CARLsim4/snn__datastructures_8h_source.html

/* * Copyright (c) 2016 Regents of the University of California. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1. Redistributions of source code must retain the above copyright

*    notice, this list of conditions and the following disclaimer.

*

* 2. Redistributions in binary form must reproduce the above copyright

*    notice, this list of conditions and the following disclaimer in the

*    documentation and/or other materials provided with the distribution.

*

* 3. The names of its contributors may not be used to endorse or promote

*    products derived from this software without specific prior written

*    permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

* *********************************************************************************************** *

* CARLsim

* created by: (MDR) Micah Richert, (JN) Jayram M. Nageswaran

* maintained by:

* (MA) Mike Avery <averym@uci.edu>

* (MB) Michael Beyeler <mbeyeler@uci.edu>,

* (KDC) Kristofor Carlson <kdcarlso@uci.edu>

* (TSC) Ting-Shuo Chou <tingshuc@uci.edu>

* (HK) Hirak J Kashyap <kashyaph@uci.edu>

*

* CARLsim v1.0: JM, MDR

* CARLsim v2.0/v2.1/v2.2: JM, MDR, MA, MB, KDC

* CARLsim3: MB, KDC, TSC

* CARLsim4: TSC, HK

*

* CARLsim available from http://socsci.uci.edu/~jkrichma/CARLsim/

* Ver 12/31/2016

*/


#ifndef _SNN_DATASTRUCTURES_H_

#define _SNN_DATASTRUCTURES_H_


// include CUDA version-dependent macros and include files

#ifndef __NO_CUDA__

    #include <cuda_version_control.h>

    #include <curand.h>

#endif


enum MemType {

    CPU_MEM,

    GPU_MEM,

};


enum conType_t { CONN_RANDOM, CONN_ONE_TO_ONE, CONN_FULL, CONN_FULL_NO_DIRECT, CONN_GAUSSIAN, CONN_USER_DEFINED, CONN_UNKNOWN};


enum SNNState {

    CONFIG_SNN,

    COMPILED_SNN,

    PARTITIONED_SNN,

    EXECUTABLE_SNN

};


typedef struct DelayInfo_s {

    short  delay_index_start;

    short  delay_length;

} DelayInfo;


typedef struct SynInfo_s {

    int gsId;

    int nId;

} SynInfo;


typedef struct ConnectionInfo_s {

    int grpSrc;

    int grpDest;

    int nSrc;

    int nDest;

    int srcGLoffset;

    float initWt;

    float maxWt;

    int preSynId;

    short int connId;

    uint8_t delay;


    bool operator== (const struct ConnectionInfo_s& conn) {

        return (nSrc + srcGLoffset == conn.nSrc);

    }

} ConnectionInfo;


typedef struct ConnectConfig_s {

    int                      grpSrc;

    int                      grpDest;

    uint8_t                  maxDelay;

    uint8_t                  minDelay;

    float                    maxWt;

    float                    initWt;

    float                    minWt;

    RadiusRF                 connRadius;

    float                    mulSynFast;

    float                    mulSynSlow;

    int                      connectionMonitorId; // ToDo: move to ConnectConfigMD

    uint32_t                 connProp;

    ConnectionGeneratorCore* conn;

    conType_t                type;

    float                    connProbability;

    short int                connId;

    int                      numberOfConnections; // ToDo: move to ConnectConfigMD

} ConnectConfig;


typedef struct ConnectConfigMD_s {

    ConnectConfigMD_s() : gConnId(-1), lConnId(-1), connectionMonitorId(-1), numberOfConnections(-1)

    {}

    int gConnId;

    int lConnId;

    int connectionMonitorId;

    int numberOfConnections;

} ConnectConfigMD;


typedef struct ConnectConfigRT_s {

    float* mulSynFast;

    float* mulSynSlow;

} ConnectConfigRT;


typedef struct compConnectionInfo_s {

    int                             grpSrc, grpDest;

    short int                       connId;

}compConnectionInfo;


