olb::cpu::sisd::CyclicColumn< T > Class Template Reference

Cyclic column for usage in ColumnVector. More...

#include <column.h>

Inheritance diagram for olb::cpu::sisd::CyclicColumn< T >:

Collaboration diagram for olb::cpu::sisd::CyclicColumn< T >:

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 (CyclicColumn< T > &&rhs)
	~CyclicColumn ()=default
const T &	operator[] (std::size_t i) const override
T &	operator[] (std::size_t i) override
std::size_t	size () const override
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::AbstractCyclicColumn< T >
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::cpu::sisd::CyclicColumn< T >

Cyclic column for usage in ColumnVector.

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

Definition at line 129 of file column.h.

Member Typedef Documentation

value_t

template<typename T >

using olb::cpu::sisd::CyclicColumn< T >::value_t = T

Definition at line 140 of file column.h.

Constructor & Destructor Documentation

CyclicColumn() [1/2]

template<typename T >

olb::cpu::sisd::CyclicColumn< T >::CyclicColumn ( std::size_t count )

inline

Definition at line 142 of file column.h.

                               :
    _count(count),
    _data(new T[count] {}),
    _shift(0),
    _remainder(count)
  {
    refresh();
  }

CyclicColumn() [2/2]

template<typename T >

olb::cpu::sisd::CyclicColumn< T >::CyclicColumn ( CyclicColumn< T > && rhs )

inline

Definition at line 151 of file column.h.

                                     :
    _count(rhs._count),
    _data(rhs._data.release()),
    _shift(rhs._shift),
    _remainder(rhs._remainder)
  {
    refresh();
  }

References olb::cpu::sisd::CyclicColumn< T >::refresh().

Here is the call graph for this function:

~CyclicColumn()

template<typename T >

olb::cpu::sisd::CyclicColumn< T >::~CyclicColumn ( )

default

Member Function Documentation

getBlock()

template<typename T >

bool * olb::cpu::sisd::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 79 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.get(), _count);
 
  return dataPtr;
}

getNblock()

template<typename T >

std::size_t olb::cpu::sisd::CyclicColumn< T >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 67 of file column.hh.

{
  return 3;
}

getSerializableSize()

template<typename T >

std::size_t olb::cpu::sisd::CyclicColumn< T >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 73 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::cpu::sisd::CyclicColumn< T >::operator[] ( std::size_t i ) const

inlineoverridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 162 of file column.h.

  {
    return (i > _remainder ? _start[1] : _start[0])[i];
  }

operator[]() [2/2]

template<typename T >

T & olb::cpu::sisd::CyclicColumn< T >::operator[] ( std::size_t i )

inlineoverridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 167 of file column.h.

  {
    return (i > _remainder ? _start[1] : _start[0])[i];
  }

postLoad()

template<typename T >

void olb::cpu::sisd::CyclicColumn< T >::postLoad ( )

inlineoverridevirtual

Reimplemented from olb::Serializable.

Definition at line 219 of file column.h.

{ refresh(); }

References olb::cpu::sisd::CyclicColumn< T >::refresh().

Here is the call graph for this function:

refresh()

template<typename T >

void olb::cpu::sisd::CyclicColumn< T >::refresh ( )

inline

Definition at line 177 of file column.h.

  {
    const std::ptrdiff_t n = size();
    T* const base = _data.get();
    if (_shift >= 0) {
      _remainder = n - _shift - 1;
      _start[0] = base + _shift;
      _start[1] = base - (n - _shift);
    }
    else {
      _remainder = -_shift - 1;
      _start[0] = base + (n + _shift);
      _start[1] = base + _shift;
    }
  }

References olb::cpu::sisd::CyclicColumn< T >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

resize()

template<typename T >

void olb::cpu::sisd::CyclicColumn< T >::resize ( std::size_t count )

inline

Definition at line 206 of file column.h.

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

rotate()

template<typename T >

void olb::cpu::sisd::CyclicColumn< T >::rotate ( std::ptrdiff_t offset )

inline

Definition at line 193 of file column.h.

  {
    const std::ptrdiff_t n = size();
    _shift -= offset;
    if (_shift >= n) {
      _shift -= n;
    }
    else if (_shift <= -n) {
      _shift += n;
    }
    refresh();
  }

References olb::cpu::sisd::CyclicColumn< T >::refresh(), and olb::cpu::sisd::CyclicColumn< T >::size().

Here is the call graph for this function:

setProcessingContext()

template<typename T >

void olb::cpu::sisd::CyclicColumn< T >::setProcessingContext ( ProcessingContext )

inline

Definition at line 211 of file column.h.

{ };

size()

template<typename T >

std::size_t olb::cpu::sisd::CyclicColumn< T >::size ( ) const

inlineoverridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 172 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/cpu/sisd/column.h
• src/core/platform/cpu/sisd/column.hh