processcomm.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef processcomm_h
#define processcomm_h
 
#include <cstdint>
#include "oofemenv.h"
#include "combuff.h"
#include "commbufftype.h"
#include "communicatormode.h"
#include "floatmatrix.h"
#include "floatarray.h"
#include "intarray.h"
#include "error.h"
#include "logger.h"
 
#include <string>
#include <memory>
 
namespace oofem {
class OOFEM_EXPORT ProcessCommunicatorBuff: public DataStream
{
protected:
    std::unique_ptr<CommunicationBuffer> send_buff;
    std::unique_ptr<CommunicationBuffer> recv_buff;
public:
    ProcessCommunicatorBuff(CommBuffType t);
 
    int givePackSizeOfInt(std::size_t count) override { return send_buff->givePackSizeOfInt(count); }
    int givePackSizeOfDouble(std::size_t count) override { return send_buff->givePackSizeOfDouble(count); }
    int givePackSizeOfChar(std::size_t count) override { return send_buff->givePackSizeOfChar(count); }
    int givePackSizeOfBool(std::size_t count) override { return send_buff->givePackSizeOfBool(count); }
    int givePackSizeOfLong(std::size_t count) override { return send_buff->givePackSizeOfLong(count); }
    int givePackSizeOfSizet(std::size_t count) override { return send_buff->givePackSizeOfSizet(count); }
 
 
    using DataStream::write;
    int write(const int *data, std::size_t count) override { return send_buff->write(data, count); }
    int write(const long *data, std::size_t count) override { return send_buff->write(data, count); }
    int write(const unsigned long *data, std::size_t count) override { return send_buff->write(data, count); }
    int write(const double *data, std::size_t count) override { return send_buff->write(data, count); }
    int write(const char *data, std::size_t count) override { return send_buff->write(data, count); }
    int write(bool data) override { return send_buff->write(data); }
 
    using DataStream::read;
    int read(int *data, std::size_t count) override { return this->recv_buff->read(data, count); }
    int read(long *data, std::size_t count) override { return this->recv_buff->read(data, count); }
    int read(unsigned long *data, std::size_t count) override { return this->recv_buff->read(data, count); }
    int read(double *data, std::size_t count) override { return this->recv_buff->read(data, count); }
    int read(char *data, std::size_t count) override { return this->recv_buff->read(data, count); }
    int read(bool &data) override { return recv_buff->read(data); }

    void initSendBuff() { send_buff->init(); }
    void initRecvBuff() { recv_buff->init(); }
    void init() {
        initSendBuff();
        initRecvBuff();
    }

    void initForPacking() { send_buff->initForPacking(); }
    void initForUnpacking() { recv_buff->initForUnpacking(); }

    int initExchange(int rank, int tag) {
        int result = 1;
        result &= initSend(rank, tag);
        result &= initReceive(rank, tag);
 
        return result;
    }

    int initSend(int rank, int tag) { return send_buff->iSend(rank, tag); }
    int initReceive(int rank, int tag) { return recv_buff->iRecv(rank, tag); }

    void clearBuffers() { }
 
    void resizeSendBuffer(std::size_t size) { send_buff->resize(size); }
    void resizeReceiveBuffer(std::size_t size) { recv_buff->resize(size); }

    int sendCompleted() { return send_buff->testCompletion(); }
    int receiveCompleted() { return recv_buff->testCompletion(); }
    int testCompletion() { return ( send_buff->testCompletion() && recv_buff->testCompletion() ); }
    int waitCompletion() { return ( send_buff->waitCompletion() && recv_buff->waitCompletion() ); }

    CommunicationBuffer &giveSendBuff() { return *send_buff; }
    CommunicationBuffer &giveRecvBuff() { return *recv_buff; }
};
 

class OOFEM_EXPORT ProcessCommunicator
{
protected:
    int rank; // remote problem id = rank

    ProcessCommunicatorBuff *pcBuffer;

    IntArray toSend;
    IntArray toReceive;
    CommunicatorMode mode;
 
public:
    ProcessCommunicator(ProcessCommunicatorBuff * b, int irank, CommunicatorMode m = CommMode_Static);

    int giveRank() { return rank; }

