b2comm_Serial.H

//------------------------------------------------------------------------
// b2comm_Serial.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_SERIAL_H_
#define B2COMM_SERIAL_H_
 
//------------------------------------------------------------------------
//
// \file
// Serial communicator encapsulation. Provides dummy communicator when
// no distributed parallel infrastructue is available.
//
//------------------------------------------------------------------------
 
#include <map>
 
#include "b2ppconfig.h"
#include "utils/b2comm.H"
 
#define B2_NOCOMM -987654
 
namespace b2000 {
 
// Dummy communication implementation, if there is no distributed memory
// parallelization available.
//
// This class realizes a dummy "communication" if there is only one process
// available.
class B2serial : public Communicator {
public:
    static constexpr bool supported = true;
 
    // A main constructor to initialize the communicator as the one of the
    // main program.
    B2serial(int argc, char* argv[]) : rank_(0), size_(1) {
        // Nothing to do for serial programs.
    }
 
    explicit B2serial() = default;
 
    ~B2serial() override{};
 
    // Rank of the running process
    int rank() const override { return rank_; }
 
    // Number of processes in the communicator
    int NumRanks() const override { return size_; }
 
    // Is running process root?
    bool IsRoot() const override { return (0 == rank_); }
 
    // Additional command line options for the communication
    void CmdOpts(cmdline::CmdLine& cmdline) override {
        // No additional command line options necessary for the MPI
        // communication.
    }
 
    // Get a communicator handle for Fortran, needed by MUMPS.
    // We return B2_NOCOMM here, which is understood by MUMPS as a special
    // value to not do communication.
    int GetFcomm() const override { return B2_NOCOMM; }
 
    // Abort the parallel execution
    void Abort(int errorcode) override {
        // Nothing to do in serial
    }
 
    // Wait on other processes
    void Barrier() override {
        // Nothing to do in serial
    }
 
    // Receive a message from rank source with tag within the communicator.
    void Recv(char buffer[], uint64_t length, int source, int tag) override {
        buffer = static_cast<char*>(buffers_[tag].ptr);
    }
 
    // Send a message to rank target with tag within the communicator.
    void Send(char buffer[], uint64_t length, int target, int tag) override {
        buffers_[tag].ptr = static_cast<void*>(buffer);
        buffers_[tag].num_bytes = length * sizeof buffer[0];
    }
 
    // Broadcast a buffer from root to all in the communicator
    // Nothing to do in serial with a single root process.
    void Bcast(uint64_t buffer[], uint64_t length, int root = 0) override {}
    void Bcast(int buffer[], uint64_t length, int root = 0) override {}
    void Bcast(double buffer[], uint64_t length, int root = 0) override {}
 
    // Probe an incoming message for its size in bytes (before calling
    // the corresponding receive).
    uint64_t ProbeByteCount(int source, int tag) override {
        return static_cast<uint64_t>(buffers_[tag].num_bytes);
    }
 
private:
    struct buffer_t {
        void* ptr;
        size_t num_bytes;
    };
 
    std::map<int, buffer_t> buffers_;
 
    // Identification of the running process
    int rank_ = 0;
 
    // Size of the Communicator
    int size_ = 1;
 
};  // class B2serial
 
}  // namespace b2000
 
#endif  // B2COMM_SERIAL_H_