b2comm.H

//------------------------------------------------------------------------
// b2comm.H
//
// written by Harald Klimach <harald.klimach@dlr.de>
//            Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
//
// (c) 2021 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//          Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of DLR.
//
//------------------------------------------------------------------------
 
#ifndef B2COMM_H_
#define B2COMM_H_
 
//------------------------------------------------------------------------
//
// \file
// Communicator system for b2000 to deal with communication between
// processes.
//
//------------------------------------------------------------------------
 
#include <memory>
 
#include "b2ppconfig.h"
#include "utils/b2cmdline.H"
#include "utils/b2object.H"
 
// \file
//
// Abstract definition of the API for distributed memory parallelization.
 
namespace b2000 {
 
// Abstract class defining the communication strategy for distributed
// memory parallelization.
class Communicator {
public:
    virtual ~Communicator(){};
 
    // Rank of the running process
    virtual int rank() const = 0;
 
    // Number of processes in this communicator
    virtual int NumRanks() const = 0;
 
    // Is the running process root of the communicator?
    virtual bool IsRoot() const = 0;
 
    // Additional command line options for the communication
    virtual void CmdOpts(cmdline::CmdLine& cmdline) = 0;
 
    // Get a communicator handle for Fortran, needed by MUMPS.
    virtual int GetFcomm() const = 0;
 
    // Abort the parallel execution.
    virtual void Abort(int errorcode) = 0;
 
    // Synchronize all processes in the communicator
    virtual void Barrier() = 0;
 
    // Receive a message from rank source with tag within the communicator.
    virtual void Recv(char buffer[], uint64_t length, int source, int tag) = 0;
 
    // Send a message to rank target with tag within the communicator.
    virtual void Send(char buffer[], uint64_t length, int target, int tag) = 0;
 
    // Broadcast a buffer from the root process to all in the communicator
    virtual void Bcast(uint64_t buffer[], uint64_t length, int root = 0) = 0;
    virtual void Bcast(int buffer[], uint64_t length, int root = 0) = 0;
    virtual void Bcast(double buffer[], uint64_t length, int root = 0) = 0;
 
    // Probe an incoming message for its size in bytes (before calling
    // the corresponding receive).
    virtual uint64_t ProbeByteCount(int source, int tag) = 0;
};  // class Communicator
 
// Creator function to decide on the actual communicator to be used.
// This depends on the compile-time environment, depending on the available
// communication layers, the appropriate Communicator implementation will
// be returned.
std::shared_ptr<Communicator> CreateComm(int argc, char* argv[]);
 
}  // namespace b2000
 
#endif  // B2COMM_H_