typedef struct compConnectConfig_s {

    int                         grpSrc, grpDest;

    short int                   connId;

} compConnectConfig;


typedef struct NeuralDynamicsConfig_s {

    NeuralDynamicsConfig_s() : Izh_a(-1.0f), Izh_a_sd(-1.0f), Izh_b(-1.0f), Izh_b_sd(-1.0f),

                               Izh_c(-1.0f), Izh_c_sd(-1.0f), Izh_d(-1.0f), Izh_d_sd(-1.0f),

                               Izh_C(-1.0f), Izh_C_sd(-1.0f), Izh_k(-1.0f), Izh_k_sd(-1.0f),

                               Izh_vr(-1.0f), Izh_vr_sd(1.0f), Izh_vt(1.0f), Izh_vt_sd(-1.0f),

                               Izh_vpeak(-1.0f), Izh_vpeak_sd(-1.0f), lif_tau_m(-1),

                               lif_tau_ref(-1), lif_vTh(1.0f), lif_vReset(0.0f), lif_minRmem(1.0f),

                               lif_maxRmem(1.0f)

    {}

    float       Izh_C;

    float       Izh_C_sd;

    float       Izh_k;

    float       Izh_k_sd;

    float       Izh_vr;

    float       Izh_vr_sd;

    float       Izh_vt;

    float       Izh_vt_sd;

    float       Izh_vpeak;

    float       Izh_vpeak_sd;

    float       Izh_a;

    float       Izh_a_sd;

    float       Izh_b;

    float       Izh_b_sd;

    float       Izh_c;

    float       Izh_c_sd;

    float       Izh_d;

    float       Izh_d_sd;

    int         lif_tau_m;

    int         lif_tau_ref;

    float       lif_vTh;

    float       lif_vReset;

    double      lif_minRmem;

    double      lif_maxRmem;

} NeuralDynamicsConfig;


typedef struct STDPConfig_s {

    STDPConfig_s() : WithSTDP(false), WithESTDP(false), WithISTDP(false),

        WithESTDPtype(UNKNOWN_STDP), WithISTDPtype(UNKNOWN_STDP), WithESTDPcurve(UNKNOWN_CURVE), WithISTDPcurve(UNKNOWN_CURVE)

    {}

    bool WithSTDP;

    bool WithESTDP;

    bool WithISTDP;

    STDPType WithESTDPtype;

    STDPType WithISTDPtype;

    STDPCurve WithESTDPcurve;

    STDPCurve WithISTDPcurve;

    float        TAU_PLUS_INV_EXC;

    float        TAU_MINUS_INV_EXC;

    float        ALPHA_PLUS_EXC;

    float        ALPHA_MINUS_EXC;

    float        GAMMA;

    float        KAPPA;

    float        OMEGA;

    float        TAU_PLUS_INV_INB;

    float        TAU_MINUS_INV_INB;

    float        ALPHA_PLUS_INB;

    float        ALPHA_MINUS_INB;

    float        BETA_LTP;

    float        BETA_LTD;

    float        LAMBDA;

    float        DELTA;

} STDPConfig;


typedef struct STPConfig_s {

    STPConfig_s() : WithSTP(false), STP_A(-1.0f), STP_U(-1.0f), STP_tau_u_inv(-1.0f), STP_tau_x_inv(-1.0f)

    {}


    bool WithSTP;

    float STP_A; // scaling factor

    float STP_U;

    float STP_tau_u_inv; // facilitatory

    float STP_tau_x_inv; // depressive

} STPConfig;


typedef struct HomeostasisConfig_s {

    HomeostasisConfig_s() : WithHomeostasis(false), baseFiring(-1.0f), baseFiringSD(-1.0f),

                            avgTimeScale(-1.0f), avgTimeScaleInv(-1.0f), avgTimeScaleDecay(-1.0f),

                            homeostasisScale(-1.0f)

    {}


    bool WithHomeostasis;

    float baseFiring;

    float baseFiringSD;

    float avgTimeScale;

    float avgTimeScaleInv;

    float avgTimeScaleDecay;

    float homeostasisScale;

} HomeostasisConfig;


