auryn_definitions.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 AURYN_DEFINITIONS_H_
#define AURYN_DEFINITIONS_H_


#define AURYN_CODE_USE_MPI


#define CODE_ALIGNED_SIMD_INSTRUCTIONS

#define CODE_ACTIVATE_PREFETCHING_INTRINSICS

#define CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY

// #define CODE_ACTIVATE_CILK_INSTRUCTIONS

#define SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS 4 

// #define CODE_COLLECT_SYNC_TIMING_STATS //!< toggle  collection of timing data on sync/all_gather


#define MINDELAY 8

#define DEFAULT_MINDISTRIBUTEDSIZE 16


#define DEFAULT_TRACE_MODEL Trace
#define PRE_TRACE_MODEL Trace


//* -- End of precompiler options -- *//


#include <iostream>
#include <iomanip>
#include <string>
#include <cmath>
#include <cstdlib>
#include <list>
#include <exception>
#include <limits>

#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
#ifndef CODE_ACTIVATE_CILK_INSTRUCTIONS
#include <x86intrin.h> // SIMD intrinsics (pulls everything you need)
#else // XMM registers are not supported on the phi platform
#include <immintrin.h> // AVX only
#endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#endif /* CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY */

#ifdef  AURYN_CODE_USE_MPI
#include <boost/mpi.hpp>
namespace mpi = boost::mpi;
#endif


#include "Logger.h"


namespace auryn {

        extern double auryn_timestep;

        enum TransmitterType { 
                GLUT, 
                GABA, 
                AMPA, 
                NMDA, 
                MEM,   
                CURSYN   
        };

        enum StimulusGroupModeType { MANUAL, RANDOM, SEQUENTIAL, SEQUENTIAL_REV, STIMFILE };


        typedef unsigned int NeuronID; 
        typedef NeuronID AurynInt;
        typedef unsigned int StateID; 
        typedef unsigned long AurynLong; 
        typedef NeuronID AurynTime; 
        typedef std::string string; 
        typedef float AurynFloat; 
        typedef double AurynDouble; 
        typedef AurynFloat AurynWeight; 
        typedef AurynFloat AurynState; 
        typedef std::vector<NeuronID> SpikeContainer; 
        typedef std::vector<float> AttributeContainer; 



        struct neuron_pair {
                NeuronID i,j;
        } ;

        struct pattern_member {
                NeuronID i;
                AurynDouble gamma;
        } ;

        typedef std::vector<pattern_member> type_pattern;




        int auryn_AlignOffset (const int N, const void *vp, const int inc, const int align);  

        NeuronID calculate_vector_size(NeuronID i);

        struct SpikeEvent_type
        {
                AurynTime time; 
                NeuronID neuronID;
        };

        struct StateValue_type
        {
                AurynTime time; 
                AurynState value;
        };

        // Exceptions
        class AurynOpenFileException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Failed opening file.";
                                }
        };

        class AurynMMFileException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Problem reading MatrixMarket file. Not row major format?";
                                }
        };

        class AurynMatrixDimensionalityException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Cannot add data outside of matrix.";
                                }
        };

        class AurynMatrixComplexStateException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Trying to access non existing complex synaptic states.";
                                }
        };

        class AurynMatrixBufferException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Buffer full.";
                                }
        };

        class AurynMatrixPushBackException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Could not push_back in SimpleMatrix. Out of order execution?";
                                }
        };

        class AurynConnectionAllocationException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Buffer has not been allocated.";
                                }
        };


        class AurynMemoryAlignmentException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Memory not aligned or problem allocating aligned memory.";
                                }
        };

        class AurynDelayTooSmallException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "One of the SpikeDelays was chosen shorter than the current value of MINDELAY.";
                                }
        };

        class AurynTimeOverFlowException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Trying to simulate more timesteps than are available in AurynTime.";
                                }
        };

        class AurynStateVectorException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Auryn encountered an undefined problem when dealing with StateVectors.";
                                }
        };

        class AurynGenericException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Auryn encountered a problem which it deemed serious enough to break the run. \
                                                        To debug set logger vebosity to VERBOSE or EVERYTHING and analyze the log files.";
                                }
        };

        class AurynVectorDimensionalityException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "Dimensions do not match or trying to read beyond vector size. " 
                                                           "Are the vectors zero padded to a multiples of four dimension?";
                                }
        };

        class AurynSpikeAttributeSizeException: public std::exception
        {
                  virtual const char* what() const throw()
                                {
                                                return "The number of spike attributes can only be increased.";
                                }
        };



        // forward declartion of template class which is implemented in AurynVector.h
        template <typename T, typename IndexType > 
        class AurynVector;

        class AurynVectorFloat; // Forward declaration

        typedef AurynVectorFloat AurynStateVector; 

        typedef AurynVector<AurynWeight, AurynLong> AurynSynStateVector; 

        // Legacy state vector types 
        typedef AurynStateVector auryn_vector_float; 

        typedef AurynVector<unsigned short, NeuronID> auryn_vector_ushort; 


        // Legacy float vector functions
        // These functions should not be used any more in the future. Instead use the member functions of AurynVectorFloat

        auryn_vector_float * auryn_vector_float_alloc(const NeuronID n);

        void auryn_vector_float_free (auryn_vector_float * v);

        void auryn_vector_float_set_zero (auryn_vector_float * v);

        void auryn_vector_float_set_all (auryn_vector_float * v, AurynFloat x);

        void auryn_vector_float_copy (auryn_vector_float * src, auryn_vector_float * dst );

        AurynFloat auryn_vector_float_get (auryn_vector_float * v, const NeuronID i);

        void auryn_vector_float_set (auryn_vector_float * v, const NeuronID i, AurynFloat x);

        AurynFloat * auryn_vector_float_ptr (auryn_vector_float * v, const NeuronID i);

        void auryn_vector_float_mul( auryn_vector_float * a, auryn_vector_float * b);

        void auryn_vector_float_add_constant( auryn_vector_float * a, float b );

        void auryn_vector_float_saxpy( const float a, auryn_vector_float * x, auryn_vector_float * y );
        void auryn_vector_float_scale(const float a, auryn_vector_float * b );
        void auryn_vector_float_clip(auryn_vector_float * v, const float a , const float b );

        void auryn_vector_float_clip(auryn_vector_float * v, const float a );

        void auryn_vector_float_add( auryn_vector_float * a, auryn_vector_float * b);

        void auryn_vector_float_sub( auryn_vector_float * a, auryn_vector_float * b);

        void auryn_vector_float_sub( auryn_vector_float * a, auryn_vector_float * b, auryn_vector_float * r);



        // Legacy ushort vector functions
        auryn_vector_ushort * auryn_vector_ushort_alloc(const NeuronID n);
        void auryn_vector_ushort_free (auryn_vector_ushort * v);
        void auryn_vector_ushort_set_zero (auryn_vector_ushort * v);

        void auryn_vector_ushort_set_all (auryn_vector_ushort * v, unsigned short x);

        void auryn_vector_ushort_copy (auryn_vector_ushort * src, auryn_vector_ushort * dst );
        unsigned short auryn_vector_ushort_get (auryn_vector_ushort * v, const NeuronID i);
        void auryn_vector_ushort_set (auryn_vector_ushort * v, const NeuronID i, unsigned short x);
        unsigned short * auryn_vector_ushort_ptr (auryn_vector_ushort * v, const NeuronID i);

} // namespace

#endif /*AURYN_DEFINITIONS_H__*/