cl_Communicator.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef BELFEM_CL_COMMUNICATOR_HPP
#define BELFEM_CL_COMMUNICATOR_HPP
 
#include <string>
#ifdef BELFEM_MPI
#include <mpi.h>
#define COMM_TYPE MPI_Comm
#else
#define COMM_TYPE int
#endif
 
#include <random>
#include "typedefs.hpp"
 
#include "cl_Cell.hpp"
 
 
namespace  belfem
{
//------------------------------------------------------------------------------
 
    class CommunicationObject
    {
        index_t mIndex ;
 
    public:
 
        CommunicationObject();
 
        ~CommunicationObject();
 
        virtual void
        free();
 
        index_t
        index() const ;
    };
 
    class CommunicationObject ;
 
//------------------------------------------------------------------------------
    class Communicator
    {
        std::string mExecutablePath;
        std::string mWorkDir;
        std::string mArgumentString = "";
 
        Cell<COMM_TYPE>   mComms;
 
        proc_t mCommRank = gNoOwner ;
        proc_t mSize = gNoOwner ;
        proc_t mNodeSize = 1 ;
        Cell< string > mArguments ;
 
        int mMaxTag ;
 
        std::mt19937 mRandom;
 
        Cell< CommunicationObject * > mObjects ;
 
//------------------------------------------------------------------------------
    public:
//------------------------------------------------------------------------------
 
        Communicator(){};
 
//------------------------------------------------------------------------------
 
        Communicator(
                int argc, char ** argv );
 
//------------------------------------------------------------------------------
 
        ~Communicator();
 
//------------------------------------------------------------------------------
 
        Communicator( const Communicator & ) = delete;
        Communicator & operator=( const Communicator & ) = delete;
        Communicator( Communicator && ) = delete;
        Communicator & operator=( Communicator && ) = delete;
 
//------------------------------------------------------------------------------
 
        void
        init( int & argc, char ** & argv );
 
//-----------------------------------------------------------------------------
 
        int
        finalize();
 
//-----------------------------------------------------------------------------
 
        COMM_TYPE &
        world();
 
//-----------------------------------------------------------------------------
 
        const std::string &
        exec_path();
 
//-----------------------------------------------------------------------------
 
        const std::string &
        workdir();
 
//-----------------------------------------------------------------------------
 
        const std::string &
        argument_string();
//-----------------------------------------------------------------------------
 
        Cell< std::string > &
        arguments();
 
//-----------------------------------------------------------------------------

        void
        set_arguments( const string & aArguments );
 
//-----------------------------------------------------------------------------
 
        proc_t
        rank() const;
 
//-----------------------------------------------------------------------------
 
        proc_t
        size() const;
 
//-----------------------------------------------------------------------------

        proc_t
        node_size() const;
 
//-----------------------------------------------------------------------------
 
        inline std::mt19937 &
        random()
        {
             return mRandom ;
        }
 
        inline int
        max_tag() const
        {
            return mMaxTag ;
        }
 
        inline
        Cell< CommunicationObject * > &
        objects();
 
 
    private:
 
        int
        init_thread(  int & argc, char ** & argv );
 
        void
        set_globals();
    };
//------------------------------------------------------------------------------
 
    inline proc_t
    Communicator::rank() const
    {
        return mCommRank ;
    }
 
//-----------------------------------------------------------------------------
 
    inline proc_t
    Communicator::size() const
    {
        return mSize ;
    }
 
//-----------------------------------------------------------------------------
 
    inline proc_t
    Communicator::node_size() const
    {
        return mNodeSize ;
    }
 
    inline Cell< CommunicationObject * > &
    Communicator::objects()
    {
        return mObjects ;
    }
 
//-----------------------------------------------------------------------------
}
 
// Externally Defined Global Communicator
extern belfem::Communicator gComm;
 
//------------------------------------------------------------------------------
// comm_abort is declared HERE rather than in commtools.hpp so that core's
// assert.cpp can reach it: commtools.hpp pulls cl_Vector/cl_Matrix from
// linalg, which is not on the core module's include path, while this header
// already is ( assert.cpp includes it today ). commtools.hpp includes this
// header, so every commtools consumer sees the declaration as before.
// Definition: commtools.cpp.
//------------------------------------------------------------------------------
 
namespace belfem
{
    [[noreturn]] void
    comm_abort( const int aErrorCode = 1 );
}
 
 
#endif //BELFEM_CL_COMMUNICATOR_HPP