typedef struct NeuromodulatorConfig_s {

    NeuromodulatorConfig_s() : baseDP(1.0f), base5HT(1.0f), baseACh(1.0f), baseNE(1.0f),

                               decayDP(0.99f), decay5HT(0.99f), decayACh(0.99f), decayNE(0.99f)

    {}


    float baseDP;

    float base5HT;

    float baseACh;

    float baseNE;

    float decayDP;

    float decay5HT;

    float decayACh;

    float decayNE;

} NeuromodulatorConfig;


typedef struct GroupConfig_s {

    GroupConfig_s() : grpName("N/A"), preferredNetId(-2), type(0), numN(-1), isSpikeGenerator(false), spikeGenFunc(NULL)

    {}


    // properties of neural group size and location

    std::string  grpName;

    int          preferredNetId;

    unsigned int type;

    int          numN;

    bool isSpikeGenerator;

    bool withParamModel_9;

    bool isLIF;

    bool withCompartments;


    float compCouplingUp;

    float compCouplingDown;


    SpikeGeneratorCore* spikeGenFunc;


    Grid3D grid; //<! location information of neurons

    NeuralDynamicsConfig neuralDynamicsConfig;

    STDPConfig stdpConfig;

    STPConfig stpConfig;

    HomeostasisConfig homeoConfig;

    NeuromodulatorConfig neuromodulatorConfig;

} GroupConfig;


typedef struct GroupConfigMD_s {

    GroupConfigMD_s() : gGrpId(-1), gStartN(-1), gEndN(-1),

                        lGrpId(-1), lStartN(-1), lEndN(-1),

                        netId(-1), maxOutgoingDelay(1), fixedInputWts(true), hasExternalConnect(false),

                        LtoGOffset(0), GtoLOffset(0), numPostSynapses(0), numPreSynapses(0), Noffset(0),

                        spikeMonitorId(-1), neuronMonitorId(-1), groupMonitorId(-1), currTimeSlice(1000), sliceUpdateTime(0), homeoId(-1), ratePtr(NULL)

    {}


    int gGrpId;

    int gStartN;

    int gEndN;

    int netId;

    int lGrpId;

    int lStartN;

    int lEndN;

    int LtoGOffset;

    int GtoLOffset;

    int numPostSynapses;

    int numPreSynapses;

    int maxOutgoingDelay;

    bool fixedInputWts;

    bool hasExternalConnect;

    int spikeMonitorId;

    int neuronMonitorId;

    int groupMonitorId;

    float refractPeriod;

    int currTimeSlice;

    int sliceUpdateTime;

    int homeoId;

    int Noffset;

    PoissonRate* ratePtr;


    bool operator== (const struct GroupConfigMD_s& grp) {

        return (gGrpId == grp.gGrpId);

    }

} GroupConfigMD;


typedef struct GroupConfigRT_s {

    int          netId;

    int          gGrpId;

    int          gStartN;

    int          gEndN;

    int          lGrpId;

    int          lStartN;

    int          lEndN;

    int          LtoGOffset;

    int          GtoLOffset;

    unsigned int Type;

    int          numN;

    int          numPostSynapses;

    int          numPreSynapses;

    bool         isSpikeGenerator;

    bool         isSpikeGenFunc;

    bool         WithSTP;

    bool         WithSTDP;

    bool         WithESTDP;

    bool         WithISTDP;

    STDPType     WithESTDPtype;

    STDPType     WithISTDPtype;

    STDPCurve    WithESTDPcurve;

    STDPCurve    WithISTDPcurve;

    bool         WithHomeostasis;

    bool         FixedInputWts;

    bool         hasExternalConnect;

    int          Noffset;

    int8_t       MaxDelay;


    float        STP_A;

    float        STP_U;

    float        STP_tau_u_inv;

    float        STP_tau_x_inv;

    float        TAU_PLUS_INV_EXC;

    float        TAU_MINUS_INV_EXC;

    float        ALPHA_PLUS_EXC;

    float        ALPHA_MINUS_EXC;

    float        GAMMA;

    float        KAPPA;

    float        OMEGA;

    float        TAU_PLUS_INV_INB;

    float        TAU_MINUS_INV_INB;

    float        ALPHA_PLUS_INB;

    float        ALPHA_MINUS_INB;

    float        BETA_LTP;

    float        BETA_LTD;

    float        LAMBDA;

    float        DELTA;


    float avgTimeScale;

    float avgTimeScale_decay;

    float avgTimeScaleInv;

    float homeostasisScale;


                                    // parameters of neuromodulator

    float baseDP;

    float base5HT;

    float baseACh;

    float baseNE;

    float decayDP;

    float decay5HT;

    float decayACh;

    float decayNE;


    bool withParamModel_9;

    bool isLIF;


    bool withCompartments;

    float compCouplingUp;

    float compCouplingDown;

    int   compNeighbors[4];

    float compCoupling[4];

    short numCompNeighbors;

} GroupConfigRT;


