builtin_pattern.tex

\documentclass{report}
\usepackage{xcolor}
\usepackage{listings}

\newcommand{\concept}[1]{\fontfamily{pcr}{\selectfont #1}}

\input{lststyle_hir.tex}

\begin{document}

Built-ins in LFRic and PSyclone are dof-wise (point-wise) operations
used for arithmetic operations on fields (e.g. adding, subtracting, 
scaling, inner product). They can write the result of the operation 
in a new quantity (e.g. $Z = X + Y$) or they can just
update one of the input arguments (e.g. $X = X + Y$).

\begin{lstlisting}[style=dsl]
computation BuiltIn():
  field x, y, z
  field
  
  
  iterationSpace = DofMap
  
  
  dofmap = {z.function_space.last_dof
            # last_dof can be owned or annexed,
            # sanity check that all fields
            # are on the same function space
           }
  
  forall df in dofmap:
    z.data[df] = Operation(\ 
       x.data[df], y.data[df])

\end{lstlisting}

or

\begin{lstlisting}[style=dsl]
computation BuiltIn{
  field x, y, z
  field entities
  
  entities = UniqueDofs(owned, annexed)
  
  iterationSpace = {
    BuiltIn(z) = Operation<entities>(y, z; +, -, *, /)
  }
}
\end{lstlisting}

BuiltIns which take fields and return scalars effectively 
perform global sums (such as sum of a field or an inner product).
This process can be performed over local sums as shown below.
\begin{lstlisting}[style=dsl]
computation ReductionBuiltIn():
  field y, z
  field dofmap
  scalar lsum, sum
  
  dofmap = {z.function_space.last_dof
            # last_dof is always owned,
            # sanity check that all fields
            # are on the same function space
           }
  
  # OMP parallel do
  forall df in dofmap:
    lsum[thread_id] = lsum[thread_id] + \
       Operation(\x.data[df], y.data[df])
       
   
  forall thread_id in threads:
    sum = sum + lsum[thread_id] 

\end{lstlisting}

or

\begin{lstlisting}[style=dsl]
computation reductionBuiltIn{
  field x, y
  scalar lsum, reductionBuiltIn
  field entities
  
  entities = UniqueDofs(owned, annexed)
  
  iterationSpace = {
    lsum = Operation<entities>(x, y; inner_product, [])
    reductionBuiltIn(sum) = reduction<lsum(:)>
  }                  
}
\end{lstlisting}

Whether the unique dofs are accessed up to owned or annexed dofs can be 
controlled by PSyclone.

\subsection{Data Structure}
\begin{itemize}
\item Field data defined with \concept{Dofmap}
\end{itemize}


\subsection{Dimensionality}
\begin{itemize}
\item All 3D degrees of freedom.
\end{itemize}

\subsection{Access Pattern}
\begin{itemize}
\item Point-wise operations without neighbours, operate over unique dofs.
\end{itemize}

Functionality to get last dof (owned, annexed and at defined depth)
is stored in function space object.

\end{document}