olb::LoadBalancer< T > Class Template Reference

Base class for all LoadBalancer. More...

#include <loadBalancer.h>

Inheritance diagram for olb::LoadBalancer< T >:

Collaboration diagram for olb::LoadBalancer< T >:

Public Member Functions
	LoadBalancer (int size=1)
	Default empty constructor.
	LoadBalancer (int size, std::map< int, int > &loc, std::vector< int > &glob, std::map< int, int > &rank)
	Constructor accepting existing balancing.
	LoadBalancer (int size, std::map< int, int > &loc, std::vector< int > &glob, std::map< int, int > &rank, std::map< int, Platform > &platform)
	Constructor accepting existing heterogeneous balancing.
virtual	~LoadBalancer ()
	Default empty destructor.
void	swap (LoadBalancer< T > &loadBalancer)
	Swap method.
bool	isLocal (const int &glob) const
	returns whether glob is on this process
bool	isLocal (Platform platform) const
	returns whether there is a block on platform in this process
int	loc (const int &glob)
int	loc (int glob) const
int	glob (int loc) const
int	rank (int glob) const
int	size () const
int	getRankSize () const
virtual Platform	platform (int loc) const
virtual void	setPlatform (int loc, Platform platform)
virtual bool	doOutput (int glob) const
virtual void	setDoOutput (int glob, bool doOutput)
bool	operator== (const LoadBalancer< T > &rhs) const
	equal operator
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	print (bool multiOutput=false) const
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 ()

Protected Attributes
int	_size
	number of cuboids after shrink -1 in appropriate thread
std::map< int, int >	_loc
	maps global cuboid to (local) thread cuboid
std::vector< int >	_glob
	content is 0,1,2,...,_size
std::map< int, int >	_rank
	maps global cuboid number to the processing thread
std::map< int, Platform >	_platform
	maps global cuboid number to local platform
std::map< int, bool >	_doOutput
	defines if global cuboid number has state doOutput
Protected Attributes inherited from olb::BufferSerializable
std::vector< bool * >	_dataBuffer
	Data buffer for data that has to be buffered between two getBlock() iterations.
std::vector< size_t >	_sizeBuffer
	std::vector of integer buffers (e.g. for std::vector size) to be buffered for the whole iteration process