typedef struct RuntimeData_s {

    unsigned int spikeCountSec;

    unsigned int spikeCountD1Sec;

    unsigned int spikeCountD2Sec;

    unsigned int spikeCountExtRxD1Sec;

    unsigned int spikeCountExtRxD2Sec;

    unsigned int spikeCount;

    unsigned int spikeCountD1;

    unsigned int spikeCountD2;

    unsigned int nPoissonSpikes;

    unsigned int spikeCountLastSecLeftD2;

    unsigned int spikeCountExtRxD2;

    unsigned int spikeCountExtRxD1;


    float* voltage;

    float* nextVoltage;

    float* recovery;

    float* Izh_C;

    float* Izh_k;

    float* Izh_vr;

    float* Izh_vt;

    float* Izh_vpeak;

    float* Izh_a;

    float* Izh_b;

    float* Izh_c;

    float* Izh_d;

    float* current;

    float* totalCurrent;

    float* extCurrent;


    int* lif_tau_m;

    int* lif_tau_ref;

    int* lif_tau_ref_c; // current refractory of the neuron

    float* lif_vTh;

    float* lif_vReset;

    float* lif_gain;

    float* lif_bias;


    bool* curSpike;


    // conductances and stp values

    float* gNMDA;

    float* gNMDA_r;

    float* gNMDA_d;

    float* gAMPA;

    float* gGABAa;

    float* gGABAb;

    float* gGABAb_r;

    float* gGABAb_d;


    int* I_set;


    MemType memType;

    bool allocated;


    /* Tsodyks & Markram (1998), where the short-term dynamics of synapses is characterized by three parameters:

       U (which roughly models the release probability of a synaptic vesicle for the first spike in a train of spikes),

       maxDelay_ (time constant for recovery from depression), and F (time constant for recovery from facilitation). */

    float* stpx;

    float* stpu;


    unsigned short* Npre;

    unsigned short* Npre_plastic;

    float*          Npre_plasticInv;

    unsigned short* Npost;


    int* lastSpikeTime;

    int* synSpikeTime;


    float* wtChange;

    float* wt;

    float* maxSynWt;


    unsigned int* cumulativePost;

    unsigned int* cumulativePre;


    short int* connIdsPreIdx;

    short int* grpIds;


    SynInfo* postSynapticIds;

    SynInfo* preSynapticIds;


    DelayInfo* postDelayInfo;

    unsigned int* timeTableD1;

    unsigned int* timeTableD2;


    int* firingTableD1;

    int* firingTableD2;


    int** extFiringTableD1;

    int** extFiringTableD2;


    int* extFiringTableEndIdxD1;

    int* extFiringTableEndIdxD2;


    float* poissonFireRate;

    float* randNum;

#ifndef __NO_CUDA__

    int2* neuronAllocation;

    int3* groupIdInfo;

#endif


    int*  nSpikeCnt;


    float* baseFiringInv;

    float* baseFiring;

    float* avgFiring;


    float* grpDA;

    float* grp5HT;

    float* grpACh;

    float* grpNE;


    // group monitor assistive buffers

    float* grpDABuffer;

    float* grp5HTBuffer;

    float* grpAChBuffer;

    float* grpNEBuffer;


    // neuron monitor assistive buffers

    float* nVBuffer;

    float* nUBuffer;

    float* nIBuffer;


    unsigned int* spikeGenBits;

#ifndef __NO_CUDA__

    curandGenerator_t gpuRandGen;

#endif

} RuntimeData;


