olb::gpu::cuda::CyclicColumn< T > Class Template Reference

Virtual memory based cyclic column for usage in ColumnVector. More...

#include <column.h>

Inheritance diagram for olb::gpu::cuda::CyclicColumn< T >:

Collaboration diagram for olb::gpu::cuda::CyclicColumn< T >:

Classes
struct	Data

Public Types
using	value_t = T
Public Types inherited from olb::AbstractCyclicColumn< T >
using	value_type = T

Public Member Functions
	CyclicColumn (std::size_t count)
	~CyclicColumn ()
const T &	operator[] (std::size_t i) const override
T &	operator[] (std::size_t i) override
const T *	deviceData () const
T *	deviceData ()
std::size_t	size () const
void	refresh ()
void	rotate (std::ptrdiff_t offset)
void	resize (std::size_t count)
void	setProcessingContext (ProcessingContext)
std::size_t	getNblock () const override
	Number of data blocks for the serializable interface.
std::size_t	getSerializableSize () const override
	Binary size for the serializer.
bool *	getBlock (std::size_t iBlock, std::size_t &sizeBlock, bool loadingMode) override
	Return a pointer to the memory of the current block and its size for the serializable interface.
void	postLoad () override
Public Member Functions inherited from olb::Serializable
virtual	~Serializable ()=default
template<bool includeLogOutputDir = true>
bool	save (std::string fileName="", const bool enforceUint=false)
	Save Serializable into file fileName
template<bool includeLogOutputDir = true>
bool	load (std::string fileName="", const bool enforceUint=false)
	Load Serializable from file fileName
bool	save (std::uint8_t *buffer)
	Save Serializable into buffer of length getSerializableSize
bool	load (const std::uint8_t *buffer)
	Load Serializable from buffer of length getSerializableSize

Additional Inherited Members
Protected Member Functions inherited from olb::Serializable
template<typename DataType >
void	registerVar (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, const DataType &data, const size_t arrayLength=1) const
	Register primitive data types (int, double, ...) or arrays of those.
template<typename DataType >
void	registerSerializableOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register Serializable object of constant size.
template<typename DataType >
void	registerSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType *data, const size_t arrayLength, const bool loadingMode=false)
	Register an array of Serializable objects of constant size.

Detailed Description

template<typename T>
class olb::gpu::cuda::CyclicColumn< T >

Virtual memory based cyclic column for usage in ColumnVector.

Column type used for propagatable population storage using the virtual memory PS pattern.

Definition at line 101 of file column.h.

Member Typedef Documentation

value_t

template<typename T >

using olb::gpu::cuda::CyclicColumn< T >::value_t = T

Definition at line 116 of file column.h.

Constructor & Destructor Documentation

CyclicColumn()

template<typename T >

olb::gpu::cuda::CyclicColumn< T >::CyclicColumn

(

std::size_t

count

)

Definition at line 259 of file column.hh.

                                            :
  _count(device::getPageAlignedCount<T>(count)),
  _size(_count * sizeof(T)),
  _data(new Data(_count)),
  _shift(0)
{
  _deviceBase = reinterpret_cast<T*>(_data->ptr);
  _devicePopulation = _deviceBase;
}

~CyclicColumn()

template<typename T >

olb::gpu::cuda::CyclicColumn< T >::~CyclicColumn

(

)

Definition at line 270 of file column.hh.

{ }

Member Function Documentation

deviceData() [1/2]

template<typename T >

T * olb::gpu::cuda::CyclicColumn< T >::deviceData ( )

inline

Definition at line 129 of file column.h.

  {
    return _devicePopulation;
  }

deviceData() [2/2]

template<typename T >

const T * olb::gpu::cuda::CyclicColumn< T >::deviceData ( ) const

inline

Definition at line 124 of file column.h.

  {
    return _devicePopulation;
  }

getBlock()

template<typename T >

bool * olb::gpu::cuda::CyclicColumn< T >::getBlock ( std::size_t iBlock, std::size_t & sizeBlock, bool loadingMode )

overridevirtual

Return a pointer to the memory of the current block and its size for the serializable interface.

Implements olb::Serializable.

Definition at line 311 of file column.hh.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _shift);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _count);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, *_data->host.get(), _count);
 
  return dataPtr;
}

getNblock()

template<typename T >

std::size_t olb::gpu::cuda::CyclicColumn< T >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 299 of file column.hh.

{
  return 3;
}

getSerializableSize()

template<typename T >

std::size_t olb::gpu::cuda::CyclicColumn< T >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 305 of file column.hh.

{
  return _count * sizeof(T) + sizeof(std::ptrdiff_t) + sizeof(std::size_t);
}

operator[]() [1/2]

template<typename T >

const T & olb::gpu::cuda::CyclicColumn< T >::operator[] ( std::size_t i ) const

overridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 274 of file column.hh.

{
  return _data->host[i];
}

operator[]() [2/2]

template<typename T >

T & olb::gpu::cuda::CyclicColumn< T >::operator[] ( std::size_t i )

overridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 280 of file column.hh.

{
  return _data->host[i];
}

postLoad()

template<typename T >

void olb::gpu::cuda::CyclicColumn< T >::postLoad ( )

inlineoverridevirtual

Reimplemented from olb::Serializable.

Definition at line 169 of file column.h.

{ refresh(); }

References olb::gpu::cuda::CyclicColumn< T >::refresh().

Here is the call graph for this function:

refresh()

template<typename T >

void olb::gpu::cuda::CyclicColumn< T >::refresh ( )

inline

Definition at line 139 of file column.h.

  {
    _devicePopulation = _deviceBase + _shift;
  }

Here is the caller graph for this function:

resize()

template<typename T >

void olb::gpu::cuda::CyclicColumn< T >::resize ( std::size_t count )

inline

Definition at line 156 of file column.h.

  {
    throw std::logic_error("Cyclic column can not be resized");
  }

rotate()

template<typename T >

void olb::gpu::cuda::CyclicColumn< T >::rotate ( std::ptrdiff_t offset )

inline

Definition at line 144 of file column.h.

  {
    _shift -= offset;
    if (_shift >= _count) {
      _shift -= _count;
    }
    else if (_shift < 0) {
      _shift += _count;
    }
    refresh();
  }

References olb::gpu::cuda::CyclicColumn< T >::refresh().

Here is the call graph for this function:

setProcessingContext()

template<typename T >

void olb::gpu::cuda::CyclicColumn< T >::setProcessingContext

(

ProcessingContext

context

)

Definition at line 286 of file column.hh.

{
  switch (context) {
  case ProcessingContext::Evaluation:
    device::copyToHost(_devicePopulation, _data->host.get(), _size);
    return;
  case ProcessingContext::Simulation:
    device::copyToDevice(_data->host.get(), _devicePopulation, _size);
    return;
  }
}

References olb::gpu::cuda::device::copyToDevice(), olb::gpu::cuda::device::copyToHost(), olb::Evaluation, and olb::Simulation.

Here is the call graph for this function:

size()

template<typename T >

std::size_t olb::gpu::cuda::CyclicColumn< T >::size ( ) const

inline

Definition at line 134 of file column.h.

  {
    return _count;
  }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• src/core/platform/gpu/cuda/column.h
• src/core/platform/gpu/cuda/column.hh