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

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

#include <column.h>

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

Collaboration diagram for olb::cpu::simd::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 ()
const T &	operator[] (std::size_t i) const override
T &	operator[] (std::size_t i) override
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::cpu::simd::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 153 of file column.h.

Member Typedef Documentation

value_t

template<typename T >

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

Definition at line 167 of file column.h.

Constructor & Destructor Documentation

CyclicColumn()

template<typename T >

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

inline

Definition at line 169 of file column.h.

                               :
    _count(getPageAlignedCount<T>(count)),
    _size(_count * sizeof(T)),
    _shift(0)
  {
  #ifdef __NR_memfd_create
    // Open anonymous file for physical lattice memory
    // Manual call of "memfd_create("openlb", MFD_CLOEXEC)" in case GLIB is old
    const int shm_file = syscall(__NR_memfd_create, "openlb", MFD_CLOEXEC);
  #else
    std::string shm_path = "/openlb_block_XXXXXX";
    const int shm_name = mkstemp(const_cast<char*>(shm_path.data()));
    if (shm_name != -1) {
      throw std::runtime_error("Could not generate unique shared memory object name");
    }
    // Open shared memory object as physical lattice memory
    const int shm_file = shm_open(shm_path.c_str(), O_CREAT | O_RDWR | O_EXCL | O_CLOEXEC, S_IRUSR | S_IWUSR);
    shm_unlink(shm_path.c_str());
  #endif
    if (shm_file == -1) {
      throw std::runtime_error("Failed to create shared memory object");
    }
 
    // Resize to fit lattice populations
    if (ftruncate(shm_file, _size) == -1) {
      throw std::runtime_error("Failed to resize shared memory object");
    }
 
    // Allocate virtual address space for q times two consecutive lattices
    _buffer = static_cast<std::uint8_t*>(
      mmap(NULL, 2 * _size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
 
    // Map single physical lattice into virtual address space
    mmap(_buffer,         _size, PROT_RW, MAP_SHARED | MAP_FIXED, shm_file, 0);
    mmap(_buffer + _size, _size, PROT_RW, MAP_SHARED | MAP_FIXED, shm_file, 0);
 
    // Store base pointer for reference
    _base = reinterpret_cast<T*>(_buffer);
    // Initialize shiftable f pointer to be used for lattice access
    _f = _base;
  }

References olb::cpu::simd::PROT_RW.

~CyclicColumn()

template<typename T >

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

inline

Definition at line 211 of file column.h.

                  {
    munmap(_buffer, 2 * _size);
  }

Member Function Documentation

getBlock()

template<typename T >

bool * olb::cpu::simd::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 77 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, *_base, 2*_count);
 
  return dataPtr;
}

getNblock()

template<typename T >

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

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 65 of file column.hh.

{
  return 3;
}

getSerializableSize()

template<typename T >

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

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 71 of file column.hh.

{
  return 2*_size + sizeof(std::ptrdiff_t) + sizeof(std::size_t);
}

operator[]() [1/2]

template<typename T >

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

inlineoverridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 215 of file column.h.

  {
    return _f[i];
  }

operator[]() [2/2]

template<typename T >

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

inlineoverridevirtual

Implements olb::AbstractCyclicColumn< T >.

Definition at line 220 of file column.h.

  {
    return _f[i];
  }

postLoad()

template<typename T >

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

inlineoverridevirtual

Reimplemented from olb::Serializable.

Definition at line 260 of file column.h.

{ refresh(); }

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

Here is the call graph for this function:

refresh()

template<typename T >

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

inline

Definition at line 230 of file column.h.

  {
    _f = _base + _shift;
  }

Here is the caller graph for this function:

resize()

template<typename T >

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

inline

Definition at line 247 of file column.h.

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

rotate()

template<typename T >

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

inline

Definition at line 235 of file column.h.

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

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

Here is the call graph for this function:

setProcessingContext()

template<typename T >

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

inline

Definition at line 252 of file column.h.

{ };

size()

template<typename T >

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

inline

Definition at line 225 of file column.h.

  {
    return _count;
  }

---

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

• src/core/platform/cpu/simd/column.h
• src/core/platform/cpu/simd/column.hh