These html pages are based on the
PhD thesis "Cluster-Based Parallelization of Simulations on Dynamically Adaptive Grids and Dynamic Resource Management" by Martin Schreiber.
There is also
more information and a PDF version available.
4.4 Classification of data lifetime
We continue by showing variants of how different data is accessed with a stack system.
-
(a)
- Persistent access: Persistent data is never released during a traversal by either updating
the associated data only or fetching it from one buffer and pushing it to another one.
Examples:
Structure stack: With the stack data handled during a forward and backward traversal,
fetching data from one and pushing all data to the other stack such as the structure stack
can keep the grid structure persistently in memory.
Cell data stack: This stack stores the data which is stored for every cell, e.g. the DoF stored
for the DG simulation. This data can be kept persistently either by updating the data on
the stacks or by copying the data from one source stack to another destination stack and
using the destination as the source stack in the next traversals.
-
(b)
- Semi-persistent access: For this type of access, we distinguish between creating access
and clearing access, respectively, for the forward and backward traversal:
- Creating access:
For communication via edges and vertices, the data is first created with a forward
traversal and stored to an additional buffer for reusage during backward traversal.
Examples:
Flux preprocessing: Nodal quadrature points on the edges are stored during the forward
traversal .
Vertex computations: Storing surface vertex data, e.g. for visualization: initialization
and updating such data stored at vertices shared by cells.
- Clearing access:
A clearing access starts with an already filled buffer and reads the data resulting in
an empty buffer.
Examples:
Flux postprocessing: After the forward traversal and flux computations, the flux
updates are fetched from the buffers and are further processed with time step
integration for the cells.
Vertex computations: With the vertex data stored to the buffer system during the
forward traversal, it is fetched from the buffer system for processing, e.g. writing vertex
data to a vertex buffer array, resulting in an empty buffer system.
-
(c)
- Non-persistent access:
This access starts with an empty stack and finishes with an empty stack. Thus, it is an interplay
of creating and clearing accesses.
Adaptivity information: To refine or coarsen cells, adaptivity information requesting refinement or
coarsening for cells is forwarded to adjacent cells via a stack system with the adjacent cell’s
adaptivity states immediately updated. After either the forward or backward traversal is finished,
the stack is empty.
This work puts its focus on data which has persistent cell- and structure-stacks only.
The other stacks are assumed to be semi-persistent such as the edge communication data.
Here, we describe two ways how to handle persistent edge and node data with a stack
system:
- The first approach is storing the node and edge data in cell data, resulting in as many
duplicates as cells share the node or edge primitives. This approach is directly applicable
with this development by mapping cell data to edges and vertices.
- A second approach uses stack systems for storing node and edge data only once and
separated from the cell data. This avoids storing duplicated data in grid cells resulting in
less memory consumption. The Peano framework [Nec09,Wei09] uses a storage system for
such persistent vertices. An implementation with the serial version using the Sierpiński
SFC can be e.g. found in [Vig12] and is not part of this thesis.