SyncBuffer.h

Go to the documentation of this file.

/* 
* Copyright 2014-2018 Friedemann Zenke
*
* This file is part of Auryn, a simulation package for plastic
* spiking neural networks.
* 
* Auryn is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* Auryn 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 General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with Auryn.  If not, see <http://www.gnu.org/licenses/>.
*
* If you are using Auryn or parts of it for your work please cite:
* Zenke, F. and Gerstner, W., 2014. Limits to high-speed simulations 
* of spiking neural networks using general-purpose computers. 
* Front Neuroinform 8, 76. doi: 10.3389/fninf.2014.00076
*/


#ifndef SYNCBUFFER_H_
#define SYNCBUFFER_H_


#define SYNCBUFFER_SIZE_MARGIN_MULTIPLIER 5 
#define SYNCBUFFER_SIZE_HIST_LEN 512 


#define SYNCBUFFER_DELTA_DATATYPE NeuronID 

#include "auryn_definitions.h"
#include "SpikeDelay.h"
#include <vector>
#include <algorithm>

#ifdef AURYN_CODE_USE_MPI

#include <boost/mpi.hpp>
#include <mpi.h>

namespace auryn {

        class SyncBuffer
        {
                private:
                        std::vector<NeuronID> send_buf;
                        std::vector<NeuronID> recv_buf;

                        NeuronID overflow_value;
                        unsigned int overflow_counter;

                        SYNCBUFFER_DELTA_DATATYPE max_delta_size;
                        SYNCBUFFER_DELTA_DATATYPE undefined_delta_size;

                        unsigned int sync_counter;

                        int * rank_send_sum;
                        int * rank_send_sum2;
                        int * rank_recv_count;
                        int * rank_displs;

                        int max_send_size;

                        mpi::communicator * mpicom;


                        SYNCBUFFER_DELTA_DATATYPE carry_offset;

                        SYNCBUFFER_DELTA_DATATYPE * pop_delta_spikes;
                        SYNCBUFFER_DELTA_DATATYPE * last_spike_pos;

                        unsigned int * pop_offsets;

                        void reset_send_buffer();
                        void resize_buffers(unsigned int send_size);

                        void init();
                        void free();

                        void update_send_recv_counts();
                        int compute_buffer_margin(int n, int sum, int sum2);
                        int compute_buffer_size_with_margin(int n, int sum, int sum2);

                        NeuronID * read_delta_spike_from_buffer(NeuronID * iter, SYNCBUFFER_DELTA_DATATYPE & delta);

                        NeuronID * read_attribute_from_buffer(NeuronID * iter, AurynFloat & attrib);

                        void sync_allgatherv();

                        void sync_allgather();

                public:

                        SyncBuffer( mpi::communicator * com );

                        virtual ~SyncBuffer( );

                        void sync();

                        void push(SpikeDelay * delay, const NeuronID size);

                        void null_terminate_send_buffer();

                        void pop(SpikeDelay * delay, const NeuronID size);

                        int get_max_send_buffer_size(); 

                        unsigned int get_sync_count();  

                        unsigned int get_overflow_count();      

#ifdef CODE_COLLECT_SYNC_TIMING_STATS
                        AurynDouble deltaT;
                        AurynDouble measurement_start;
                        AurynDouble get_relative_sync_time();
                        AurynDouble get_sync_time();
                        AurynDouble get_elapsed_wall_time();
                        void reset_sync_time();
#endif
        };
}

#endif // AURYN_CODE_USE_MPI

#endif /*SYNCBUFFER_H_*/