Additional Inherited Members
Protected Member Functions inherited from olb::BufferSerializable
template<typename DataType >
void	registerSerializable (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register Serializable object of dynamic size.
template<typename DataType >
void	registerStdVectorOfVars (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of primitive DataType (int, double, ...)
template<typename DataType >
void	registerStdVectorOfSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of constant-sized Serializable
template<typename DataType >
void	registerStdVectorOfSerializables (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of dynamic-sized DataType
template<typename DataTypeKey , typename DataTypeValue >
void	registerMap (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::map< DataTypeKey, DataTypeValue > &data, const bool loadingMode=false)
	Method for registering a std::map<DataTypeKey, DataTypeValue> of fixed-sized types (i.e. int, double)
size_t	addSizeToBuffer (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, const size_t data) const
	Add a size_t to the sizeBuffer in the n-th util::round and return that size_t in all successive rounds.
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::LoadBalancer< T >

Base class for all LoadBalancer.

Sketch: assume we have 6 cuboids and 2 threads. Thread number 1 owns cuboid 0 and 1. Thread number 2 owns cuboid 2, 3, 4 and 5. Then we get the following configuration:

global cuboid number: 0 1 2 3 4 5 local cuboid number of thread 0: 0 1 local cuboid number of thread 1: 0 1 2 3

Parameters

_glob	is a vector from 0,1,...,numberOfCuboids-1
_loc	indicates local cuboid number in actual thread, for given global cuboid number
_rank	indicates the processing thread of a global cuboid number

Definition at line 42 of file vtiWriter.h.

Constructor & Destructor Documentation

LoadBalancer() [1/3]

template<typename T >

olb::LoadBalancer< T >::LoadBalancer

(

int

size = 1

)

Default empty constructor.

Definition at line 34 of file loadBalancer.hh.

                                      : _size(size)
{}

LoadBalancer() [2/3]

template<typename T >

olb::LoadBalancer< T >::LoadBalancer	(	int	size,
		std::map< int, int > &	loc,
		std::vector< int > &	glob,
		std::map< int, int > &	rank )

Constructor accepting existing balancing.

Definition at line 38 of file loadBalancer.hh.

  : _size(size), _loc(loc), _glob(glob), _rank(rank)
{}

LoadBalancer() [3/3]

template<typename T >

olb::LoadBalancer< T >::LoadBalancer	(	int	size,
		std::map< int, int > &	loc,
		std::vector< int > &	glob,
		std::map< int, int > &	rank,
		std::map< int, Platform > &	platform )

Constructor accepting existing heterogeneous balancing.

Definition at line 46 of file loadBalancer.hh.

  : _size(size), _loc(loc), _glob(glob), _rank(rank), _platform(platform)
{}

~LoadBalancer()

template<typename T >

olb::LoadBalancer< T >::~LoadBalancer ( )

virtual

Default empty destructor.

Definition at line 55 of file loadBalancer.hh.

{}

Member Function Documentation

doOutput()

template<typename T >

virtual bool olb::LoadBalancer< T >::doOutput ( int glob ) const

inlinevirtual

Definition at line 124 of file loadBalancer.h.

                                        {
    try {
      return _doOutput.at(glob);
    } catch (std::out_of_range& ex) {
      return true;
    }
  }

References olb::LoadBalancer< T >::_doOutput, and olb::LoadBalancer< T >::glob().

Here is the call graph for this function:

Here is the caller graph for this function:

getBlock()

template<typename T >

bool * olb::LoadBalancer< 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 155 of file loadBalancer.hh.

{
  std::size_t currentBlock = 0;
  size_t sizeBufferIndex = 0;
  bool* dataPtr = nullptr;
 
  this->registerVar<int>            (iBlock, sizeBlock, currentBlock, dataPtr, _size);
  this->registerMap<int, int>       (iBlock, sizeBlock, currentBlock, sizeBufferIndex, dataPtr, _loc, loadingMode);
  this->registerStdVectorOfVars<int>(iBlock, sizeBlock, currentBlock, sizeBufferIndex, dataPtr, _glob, loadingMode);
  this->registerMap<int, int>       (iBlock, sizeBlock, currentBlock, sizeBufferIndex, dataPtr, _rank, loadingMode);
 
  return dataPtr;
}

getNblock()

template<typename T >

size_t olb::LoadBalancer< T >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 134 of file loadBalancer.hh.

{
  return   4     // _size, plus vector length of _loc, _glob and _rank
           + _loc.size()
           + _rank.size()
           + _glob.size();
}

getRankSize()

template<typename T >

int olb::LoadBalancer< T >::getRankSize

(

)

const

Returns

read size of _rank

Definition at line 118 of file loadBalancer.hh.

{
  return _rank.size();
}

Here is the caller graph for this function:

getSerializableSize()

template<typename T >

size_t olb::LoadBalancer< T >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 144 of file loadBalancer.hh.

{
  return   sizeof(int)         // _size
           + 3 * sizeof(size_t)  // vector length of _loc, _glob and _rank
           + _loc.size() * sizeof(std::pair<int, int>)
           + _rank.size() * sizeof(std::pair<int, int>)
           + _glob.size() * sizeof(int);
}

glob()

template<typename T >

int olb::LoadBalancer< T >::glob

(

int

loc

)

const

Returns

global cuboid number of given local cuboid

Definition at line 99 of file loadBalancer.hh.

{
  return _glob[loc];
}

Here is the caller graph for this function:

isLocal() [1/2]

template<typename T >

bool olb::LoadBalancer< T >::isLocal

(

const int &

glob

)

const

returns whether glob is on this process

Definition at line 69 of file loadBalancer.hh.

{
  return rank(glob) == singleton::mpi().getRank();
}

References olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

isLocal() [2/2]

template<typename T >

bool olb::LoadBalancer< T >::isLocal

(

Platform

platform

)

const

returns whether there is a block on platform in this process

Definition at line 75 of file loadBalancer.hh.

{
  for (auto [loc, _] : _loc) {
    if (this->platform(loc) == platform) {
      return true;
    }
  }
  return false;
}

loc() [1/2]

template<typename T >

int olb::LoadBalancer< T >::loc

(

const int &

glob

)

Returns

local cuboid number of relevant thread

Definition at line 86 of file loadBalancer.hh.

{
  return _loc[glob];
}

Here is the caller graph for this function:

loc() [2/2]

template<typename T >

int olb::LoadBalancer< T >::loc

(

int

glob

)

const

Returns

local cuboid number of relevant thread

Definition at line 92 of file loadBalancer.hh.

{
  std::map<int,int>::const_iterator iter = _loc.find(glob);
  return iter->second;
}

operator==()

template<typename T >

bool olb::LoadBalancer< T >::operator==

(

const LoadBalancer< T > &

rhs

)

const

equal operator

Definition at line 124 of file loadBalancer.hh.

{
  return _size == rhs._size &&
         _loc == rhs._loc &&
         _glob == rhs._glob &&
         _rank == rhs._rank;
}

References olb::LoadBalancer< T >::_glob, olb::LoadBalancer< T >::_loc, olb::LoadBalancer< T >::_rank, and olb::LoadBalancer< T >::_size.

platform()

template<typename T >

virtual Platform olb::LoadBalancer< T >::platform ( int loc ) const

inlinevirtual

Returns

target platform for processing of local cuboid

Reimplemented in olb::HeterogeneousLoadBalancer< T >, and olb::OrthogonalHeterogeneousLoadBalancer< T >.

Definition at line 103 of file loadBalancer.h.

                                           {
    auto iter = _platform.find(glob(loc));
    if (iter != _platform.end()) {
      return std::get<1>(*iter);
    } else {
    #ifdef PLATFORM_GPU_CUDA
      return Platform::GPU_CUDA;
    #else
    #ifdef PLATFORM_CPU_SIMD
      return Platform::CPU_SIMD;
    #else
      return Platform::CPU_SISD;
    #endif
    #endif
    }
  }

References olb::LoadBalancer< T >::_platform, olb::CPU_SIMD, olb::CPU_SISD, olb::LoadBalancer< T >::glob(), olb::GPU_CUDA, and olb::LoadBalancer< T >::loc().

Here is the call graph for this function:

Here is the caller graph for this function:

print()

template<typename T >

void olb::LoadBalancer< T >::print

(

bool

multiOutput = false

)

const

Definition at line 171 of file loadBalancer.hh.

{
  OstreamManager clout(std::cout,"LoadBalancer");
  clout.setMultiOutput(multiOutput);
  for (unsigned i = 0; i < this->_glob.size(); i++) {
    clout << "glob[" << i << "]=" << this->_glob[i] << std::endl;
  }
  for (const auto& [globC, locC] : this->_loc) {
    clout << "loc[" << globC << "]=" << locC << std::endl;
  }
  for (const auto& [globC, rank] : this->_rank) {
    clout << "rank[" << globC << "]=" << rank << std::endl;
  }
  clout.setMultiOutput(false);
}

References olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

rank()

template<typename T >

int olb::LoadBalancer< T >::rank

(

int

glob

)

const

Parameters

glob	is the global cuboid number

Returns

rank that owns the given global cuboid number

Definition at line 105 of file loadBalancer.hh.

{
  std::map<int,int>::const_iterator iter = _rank.find(glob);
  return iter->second;
}

Here is the caller graph for this function:

setDoOutput()

template<typename T >

virtual void olb::LoadBalancer< T >::setDoOutput ( int glob, bool doOutput )

inlinevirtual

Definition at line 131 of file loadBalancer.h.

                                                    {
    _doOutput[glob] = doOutput;
  }

References olb::LoadBalancer< T >::_doOutput, olb::LoadBalancer< T >::doOutput(), and olb::LoadBalancer< T >::glob().

Here is the call graph for this function:

setPlatform()

template<typename T >

virtual void olb::LoadBalancer< T >::setPlatform ( int loc, Platform platform )

inlinevirtual

Reimplemented in olb::HeterogeneousLoadBalancer< T >, and olb::OrthogonalHeterogeneousLoadBalancer< T >.

Definition at line 120 of file loadBalancer.h.

                                                       {
    _platform[glob(loc)] = platform;
  }

References olb::LoadBalancer< T >::_platform, olb::LoadBalancer< T >::glob(), olb::LoadBalancer< T >::loc(), and olb::LoadBalancer< T >::platform().

Here is the call graph for this function:

size()

template<typename T >

int olb::LoadBalancer< T >::size

(

)

const

Returns

read only acess to _size

Definition at line 112 of file loadBalancer.hh.

{
  return _size;
}

Here is the caller graph for this function:

swap()

template<typename T >

void olb::LoadBalancer< T >::swap

(

LoadBalancer< T > &

loadBalancer

)

Swap method.

Definition at line 59 of file loadBalancer.hh.

{
  std::swap(_size, loadBalancer._size);
  _loc.swap(loadBalancer._loc);
  _glob.swap(loadBalancer._glob);
  _rank.swap(loadBalancer._rank);
  _platform.swap(loadBalancer._platform);
}

References olb::LoadBalancer< T >::_glob, olb::LoadBalancer< T >::_loc, olb::LoadBalancer< T >::_platform, olb::LoadBalancer< T >::_rank, and olb::LoadBalancer< T >::_size.

Here is the caller graph for this function:

Member Data Documentation

_doOutput

template<typename T >

std::map<int,bool> olb::LoadBalancer< T >::_doOutput

protected

defines if global cuboid number has state doOutput

Definition at line 72 of file loadBalancer.h.

_glob

template<typename T >

std::vector<int> olb::LoadBalancer< T >::_glob

protected

content is 0,1,2,...,_size

Definition at line 66 of file loadBalancer.h.

_loc

template<typename T >

std::map<int,int> olb::LoadBalancer< T >::_loc

protected

maps global cuboid to (local) thread cuboid

Definition at line 64 of file loadBalancer.h.

_platform

template<typename T >

std::map<int,Platform> olb::LoadBalancer< T >::_platform

protected

maps global cuboid number to local platform

Definition at line 70 of file loadBalancer.h.

_rank

template<typename T >

std::map<int,int> olb::LoadBalancer< T >::_rank

protected

maps global cuboid number to the processing thread

Definition at line 68 of file loadBalancer.h.

_size

template<typename T >

int olb::LoadBalancer< T >::_size

protected

number of cuboids after shrink -1 in appropriate thread

Definition at line 62 of file loadBalancer.h.

---

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

• src/communication/loadBalancer.h
• src/core/fieldArrayD.h
• src/core/superLattice2D.h
• src/geometry/cuboidDecomposition.h
• src/io/vtiReader.h
• src/io/vtiWriter.h
• src/communication/loadBalancer.hh