MPIInputSpikeBuffer.h

Go to the documentation of this file.

#ifndef MPIInputSpikeBuffer_H_
#define MPIInputSpikeBuffer_H_

#include <vector>
#include <iostream>
#include "globaldefinitions.h"

using std::vector;
using std::cout;
using std::endl;


class MPIInputSpikeBufferElement
{
public:
    int timestamp;
    local_objectid_t oid;
    gl_engineid_t engine;
};

bool compareMPIInputSpikeBufferElem(const MPIInputSpikeBufferElement &el1,const MPIInputSpikeBufferElement &el2);

bool equalMPIInputSpikeBufferElem(const MPIInputSpikeBufferElement &el1,const MPIInputSpikeBufferElement &el2);

template<typename T>
class MPIInputSpikeBuffer;


template<typename T>
class MPIInputSpikeBufferIterator;

template <typename T>
inline bool operator==(const MPIInputSpikeBufferIterator<T> &it1, const MPIInputSpikeBufferIterator<T> &it2)
{
    return (it1.pbuf == it2.pbuf && it1.curr_pos == it2.curr_pos);
}

template <typename T>
inline bool operator!=(const MPIInputSpikeBufferIterator<T> &it1, const MPIInputSpikeBufferIterator<T> &it2)
{
    return !operator==(it1,it2);
}




template<typename T = unsigned short>
class MPIInputSpikeBufferIterator
{
public:
    MPIInputSpikeBufferIterator();

    MPIInputSpikeBufferIterator<T> & operator++();

    MPIInputSpikeBufferElement & operator*()
    {
        return elem;
    }

    MPIInputSpikeBufferElement* operator->()
    {
        return &elem;
    }

protected:
    MPIInputSpikeBufferElement elem;

    T *pbuf;
    T *curr_pos;
    unsigned int len ;

    T guard_value ;

    friend class  MPIInputSpikeBuffer<T>;
    friend bool operator==<T>(const MPIInputSpikeBufferIterator<T> &it1, const MPIInputSpikeBufferIterator<T> &it2);
    friend bool operator!=<T>(const MPIInputSpikeBufferIterator<T> &it1, const MPIInputSpikeBufferIterator<T> &it2);

};


template<class T>
class MPIInputSpikeBufferVector;


template<typename T = unsigned short >
class MPIInputSpikeBuffer
{
public:
    typedef MPIInputSpikeBufferIterator<T> const_iterator;

    typedef MPIInputSpikeBufferElement value_type;
    


    typedef T coding_element_type;

    T guard_value;
    

    MPIInputSpikeBuffer();    

    virtual ~MPIInputSpikeBuffer();
        
    void initialize(T * buffer) {
                _buffer = buffer;
        *_buffer = 2;
        *(_buffer+1) = 1;
        contentIndicator = false;
    }

    const_iterator begin();

    const_iterator end();

    T * getBuffer();

    int & getLength();


    bool isLastReceivedBuffer();
    
        
    void setHasNewContent(bool indicator) {
        contentIndicator = indicator;
    }
    
    
    bool hasNewContent() {
        return contentIndicator;
    };
    
protected:
    bool contentIndicator;

    
    T* _buffer;

    int len;

    friend class MPIInputSpikeBufferIterator<T>;
    friend class MPIInputSpikeBufferVector<T>;

};



template<class T = unsigned short>
class MPIInputSpikeBufferVector
{
public:


    MPIInputSpikeBufferVector(int numBuffers, size_t buf_size = MPIBUFFER_BLOCK_SIZE);

    virtual ~MPIInputSpikeBufferVector()
    {
        delete [] inputBuffersPool;
    }

    MPIInputSpikeBuffer<T> & operator[](int idx)
    {
        return _buffers[idx];
    }

    T *getBuffersPool()
    {
        return inputBuffersPool;
    }

    unsigned int size()
    {
        return nNodes;
    }

protected:
    int nNodes;

    size_t _buf_size;

