MPIAllToAllCommunicator.cpp

Go to the documentation of this file.

#include "MPIAllToAllCommunicator.h"

#include <functional>
#include <numeric>
#include <algorithm>
using std::logical_or;
using std::accumulate;
using std::copy;

MPIAllToAllCommunicator::MPIAllToAllCommunicator(MPIInputBufferVector & mpiInputBuffers,
        MPIOutputBufferVector & mpiOutputBuffers,
        MPI::Intracomm & comm,
        vector<bool> &incomingConnections,
        vector<bool> &outgoingConnections) :
        inputBuffers(mpiInputBuffers), outputBuffers(mpiOutputBuffers),
        incoming_connections(incomingConnections), outgoing_connections(outgoingConnections),
        mpi_comm(comm)
{
    numNodes = mpi_comm.Get_size();
    finished = true;
    hasNextToSend.resize(numNodes);

}

MPIAllToAllCommunicator::~MPIAllToAllCommunicator()
{}

int MPIAllToAllCommunicator::getRank()
{
    return mpi_comm.Get_rank();
}

bool MPIAllToAllCommunicator::doAllToAllExchange()
{
    if (finished) {
        // this is the first iteration of a new all-to-all exchange operation so initialize the buffers
        inputBuffers.startNewMPIExchange();
        outputBuffers.startNewMPIExchange();

        // and initialize the needs to send and needs to receive indicators
        prepare();
        finished = false;
    }

    outputBuffers.prepareNextBufferSlices();
    inputBuffers.prepareNextBufferSlices();

    for (int i = 0 ; i < numNodes ; ++i)
        hasNextToSend[i] = hasNextToSend[i] && outputBuffers[i].hasNextBufferSlice();

    // do the exchange algorithm
    doExchangeAlgorithm();

    // update the needsToReceive and needsToSend array for the next cycle
    for (int i = 0 ; i < numNodes ; ++i ) {
        needsToSend[i] = hasNextToSend[i];
        if (mpi_comm.Get_rank() != i) {
            inputBuffers[i].setHasNewContent(needsToReceive[i]);
            needsToReceive[i] = needsToReceive[i] && inputBuffers[i].hasNextBufferSlice();
        }
    }

    // are we finished with the iterations ?
    finished = !(accumulate(needsToReceive.begin(), needsToReceive.end(), false, logical_or<bool>())
                 || accumulate(needsToSend.begin(), needsToSend.end(), false, logical_or<bool>()));

    if (finished)
        outputBuffers.nextCycle();
    return finished;
}

---