MPIBufferSlicer.cpp

Go to the documentation of this file.

#include "MPIBufferSlicer.h"
#include "MPIInputSpikeBuffer.h"
#include "PCSIMException.h"

#include <cassert>
#include <numeric>

using std::min;

MPIBufferSlicer::MPIBufferSlicer(MPIBufferType bufferType)
        : buffer_type(bufferType)
{}

void MPIBufferSlicer::initialize(size_t analogBufferSize,
                                 size_t maxMPIMsgSize ,
                                 size_t spikeBufferSize)
{
    if (maxMPIMsgSize % 8) {
        throw PCSIM::Exception("MPIBufferSlicer::initialize", "Maximum mpi msg size must be divisible by 8");
    }

    max_mpi_msg_size = maxMPIMsgSize;
    spike_buffer_size_bytes = spikeBufferSize ;
    analog_buffer_size_elements = analogBufferSize;
    analog_buffer_size_bytes = analog_buffer_size_elements * sizeof(double);
    spike_buffer_size_elements = spike_buffer_size_bytes / sizeof(MPIInputSpikeBuffer<>::coding_element_type);

    // Decide if there will be mixed (analog and spiking) mpi data types during transfer
    if ( analog_buffer_size_bytes == 0 )
        thereIsMixedDataType = false;
    else
        if ( max_mpi_msg_size == 0 )
            thereIsMixedDataType = true;
        else
            if (analog_buffer_size_bytes % max_mpi_msg_size == 0 ||
                    max_mpi_msg_size - analog_buffer_size_bytes % max_mpi_msg_size < MIN_MPI_SPIKE_BUFFER_SIZE)
                thereIsMixedDataType = false;
            else
                thereIsMixedDataType = true;
}

void MPIBufferSlicer::reset()
{
    currentSliceType = sliceUndefined;
}

void MPIBufferSlicer::calcNextBufferSliceDimensions()
{
    switch(currentSliceType) {
    case sliceUndefined:
        if (!analog_buffer_size_elements) {
            // no analog data so start transfering the spiking slices
            currentSliceType = sliceSpiking;
            currentSlicePos = analog_buffer_size_bytes;
            allowedSpikeSliceSize = spike_buffer_size_bytes;
        } else {
            if (thereIsMixedDataType) {
                if (max_mpi_msg_size == 0) {
                    currentSliceType = sliceMixed;
                    currentSlicePos = 0;
                    currentAnalogSliceSize = analog_buffer_size_bytes;
                    allowedSpikeSliceSize = spike_buffer_size_bytes;
                } else {
                    if (max_mpi_msg_size > analog_buffer_size_bytes) {
                        // first message should be mixed
                        currentSliceType = sliceMixed;
                        currentSlicePos = 0;
                        currentAnalogSliceSize = analog_buffer_size_bytes;
                        allowedSpikeSliceSize = min(max_mpi_msg_size - analog_buffer_size_bytes,
                                                    spike_buffer_size_bytes);
                    } else {
                        // first message is analog since there is analog data, and the first message is not mixed
                        currentSliceType = sliceAnalog;
                        currentSlicePos = 0;
                        currentAnalogSliceSize = max_mpi_msg_size;
                    }
                }
            } else {
                // there isn't a mixed data type, and there is analog data, so the first message should be analog
                currentSliceType = sliceAnalog;
                currentSlicePos = 0;
                currentAnalogSliceSize= min(max_mpi_msg_size, analog_buffer_size_bytes) ;
            }
        }
        break;
    case sliceAnalog:
        currentSlicePos += currentAnalogSliceSize;
        if (currentSlicePos == analog_buffer_size_bytes) {
            currentSliceType = sliceSpiking;
            allowedSpikeSliceSize = spike_buffer_size_bytes;
        } else {
            if (currentSlicePos + max_mpi_msg_size > analog_buffer_size_bytes) {
                if (thereIsMixedDataType) {
                    currentSliceType = sliceMixed;
                    currentAnalogSliceSize = analog_buffer_size_bytes - currentSlicePos ;
                    allowedSpikeSliceSize = min( currentSlicePos + max_mpi_msg_size - analog_buffer_size_bytes,
                                                 spike_buffer_size_bytes) ;
                } else {
                    currentSliceType = sliceAnalog;
                    currentAnalogSliceSize = analog_buffer_size_bytes - currentSlicePos;
                }
            } else {
                currentSliceType = sliceAnalog;
                currentAnalogSliceSize = max_mpi_msg_size;
            }
        }
        break;
    case sliceMixed:
    case sliceSpiking:
        currentSliceType = sliceSpiking;
        currentSlicePos = analog_buffer_size_bytes;
        allowedSpikeSliceSize = spike_buffer_size_bytes;
    }
}

---