    ProcessCommunicatorBuff *giveProcessCommunicatorBuff() {
        if ( pcBuffer ) {
            return pcBuffer;
        }
 
        OOFEM_ERROR("ProcessCommunicatorBuff undefined");
        return NULL;
    }
 

    const IntArray &giveToSendMap() { return toSend; }
    const IntArray &giveToRecvMap() { return toReceive; }
 

    template< class T > void setToSendArry(T *emodel, const IntArray &src, int packUnpackType);
    template< class T > void setToRecvArry(T *emodel, const IntArray &src, int packUnpackType);
    template< class T > int packData( T *emodel, int ( T :: *packFunc )( ProcessCommunicator & ) )
    {
        if ( !toSend.isEmpty() || ( this->mode == CommMode_Dynamic ) ) {
            giveProcessCommunicatorBuff()->initForPacking();
            return ( emodel->*packFunc )(* this);
        } else {
            return 1;
        }
    }

    template< class T, class P > int packData( T *emodel, P *src, int ( T :: *packFunc )( P *, ProcessCommunicator & ) )
    {
        if ( !toSend.isEmpty() || ( this->mode == CommMode_Dynamic ) ) {
            giveProcessCommunicatorBuff()->initForPacking();
            return ( emodel->*packFunc )(src, * this);
        } else {
            return 1;
        }
    }

    template< class T > int unpackData( T *emodel,  int ( T :: *unpackFunc )( ProcessCommunicator & ) )
    {
        if ( !toReceive.isEmpty() || ( this->mode == CommMode_Dynamic ) ) {
            giveProcessCommunicatorBuff()->initForUnpacking();
            return ( emodel->*unpackFunc )(* this);
        } else {
            return 1;
        }
    }

    template< class T, class P > int unpackData( T *emodel,  P *dest, int ( T :: *unpackFunc )( P *, ProcessCommunicator & ) )
    {
        if ( !toReceive.isEmpty() || ( this->mode == CommMode_Dynamic ) ) {
            giveProcessCommunicatorBuff()->initForUnpacking();
            return ( emodel->*unpackFunc )(dest, * this);
        } else {
            return 1;
        }
    }

    int initExchange(int tag);
    int initSend(int tag);
    int initReceive(int tag);
    int finishExchange();
 

    int sendCompleted();
    int receiveCompleted();
    int testCompletion();
    int waitCompletion();


    void clearBuffers();
 
private:
    template< class T > int resizeSendBuff(T *emodel, int packUnpackType);
    template< class T > int resizeRecvBuff(T *emodel, int packUnpackType);
};
 
template< class T > void
ProcessCommunicator :: setToSendArry(T *emodel, const IntArray &src, int packUnpackType)
{
    toSend = src;
    // toSend.sort (&NlDEIDynamicDomainComunicator::nodeSortFunct);
    //sortCommMap (toSend);
    resizeSendBuff(emodel, packUnpackType);
}
 
 
template< class T > void
ProcessCommunicator :: setToRecvArry(T *emodel, const IntArray &src, int packUnpackType)
{
    toReceive = src;
    //toReceive.sort (&NlDEIDynamicDomainComunicator::nodeSortFunct);
    //sortCommMap (toReceive);
    resizeRecvBuff(emodel, packUnpackType);
}
 
 
template< class T > int
ProcessCommunicator :: resizeSendBuff(T *emodel, int packUnpackType)
{
    int size;
    // determine space for send buffer
    size = emodel->estimateMaxPackSize(toSend, giveProcessCommunicatorBuff()->giveSendBuff(), packUnpackType);
    giveProcessCommunicatorBuff()->resizeSendBuffer(size);
    //giveSendBuff()->resize (size);
    return 1;
}
 
 
template< class T > int
ProcessCommunicator :: resizeRecvBuff(T *emodel, int packUnpackType)
{
    int size;
 
    // determine space for recv buffer
    size = emodel->estimateMaxPackSize(toReceive, giveProcessCommunicatorBuff()->giveRecvBuff(), packUnpackType);
    giveProcessCommunicatorBuff()->resizeReceiveBuffer(size);
    //giveRecvBuff()->resize (size);
 
    return 1;
}
} // end namespace oofem
#endif // processcomm_h