olb::ConcreteBlockMask< T, Platform::CPU_SIMD > Class Template Reference

#include <mask.h>

Inheritance diagram for olb::ConcreteBlockMask< T, Platform::CPU_SIMD >:

Collaboration diagram for olb::ConcreteBlockMask< T, Platform::CPU_SIMD >:

Public Member Functions
	ConcreteBlockMask (std::size_t size)
	ConcreteBlockMask (const ConcreteBlockMask &rhs)
bool	operator[] (std::size_t i) const
std::size_t	weight () const
void	set (std::size_t i, bool active)
auto *	raw ()
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.
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
virtual void	postLoad ()

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::ConcreteBlockMask< T, Platform::CPU_SIMD >

Definition at line 33 of file mask.h.

Constructor & Destructor Documentation

ConcreteBlockMask() [1/2]

template<typename T >

olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::ConcreteBlockMask ( std::size_t size )

inline

Definition at line 45 of file mask.h.

                                   :
    _size(size + cpu::simd::Pack<T>::size),
    _weight(0),
    _mask(_size),
    _serializedSize((_size + cpu::simd::Pack<T>::size - 1) / cpu::simd::Mask<T>::storage_size + 1),
    _serialized(new typename cpu::simd::Mask<T>::storage_t[_serializedSize] { }),
    _modified(true)
  { }

ConcreteBlockMask() [2/2]

template<typename T >

olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::ConcreteBlockMask ( const ConcreteBlockMask< T, Platform::CPU_SIMD > & rhs )

inline

Definition at line 54 of file mask.h.

                                                 :
    _size(rhs._size),
    _weight(rhs._size),
    _mask(rhs._mask),
    _serializedSize(rhs._serializedSize),
    _serialized(new typename cpu::simd::Mask<T>::storage_t[_serializedSize] { }),
    _modified(rhs._modified)
  {
    std::copy(rhs._serialized.get(),
              rhs._serialized.get() + _serializedSize,
              _serialized.get());
  }

Member Function Documentation

getBlock()

template<typename T >

bool * olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::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 125 of file mask.h.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _weight);
  registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, _mask, loadingMode);
 
  return dataPtr;
}

getNblock()

template<typename T >

std::size_t olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 113 of file mask.h.

{
  return 1 + _mask.getNblock();
}

getSerializableSize()

template<typename T >

std::size_t olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 119 of file mask.h.

{
  return sizeof(_weight) + _mask.getSerializableSize();
}

operator[]()

template<typename T >

bool olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::operator[] ( std::size_t i ) const

inline

Definition at line 67 of file mask.h.

                                     {
    return _mask[i];
  }

raw()

template<typename T >

auto * olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::raw ( )

inline

Definition at line 85 of file mask.h.

  {
    if constexpr (cpu::simd::Mask<T>::storage_size == 1) {
      return _mask.data(); // Transparently convert bools to std::uint64_t for AVX2
    } else {
      return _serialized.get(); // Use serialized bit-mask for AVX-512
    }
  }

References olb::cpu::simd::Column< T >::data().

Here is the call graph for this function:

set()

template<typename T >

void olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::set ( std::size_t i, bool active )

inline

Definition at line 75 of file mask.h.

                                     {
           if ( _mask[i] && !active) {
      _weight -= 1;
    } else if (!_mask[i] &&  active) {
      _weight += 1;
    }
    _mask[i] = active;
    _modified = true;
  }

setProcessingContext()

template<typename T >

void olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::setProcessingContext ( ProcessingContext )

inline

Definition at line 94 of file mask.h.

                                               {
    if (_modified) {
      for (std::size_t i=0; i < _size; i += cpu::simd::Mask<T>::storage_size) {
        _serialized[i / cpu::simd::Mask<T>::storage_size] = cpu::simd::Mask<T>::encode(_mask.data() + i);
      }
      _modified = false;
    }
  }

References olb::cpu::simd::Column< T >::data().

Here is the call graph for this function:

weight()

template<typename T >

std::size_t olb::ConcreteBlockMask< T, Platform::CPU_SIMD >::weight ( ) const

inline

Definition at line 71 of file mask.h.

                           {
    return _weight;
  }

---

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

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