    vector<MPIInputSpikeBuffer<T> > _buffers;

    T *inputBuffersPool;

};


inline bool compareMPIInputSpikeBufferElem(const MPIInputSpikeBufferElement &el1,const MPIInputSpikeBufferElement &el2)
{
    if (el1.engine < el2.engine)
        return true;
    if (el1.engine == el2.engine) {
        if (el1.timestamp < el2.timestamp)
            return true;
        if (el1.timestamp == el2.timestamp)
            return el1.oid < el2.oid ;
    }
    return false;
}

inline bool equalMPIInputSpikeBufferElem(const MPIInputSpikeBufferElement &el1,const MPIInputSpikeBufferElement &el2)
{
    return      el1.engine == el2.engine && el1.timestamp == el2.timestamp && el1.oid == el2.oid ;
}

template<typename T>
MPIInputSpikeBufferIterator<T>::MPIInputSpikeBufferIterator()
{
    guard_value = 0xFF;
    for (unsigned int i = 1 ; i < sizeof(T) ; ++i)
        guard_value = (guard_value << 8) + 0xFF;
}

template<typename T>
MPIInputSpikeBufferIterator<T> & MPIInputSpikeBufferIterator<T>::operator++()
{

    curr_pos++;
    if (*curr_pos == guard_value) {
        curr_pos++;
        while (*curr_pos == guard_value) {
            if (++curr_pos == (pbuf + len - 2)) {
                return (*this);
            }
            elem.engine = *(curr_pos++);
            curr_pos++;
        }
        elem.timestamp = *(curr_pos++);
    }

    elem.oid = *curr_pos;
    return (*this);
}

template<typename T>
MPIInputSpikeBuffer<T>::MPIInputSpikeBuffer()

{
    guard_value = 0xFF;
    for (unsigned int i = 1 ; i < sizeof(T) ; ++i)
        guard_value = (guard_value << 8) + 0xFF;

    len = 0;
    _buffer = NULL;
}

template<typename T>
MPIInputSpikeBuffer<T>::~MPIInputSpikeBuffer()
{}

template<typename T>
typename MPIInputSpikeBuffer<T>::const_iterator
MPIInputSpikeBuffer<T>::begin()
{
    MPIInputSpikeBufferIterator<T> it;
    len = *_buffer;
    it.pbuf = _buffer+2;
    it.elem.engine = *it.pbuf;
    if (len <= 5) {
        it.curr_pos = _buffer + len;
        return it;
    }
    it.elem.timestamp = *(it.pbuf+2);
    it.elem.oid = *(it.pbuf+3);
    it.curr_pos = it.pbuf+3;
    it.len = len;
    return it;
}

template<typename T>
typename MPIInputSpikeBuffer<T>::const_iterator
MPIInputSpikeBuffer<T>::end()
{
    MPIInputSpikeBufferIterator<T> it;
    it.pbuf = _buffer + 2;
    it.curr_pos = _buffer + len;
    return it;
}

template<typename T>
T * MPIInputSpikeBuffer<T>::getBuffer()
{
    return _buffer;
}

template<typename T>
int & MPIInputSpikeBuffer<T>::getLength()
{
    return len;
}

template<typename T>
bool MPIInputSpikeBuffer<T>::isLastReceivedBuffer()
{
    return *(_buffer+1)!= 0;
}

template<typename T>
MPIInputSpikeBufferVector<T>::MPIInputSpikeBufferVector(int numBuffers, size_t buf_size)
        : nNodes(numBuffers), _buf_size(buf_size)
{
    inputBuffersPool = new T[nNodes*buf_size];
    _buffers.resize(nNodes, MPIInputSpikeBuffer<T>());
    for (int i = 0 ; i < nNodes ; ++i) {
        _buffers[i]._buffer = inputBuffersPool + i*buf_size;
        *_buffers[i]._buffer = 2;
        *(_buffers[i]._buffer+1) = 1;
    }
}

#endif /*MPIInputSpikeBuffer_H_*/

---