typedef struct GlobalNetworkConfig_s {

    GlobalNetworkConfig_s() : numN(0), numNReg(0), numNPois(0),

                              numNExcReg(0), numNInhReg(0), numNExcPois(0), numNInhPois(0),

                              numSynNet(0), maxDelay(-1), numN1msDelay(0), numN2msDelay(0),

                              simIntegrationMethod(FORWARD_EULER),

                              simNumStepsPerMs(2), timeStep(0.5)

    {}


    int numN;

    int numNExcReg;

    int numNInhReg;

    int numNReg;

    int numComp;

    int numNExcPois;

    int numNInhPois;

    int numNPois;

    int numSynNet;

    int maxDelay;

    int numN1msDelay;

    int numN2msDelay;


    integrationMethod_t simIntegrationMethod;

    int simNumStepsPerMs;

    float timeStep;

} GlobalNetworkConfig;


typedef struct NetworkConfigRT_s  {

    // global configuration for maximum axonal delay

    int maxDelay;


    // configurations for boundries of neural types

    int numN;

    int numNExcReg;

    int numNInhReg;

    int numNReg;

    int numComp;

    int numNExcPois;

    int numNInhPois;

    int numNPois;

    int numNSpikeGen;

    int numNRateGen;

    int numNExternal;

    int numNAssigned;


    // configurations for runtime data sizes

    unsigned int I_setLength;

    size_t       I_setPitch;

    size_t       STP_Pitch;

    int numPostSynNet;

    int numPreSynNet;

    int maxNumPostSynN;

    int maxNumPreSynN;

    unsigned int maxSpikesD2;

    unsigned int maxSpikesD1;


    // configurations for assigned groups and connections

    int numGroups;

    int numGroupsAssigned;

    int numConnections;

    //int numAssignedConnections; //!< number of connections assigned to this local network


    // configurations for execution features

    bool sim_with_fixedwts;

    bool sim_with_conductances;

    bool sim_with_compartments;

    bool sim_with_stdp;

    bool sim_with_modulated_stdp;

    bool sim_with_homeostasis;

    bool sim_with_stp;

    bool sim_in_testing;


    // please note that spike monitor and connection monitor don't need this flag because no extra buffer is required

    // for neuron monitor, the kernel allocates extra buffers to store v, u, i values of each monitored neuron

    bool sim_with_nm; // simulation with neuron monitor


    // stdp, da-stdp configurations

    float stdpScaleFactor;

    float wtChangeDecay;


    // conductance configurations

    bool sim_with_NMDA_rise;

    bool sim_with_GABAb_rise;

    double dAMPA;

    double rNMDA;

    double dNMDA;

    double sNMDA;

    double dGABAa;

    double rGABAb;

    double dGABAb;

    double sGABAb;


    integrationMethod_t simIntegrationMethod;

    int simNumStepsPerMs;

    float timeStep;

} NetworkConfigRT;


typedef struct RoutingTableEntry_s {

    RoutingTableEntry_s() : srcNetId(-1), destNetId(-1) {}


    RoutingTableEntry_s(int srcNetId_, int destNetId_) : srcNetId(srcNetId_), destNetId(destNetId_) {}


    int srcNetId;

    int destNetId;


    bool operator== (const struct RoutingTableEntry_s& rte) const {

        return (srcNetId == rte.srcNetId && destNetId == rte.destNetId);

    }

} RoutingTableEntry;


typedef struct ThreadStruct_s {

    void* snn_pointer;

    int netId;

    int lGrpId;

    int startIdx;

    int endIdx;

    int GtoLOffset;

} ThreadStruct;


#endif