
\subsection{Improving cache-efficiency}

\begin{frame}{In-cache computing}

So far we have assumed that the problem does not fit in cache
\begin{itemize}[<+->]
\item so we had $H<n/P$ or $H<m/P$ if the $m$ nonzeros in the matrix are not implicit
\item if $H>n/P$, we can keep data cache-resident between SpMVs
\item we get better cache complexity without reducing synchronizations
\item the memory-bandwidth cost would be proportional to interprocessor communication and insignificant if $\nu<\beta$
\item we can also leverage cache-residency also when $H>m/P$ 
\item idea: block-cyclic layout - subdivide mesh in $n/b$ chunks so $H>b/P$
\end{itemize}

\end{frame}

\begin{frame}{Global block-cyclic partitioning}

\centering
\includegraphics[width=4.5in]{diagrams/memband_alg_s8}

\end{frame}


\begin{frame}{Global block-cyclic partitioning schedule}

\centering
\includegraphics[width=4.5in]{diagrams/memband_alg_s8_jim}

\end{frame}
\begin{frame}{Global block-cyclic partitioning analysis}

Maintain cache residency by selecting chunks of size $b$ with $H>b/P$
\begin{itemize}[<+->]
\item can reduce memory bandwidth cost by up to $O(H^{1/d})$ or down to interprocessor communication cost
\item however, we incur $n/b$ more synchronizations
\item incur more interprocessor communication depending on $H$, finer partitioning $\Rightarrow$ larger total boundary
\item algorithm is a good idea when $kH=n/P$ for small $k$
\end{itemize}
\end{frame}

\subsection{Challenges}

\begin{frame}{Problems with partitioning real iterative methods}

In-time blocking is hard for real applications
\begin{itemize}[<+->]
\item we already noted the interprocessor communication overhead 
\item determining import region is expensive for irregular mesh/graph
\item some iterative methods require computing a norm after every SpMV
\item other iterative methods require orthogonalization after every SpMV
\item there is ongoing research on modifying iterative methods such as biconjugate gradient (which is not orthogonalized) to allow in-time blocking while preserving convergence guarantees
\item preconditioning and higher order methods, which make information propagate through the mesh {\it faster} make in-time blocking more expensive, as it works better for {\it slower} movement of information
\end{itemize}


\end{frame}

\begin{frame}{Asynchronous iterative methods}

Idea: avoid explicit synchronization by using latest-available values to apply stencil
\begin{itemize}[<+->]
\item i.e. mix Gauss-Seidel / Bellman-Ford iterations arbitrarily
\item avoid `explicit' synchronization, but still send the same number of messages on a parallel system
\item sensible in the presence of noise, soft-failures, or load-imbalance
\item possible when on a shared memory-system or with one-sided communication on a distributed system
\item benefit not reflected on most parallelism/communication models
\item affects stability, past and ongoing research on designing asynchronous methods and bounding error
\end{itemize}
\end{frame}

\begin{frame}{Multigrid}

We can reduce communication in iterative methods the same way as computation
\begin{itemize}[<+->]
\item improve convergence rate - lower number of SpMVs
\item multigrid methods leverage a hierarchy of grids to accelerate convergence
\begin{itemize}
\item perform smoothing on fine grid (e.g. stencil applications)
\item restrict residual to coarser grid
\item interpolate correction back to fine grid
\item perform smoothing again
\end{itemize}
\item asymptotic view: restriction/interpolation as hard as smoothing
\item grid hierarchy construction can be done `offline'
\item for detailed analysis, see recent paper: ``Ballard, Siefert, and Hu, 2016. Reducing communication costs for sparse matrix multiplication within algebraic multigrid''
\end{itemize}

\end{frame}
