Peano

Searching...

No Matches

Representation of a number of cells which contains all information that's required to process the stored patches or polynomial shape functions (given you know the semantics of the data). More...

#include <CellData.h>

Collaboration diagram for exahype2::CellData< inType, outType >:

[legend]

Public Member Functions
	CellData (inType QIn_, const tarch::la::Vector< Dimensions, double > &cellCentre_, const tarch::la::Vector< Dimensions, double > &cellSize_, double t_, double dt_, outType QOut_, tarch::MemoryLocation memoryLocation_=tarch::MemoryLocation::Heap, int targetDevice_=tarch::accelerator::Device::HostDevice)
	Construct patch data object for one single cell.

	CellData (int numberOfCells_, tarch::MemoryLocation memoryLocation=tarch::MemoryLocation::Heap, int targetDevice=tarch::accelerator::Device::HostDevice)

	CellData (const CellData< inType, outType > &copy)=delete

	~CellData ()

std::string	toString () const

Static Public Member Functions
static int	in (int index[Dimensions+2])

static int	out (int index[Dimensions+2])

Data Fields
inType **	QIn
	QIn may not be const, as some kernels delete it straightaway once the input data has been handled.

tarch::la::Vector< Dimensions, double > *	cellCentre

tarch::la::Vector< Dimensions, double > *	cellSize

double *	t

double *	dt

int *	id
	Id of underlying task.

const int	numberOfCells
	As we store data as SoA, we have to know how big the actual arrays are.

const tarch::MemoryLocation	memoryLocation
	We might want to allocate data on the heap or an accelerator, therefore we save the target device id.

const int	targetDevice
	We might want to allocate data on an accelerator, therefore we save the target device id.

outType **	QOut
	Out values.

double *	maxEigenvalue
	Out values.

Detailed Description

template<typename inType = double, typename outType = double>
struct exahype2::CellData< inType, outType >

Representation of a number of cells which contains all information that's required to process the stored patches or polynomial shape functions (given you know the semantics of the data).

This struct is a mixture of AoS and SoA. All data besides the Qin and result are SoA. The reason for this "inconsistent" model is that we want to transfer the patch data to accelerators quickly, while we also want to avoid to copy too much stuff around. So we leave the big input fields and basically manage just pointers to that. All scalar or small vector data are converted in SoA which makes it fairly straightforward later to move them over to an accelerator.

Memory responsibility

The PatchData object is a meta object. It does not administer any major heap data itself. That is, its QIn data has to be redirected to the reconstructed data, i.e. the patch data including the halos, by the user. This happens for example in applyKernelToCell() where we create a PatchData object over both allocated input and output data.

As the PatchData does maintain some internal tables which are allocated in the constructor and freed in the destructor, I do not provide a copy constructor. This one is explicitly deleted. Some backends might require a copy constructor one day

exahype2::CellData::CellData( const CellData& copy ):
  CellData(copy.numberOfCells) {
  for (int i=0; i<numberOfCells; i++) {
    QIn[i]           = copy.QIn[i];
    cellCentre[i]    = copy.cellCentre[i];
    cellSize[i]      = copy.cellSize[i];
    t[i]             = copy.t[i];
    dt[i]            = copy.dt[i];
    id[i]            = copy.id[i];
    QOut[i]          = copy.QOut[i];
    maxEigenvalue[i] = copy.maxEigenvalue[i];
  }
}

but for the time being, I do not offer such a variant.

SYCL

If you use SYCL, you might be tempted to declare the class as copyable. This is factually wrong: the class is not trivially copyable.

#if defined(SharedSYCL)
#include "tarch/accelerator/sycl/Device.h"
template<>
struct sycl::is_device_copyable<exahype2::CellData>: std::true_type {};
#endif

hence makes the file compile, but in all tests that I ran the code then did crash.

Definition at line 77 of file CellData.h.