olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > > Class Template Reference

#include <blockLattice.h>

Inheritance diagram for olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >:

Collaboration diagram for olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >:

Classes
struct	CopyTask
	Wrapper for a local plain-copy block communication request. More...
class	HomogeneousCopyTask
	Wrapper for a local homogeneous CPU block communication request. More...
class	RecvTask
	Wrapper for a non-blocking block propagation receive request. More...
class	SendTask
	Wrapper for a non-blocking block propagation send request. More...

Public Member Functions
	ConcreteBlockCommunicator (SuperLattice< T, DESCRIPTOR > &super, LoadBalancer< T > &loadBalancer, SuperCommunicationTagCoordinator< T > &tagCoordinator, MPI_Comm comm, int iC, const BlockCommunicationNeighborhood< T, DESCRIPTOR::d > &neighborhood)
	~ConcreteBlockCommunicator ()
void	receive () override
void	send () override
void	unpack () override
void	wait () override
Public Member Functions inherited from olb::BlockCommunicator
virtual	~BlockCommunicator ()

Detailed Description

template<typename T, typename DESCRIPTOR, Platform PLATFORM>
class olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >

Definition at line 698 of file blockLattice.h.

Constructor & Destructor Documentation

ConcreteBlockCommunicator()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::ConcreteBlockCommunicator	(	SuperLattice< T, DESCRIPTOR > &	super,
		LoadBalancer< T > &	loadBalancer,
		SuperCommunicationTagCoordinator< T > &	tagCoordinator,
		MPI_Comm	comm,
		int	iC,
		const BlockCommunicationNeighborhood< T, DESCRIPTOR::d > &	neighborhood )

Definition at line 741 of file blockLattice.hh.

                                                                    :
  _iC(iC)
#ifdef PARALLEL_MODE_MPI
, _mpiCommunicator(comm)
#endif
{
#ifdef PARALLEL_MODE_MPI
  neighborhood.forNeighbors([&](int remoteC) {
    if (loadBalancer.isLocal(remoteC)) {
      const Platform remotePlatform = loadBalancer.platform(loadBalancer.loc(remoteC));
      if (!neighborhood.getCellsInboundFrom(remoteC).empty()) {
        switch (remotePlatform) {
#ifdef PLATFORM_GPU_CUDA
          case Platform::GPU_CUDA:
            // Use manual copy for local GPU-CPU communication due to better performance
            _copyTasks.emplace_back(new HeterogeneousCopyTask<T,DESCRIPTOR,Platform::GPU_CUDA,PLATFORM>(
              neighborhood.getFieldsCommonWith(remoteC),
              neighborhood.getCellsInboundFrom(remoteC),   super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(_iC),
              neighborhood.getCellsRequestedFrom(remoteC), super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,Platform::GPU_CUDA>>(loadBalancer.loc(remoteC))));
            break;
#endif
          default:
            // Use manual copy for local CPU-CPU communication due to better performance
            _copyTasks.emplace_back(new HomogeneousCopyTask(
              neighborhood.getFieldsCommonWith(remoteC),
              neighborhood.getCellsInboundFrom(remoteC),   super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(_iC),
              neighborhood.getCellsRequestedFrom(remoteC), super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(loadBalancer.loc(remoteC))));
            break;
        }
      }
    } else {
      if (!neighborhood.getCellsOutboundTo(remoteC).empty()) {
        _sendTasks.emplace_back(std::make_unique<SendTask>(
          _mpiCommunicator, tagCoordinator.get(loadBalancer.glob(_iC), remoteC),
          loadBalancer.rank(remoteC),
          neighborhood.getFieldsCommonWith(remoteC),
          neighborhood.getCellsOutboundTo(remoteC),
          super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(_iC)));
      }
      if (!neighborhood.getCellsInboundFrom(remoteC).empty()) {
        _recvTasks.emplace_back(std::make_unique<RecvTask>(
          _mpiCommunicator, tagCoordinator.get(remoteC, loadBalancer.glob(_iC)),
          loadBalancer.rank(remoteC),
          neighborhood.getFieldsCommonWith(remoteC),
          neighborhood.getCellsInboundFrom(remoteC),
          super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(_iC)));
      }
    }
  });
 
#else // not using PARALLEL_MODE_MPI
  neighborhood.forNeighbors([&](int localC) {
    if (!neighborhood.getCellsInboundFrom(localC).empty()) {
      _copyTasks.emplace_back(new HomogeneousCopyTask(
        neighborhood.getFieldsCommonWith(localC),
        neighborhood.getCellsInboundFrom(localC),   super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(_iC),
        neighborhood.getCellsRequestedFrom(localC), super.template getBlock<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>>(loadBalancer.loc(localC))));
    }
  });
#endif
}

References olb::BlockCommunicationNeighborhood< T, D >::forNeighbors(), olb::BlockCommunicationNeighborhood< T, D >::getCellsInboundFrom(), olb::BlockCommunicationNeighborhood< T, D >::getCellsOutboundTo(), and olb::LoadBalancer< T >::isLocal().

Here is the call graph for this function:

~ConcreteBlockCommunicator()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::~ConcreteBlockCommunicator

(

)

Definition at line 812 of file blockLattice.hh.

{ }

Member Function Documentation

receive()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::receive ( )

overridevirtual

Implements olb::BlockCommunicator.

Definition at line 818 of file blockLattice.hh.

{
  for (auto& task : _recvTasks) {
    task->receive();
  }
}

References olb::ConcreteBlockCommunicator< BLOCK >::receive().

Here is the call graph for this function:

send()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::send ( )

overridevirtual

Implements olb::BlockCommunicator.

Definition at line 826 of file blockLattice.hh.

{
  for (auto& task : _sendTasks) {
    task->send();
  }
  for (auto& task : _copyTasks) {
    task->copy();
  }
}

References olb::ConcreteBlockCommunicator< BLOCK >::send().

Here is the call graph for this function:

unpack()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::unpack ( )

overridevirtual

Implements olb::BlockCommunicator.

Definition at line 837 of file blockLattice.hh.

{
  std::set<typename RecvTask::ref> pending(_recvTasks.begin(), _recvTasks.end());
  while (!pending.empty()) {
    auto task_iterator = pending.begin();
    while (task_iterator != pending.end()) {
      auto& task = *task_iterator;
      if (task->isDone()) {
        task->unpack();
        task_iterator = pending.erase(task_iterator);
      }
      else {
        ++task_iterator;
      }
    }
  }
}

wait()

template<typename T , typename DESCRIPTOR , Platform PLATFORM>

void olb::ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >::wait ( )

overridevirtual

Implements olb::BlockCommunicator.

Definition at line 856 of file blockLattice.hh.

{
  for (auto& task : _copyTasks) {
    task->wait();
  }
  for (auto& task : _sendTasks) {
    task->wait();
  }
}

References olb::ConcreteBlockCommunicator< BLOCK >::wait().

Here is the call graph for this function:

---

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

• src/core/blockLattice.h
• src/core/blockLattice.hh