processcomm.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   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 "oofemcfg.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>

namespace oofem {
class OOFEM_EXPORT ProcessCommunicatorBuff: public DataStream
{
protected:
    CommunicationBuffer *send_buff;
    CommunicationBuffer *recv_buff;
public:
    ProcessCommunicatorBuff(CommBuffType t);
    virtual ~ProcessCommunicatorBuff();

    virtual int givePackSizeOfInt(int count) { return send_buff->givePackSizeOfInt(count); }
    virtual int givePackSizeOfDouble(int count) { return send_buff->givePackSizeOfDouble(count); }
    virtual int givePackSizeOfChar(int count) { return send_buff->givePackSizeOfChar(count); }
    virtual int givePackSizeOfBool(int count) { return send_buff->givePackSizeOfBool(count); }
    virtual int givePackSizeOfLong(int count) { return send_buff->givePackSizeOfLong(count); }

    using DataStream::write;
    virtual int write(const int *data, int count) { return send_buff->write(data, count); }
    virtual int write(const long *data, int count) { return send_buff->write(data, count); }
    virtual int write(const unsigned long *data, int count) { return send_buff->write(data, count); }
    virtual int write(const double *data, int count) { return send_buff->write(data, count); }
    virtual int write(const char *data, int count) { return send_buff->write(data, count); }
    virtual int write(bool data) { return send_buff->write(data); }

    using DataStream::read;
    virtual int read(int *data, int count) { return this->recv_buff->read(data, count); }
    virtual int read(long *data, int count) { return this->recv_buff->read(data, count); }
    virtual int read(unsigned long *data, int count) { return this->recv_buff->read(data, count); }
    virtual int read(double *data, int count) { return this->recv_buff->read(data, count); }
    virtual int read(char *data, int count) { return this->recv_buff->read(data, count); }
    virtual int read(bool &data) { 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(int size) { send_buff->resize(size); }
    void resizeReceiveBuffer(int 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);
    ~ProcessCommunicator() { }

    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