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

#include <column.h>

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

Collaboration diagram for olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >:

Public Member Functions
	ConcreteCommunicatable (cpu::simd::CyclicColumn< T > &column)
std::size_t	size (ConstSpan< CellID > indices) const
	Get serialized size for data at locations indices
std::size_t	serialize (ConstSpan< CellID > indices, std::uint8_t *buffer) const
	Serialize data at locations indices to buffer
std::size_t	deserialize (ConstSpan< CellID > indices, const std::uint8_t *buffer)
	Deserialize data at locations indices to buffer
Public Member Functions inherited from olb::Communicatable
virtual	~Communicatable ()

Detailed Description

template<typename T>
class olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >

Definition at line 282 of file column.h.

Constructor & Destructor Documentation

ConcreteCommunicatable()

template<typename T >

olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >::ConcreteCommunicatable ( cpu::simd::CyclicColumn< T > & column )

inline

Definition at line 287 of file column.h.

                                                        :
    _column{column} { }

Member Function Documentation

deserialize()

template<typename T >

std::size_t olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >::deserialize ( ConstSpan< CellID > indices, const std::uint8_t * buffer )

inlinevirtual

Deserialize data at locations indices to buffer

Implements olb::Communicatable.

Definition at line 327 of file column.h.

  {
    if (meta::is_aligned<T>(buffer)) {
      const T* source = reinterpret_cast<const T*>(buffer);
      const typename cpu::simd::Pack<T>::index_t* offsets = indices.data();
 
      for (std::size_t i=0;
           i < (indices.size() / cpu::simd::Pack<T>::size) * cpu::simd::Pack<T>::size;
           i       += cpu::simd::Pack<T>::size,
           source  += cpu::simd::Pack<T>::size,
           offsets += cpu::simd::Pack<T>::size) {
        cpu::simd::store(&_column[0], cpu::simd::Pack<T>{source}, offsets);
      }
      for (std::size_t i=(indices.size() / cpu::simd::Pack<T>::size) * cpu::simd::Pack<T>::size;
           i < indices.size();
           ++i) {
        _column[indices[i]] = *(source++);
      }
    } else {
      const std::uint8_t* source = buffer;
      for (CellID index : indices) {
        std::memcpy(reinterpret_cast<void*>(&_column[index]), source, sizeof(T));
        source += sizeof(T);
      }
    }
    return indices.size() * sizeof(T);
  }

References olb::ConstSpan< T >::data(), olb::ConstSpan< T >::size(), and olb::cpu::simd::store().

Here is the call graph for this function:

serialize()

template<typename T >

std::size_t olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >::serialize ( ConstSpan< CellID > indices, std::uint8_t * buffer ) const

inlinevirtual

Serialize data at locations indices to buffer

Implements olb::Communicatable.

Definition at line 297 of file column.h.

  {
    if (meta::is_aligned<T>(buffer)) {
      T* target = reinterpret_cast<T*>(buffer);
      const typename cpu::simd::Pack<T>::index_t* offsets = indices.data();
 
      for (std::size_t i=0;
           i < (indices.size() / cpu::simd::Pack<T>::size) * cpu::simd::Pack<T>::size;
           i       += cpu::simd::Pack<T>::size,
           target  += cpu::simd::Pack<T>::size,
           offsets += cpu::simd::Pack<T>::size) {
        cpu::simd::store(target, {&_column[0], offsets});
      }
      for (std::size_t i=(indices.size() / cpu::simd::Pack<T>::size) * cpu::simd::Pack<T>::size;
           i < indices.size();
           ++i) {
        *(target++) = _column[indices[i]];
      }
    } else {
      std::uint8_t* target = buffer;
      for (CellID index : indices) {
        std::memcpy(target, reinterpret_cast<const void*>(&_column[index]), sizeof(T));
        target += sizeof(T);
      }
    }
    return indices.size() * sizeof(T);
  }

References olb::ConstSpan< T >::data(), olb::ConstSpan< T >::size(), and olb::cpu::simd::store().

Here is the call graph for this function:

size()

template<typename T >

std::size_t olb::ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >::size ( ConstSpan< CellID > indices ) const

inlinevirtual

Get serialized size for data at locations indices

Implements olb::Communicatable.

Definition at line 291 of file column.h.

  {
    return indices.size() * sizeof(T);
  }

References olb::ConstSpan< T >::size().

Here is the call graph for this function:

---

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

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