synapseGroup.h

Go to the documentation of this file.

#pragma once

// Standard includes
#include <map>
#include <string>
#include <vector>

// GeNN includes
#include "gennExport.h"
#include "initSparseConnectivitySnippet.h"
#include "initToeplitzConnectivitySnippet.h"
#include "postsynapticModels.h"
#include "weightUpdateModels.h"
#include "synapseMatrixType.h"
#include "variableMode.h"

// Forward declarations
class NeuronGroupInternal;
class SynapseGroupInternal;

//------------------------------------------------------------------------
// SynapseGroup
//------------------------------------------------------------------------
class GENN_EXPORT SynapseGroup
{
public:
    SynapseGroup(const SynapseGroup&) = delete;
    SynapseGroup() = delete;

    //------------------------------------------------------------------------
    // Enumerations
    //------------------------------------------------------------------------
    enum class SpanType
    {
        POSTSYNAPTIC,
        PRESYNAPTIC
    };

    //------------------------------------------------------------------------
    // Public methods
    //------------------------------------------------------------------------

    void setWUVarLocation(const std::string &varName, VarLocation loc);


    void setWUPreVarLocation(const std::string &varName, VarLocation loc);
    

    void setWUPostVarLocation(const std::string &varName, VarLocation loc);
    

    void setWUExtraGlobalParamLocation(const std::string &paramName, VarLocation loc);


    void setPSVarLocation(const std::string &varName, VarLocation loc);


    void setPSExtraGlobalParamLocation(const std::string &paramName, VarLocation loc);


    void setPSTargetVar(const std::string &varName);
    

    void setPreTargetVar(const std::string &varName);


    void setSparseConnectivityExtraGlobalParamLocation(const std::string &paramName, VarLocation loc);


    void setInSynVarLocation(VarLocation loc) { m_InSynLocation = loc; }


    void setSparseConnectivityLocation(VarLocation loc);

    void setDendriticDelayLocation(VarLocation loc) { m_DendriticDelayLocation = loc; }


    void setMaxConnections(unsigned int maxConnections);


    void setMaxSourceConnections(unsigned int maxPostConnections);
    
    void setMaxDendriticDelayTimesteps(unsigned int maxDendriticDelay);
    

    void setSpanType(SpanType spanType);

    // **TODO** this shouldn't be in SynapseGroup - it's backend-specific
    void setNumThreadsPerSpike(unsigned int numThreadsPerSpike);

    void setBackPropDelaySteps(unsigned int timesteps);

    void setNarrowSparseIndEnabled(bool enabled);

    //------------------------------------------------------------------------
    // Public const methods
    //------------------------------------------------------------------------
    const std::string &getName() const{ return m_Name; }

    SpanType getSpanType() const{ return m_SpanType; }
    unsigned int getNumThreadsPerSpike() const{ return m_NumThreadsPerSpike; }
    unsigned int getDelaySteps() const{ return m_DelaySteps; }
    unsigned int getBackPropDelaySteps() const{ return m_BackPropDelaySteps; }
    unsigned int getMaxConnections() const;
    unsigned int getMaxSourceConnections() const;
    unsigned int getMaxDendriticDelayTimesteps() const{ return m_MaxDendriticDelayTimesteps; }
    SynapseMatrixType getMatrixType() const{ return m_MatrixType; }
    const std::vector<unsigned int> &getKernelSize() const { return m_KernelSize; }
    size_t getKernelSizeFlattened() const;
    
    VarLocation getInSynLocation() const { return m_InSynLocation; }

    VarLocation getSparseConnectivityLocation() const;

    VarLocation getDendriticDelayLocation() const{ return m_DendriticDelayLocation; }

    bool isTrueSpikeRequired() const;

    bool isSpikeEventRequired() const;

    bool isWeightSharingSlave() const { return (getWeightSharingMaster() != nullptr); }


    bool isPSModelFused() const{ return m_FusedPSVarSuffix != getName(); }
    

    bool isWUPreModelFused() const { return m_FusedWUPreVarSuffix != getName(); }


    bool isWUPostModelFused() const { return m_FusedWUPostVarSuffix != getName(); }


    std::string getSparseIndType() const;

    const WeightUpdateModels::Base *getWUModel() const{ return m_WUModel; }

    const std::vector<double> &getWUParams() const{ return m_WUParams; }
    const std::vector<Models::VarInit> &getWUVarInitialisers() const{ return m_WUVarInitialisers; }
    const std::vector<Models::VarInit> &getWUPreVarInitialisers() const{ return m_WUPreVarInitialisers; }
    const std::vector<Models::VarInit> &getWUPostVarInitialisers() const{ return m_WUPostVarInitialisers; }
    const std::vector<double> getWUConstInitVals() const;

    const PostsynapticModels::Base *getPSModel() const{ return m_PSModel; }

    const std::vector<double> &getPSParams() const{ return m_PSParams; }
    const std::vector<Models::VarInit> &getPSVarInitialisers() const{ return m_PSVarInitialisers; }
    const std::vector<double> getPSConstInitVals() const;

    const InitSparseConnectivitySnippet::Init &getConnectivityInitialiser() const{ return m_SparseConnectivityInitialiser; }
    const InitToeplitzConnectivitySnippet::Init &getToeplitzConnectivityInitialiser() const { return m_ToeplitzConnectivityInitialiser; }

    bool isZeroCopyEnabled() const;

    VarLocation getWUVarLocation(const std::string &var) const;

    VarLocation getWUVarLocation(size_t index) const;

    VarLocation getWUPreVarLocation(const std::string &var) const;

    VarLocation getWUPreVarLocation(size_t index) const{ return m_WUPreVarLocation.at(index); }

    VarLocation getWUPostVarLocation(const std::string &var) const;

    VarLocation getWUPostVarLocation(size_t index) const{ return m_WUPostVarLocation.at(index); }


    VarLocation getWUExtraGlobalParamLocation(const std::string &paramName) const;


    VarLocation getWUExtraGlobalParamLocation(size_t index) const{ return m_WUExtraGlobalParamLocation.at(index); }

    VarLocation getPSVarLocation(const std::string &var) const;

    VarLocation getPSVarLocation(size_t index) const{ return m_PSVarLocation.at(index); }


    VarLocation getPSExtraGlobalParamLocation(const std::string &paramName) const;


    VarLocation getPSExtraGlobalParamLocation(size_t index) const{ return m_PSExtraGlobalParamLocation.at(index); }


    const std::string &getPSTargetVar() const{ return m_PSTargetVar; }


    const std::string &getPreTargetVar() const{ return m_PreTargetVar; }
    

    VarLocation getSparseConnectivityExtraGlobalParamLocation(const std::string &paramName) const;


    VarLocation getSparseConnectivityExtraGlobalParamLocation(size_t index) const;

    bool isDendriticDelayRequired() const;

    bool isPresynapticOutputRequired() const;    
    
    bool isProceduralConnectivityRNGRequired() const;

    bool isPSInitRNGRequired() const;

    bool isWUInitRNGRequired() const;

    bool isWUPreInitRNGRequired() const;

    bool isWUPostInitRNGRequired() const;

    bool isHostInitRNGRequired() const;

    bool isWUVarInitRequired() const;

    bool isSparseConnectivityInitRequired() const;

protected:
    SynapseGroup(const std::string &name, SynapseMatrixType matrixType, unsigned int delaySteps,
                 const WeightUpdateModels::Base *wu, const std::vector<double> &wuParams, const std::vector<Models::VarInit> &wuVarInitialisers, const std::vector<Models::VarInit> &wuPreVarInitialisers, const std::vector<Models::VarInit> &wuPostVarInitialisers,
                 const PostsynapticModels::Base *ps, const std::vector<double> &psParams, const std::vector<Models::VarInit> &psVarInitialisers,
                 NeuronGroupInternal *srcNeuronGroup, NeuronGroupInternal *trgNeuronGroup, const SynapseGroupInternal *weightSharingMaster,
                 const InitSparseConnectivitySnippet::Init &connectivityInitialiser,
                 const InitToeplitzConnectivitySnippet::Init &toeplitzInitialiser,
                 VarLocation defaultVarLocation, VarLocation defaultExtraGlobalParamLocation,
                 VarLocation defaultSparseConnectivityLocation, bool defaultNarrowSparseIndEnabled);

    //------------------------------------------------------------------------
    // Protected methods
    //------------------------------------------------------------------------
    NeuronGroupInternal *getSrcNeuronGroup(){ return m_SrcNeuronGroup; }
    NeuronGroupInternal *getTrgNeuronGroup(){ return m_TrgNeuronGroup; }

    void setEventThresholdReTestRequired(bool req){ m_EventThresholdReTestRequired = req; }

    void setWUVarReferencedByCustomUpdate(bool ref) { m_WUVarReferencedByCustomUpdate = ref;  }

    void setFusedPSVarSuffix(const std::string &suffix){ m_FusedPSVarSuffix = suffix; }
    void setFusedWUPreVarSuffix(const std::string &suffix){ m_FusedWUPreVarSuffix = suffix; }
    void setFusedWUPostVarSuffix(const std::string &suffix){ m_FusedWUPostVarSuffix = suffix; }
    void setFusedPreOutputSuffix(const std::string &suffix){ m_FusedPreOutputSuffix = suffix; }
    
    void initDerivedParams(double dt);

    //------------------------------------------------------------------------
    // Protected const methods
    //------------------------------------------------------------------------
    const NeuronGroupInternal *getSrcNeuronGroup() const{ return m_SrcNeuronGroup; }
    const NeuronGroupInternal *getTrgNeuronGroup() const{ return m_TrgNeuronGroup; }

    const std::vector<double> &getWUDerivedParams() const{ return m_WUDerivedParams; }
    const std::vector<double> &getPSDerivedParams() const{ return m_PSDerivedParams; }

    const SynapseGroupInternal *getWeightSharingMaster() const { return m_WeightSharingMaster; }


    bool isEventThresholdReTestRequired() const{ return m_EventThresholdReTestRequired; }

    const std::string &getFusedPSVarSuffix() const{ return m_FusedPSVarSuffix; }
    const std::string &getFusedWUPreVarSuffix() const { return m_FusedWUPreVarSuffix; }
    const std::string &getFusedWUPostVarSuffix() const { return m_FusedWUPostVarSuffix; }
    const std::string &getFusedPreOutputSuffix() const { return m_FusedPreOutputSuffix; }

    bool areWUVarReferencedByCustomUpdate() const { return m_WUVarReferencedByCustomUpdate;  }

    bool canPSBeFused() const;
    
    bool canWUMPreUpdateBeFused() const;

    bool canPreOutputBeFused() const;   
    
    bool canWUMPostUpdateBeFused() const;
    

    boost::uuids::detail::sha1::digest_type getWUHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPreHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPostHashDigest() const;


    boost::uuids::detail::sha1::digest_type getPSHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPreFuseHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPostFuseHashDigest() const;


    boost::uuids::detail::sha1::digest_type getPSFuseHashDigest() const;


    boost::uuids::detail::sha1::digest_type getPreOutputHashDigest() const;

    boost::uuids::detail::sha1::digest_type getDendriticDelayUpdateHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUInitHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPreInitHashDigest() const;


    boost::uuids::detail::sha1::digest_type getWUPostInitHashDigest() const;


    boost::uuids::detail::sha1::digest_type getPSInitHashDigest() const;


    boost::uuids::detail::sha1::digest_type getPreOutputInitHashDigest() const;
    

    boost::uuids::detail::sha1::digest_type getConnectivityInitHashDigest() const;


    boost::uuids::detail::sha1::digest_type getConnectivityHostInitHashDigest() const;
    
    boost::uuids::detail::sha1::digest_type getVarLocationHashDigest() const;
private:
    //------------------------------------------------------------------------
    // Members
    //------------------------------------------------------------------------
    const std::string m_Name;

    SpanType m_SpanType;

    unsigned int m_NumThreadsPerSpike;

    unsigned int m_DelaySteps;

    unsigned int m_BackPropDelaySteps;

    unsigned int m_MaxConnections;
    
    unsigned int m_MaxSourceConnections;

    unsigned int m_MaxDendriticDelayTimesteps;

    std::vector<unsigned int> m_KernelSize;
    
    const SynapseMatrixType m_MatrixType;

    NeuronGroupInternal * const m_SrcNeuronGroup;

    NeuronGroupInternal * const m_TrgNeuronGroup;

    const SynapseGroupInternal *m_WeightSharingMaster;


    bool m_EventThresholdReTestRequired;

    bool m_NarrowSparseIndEnabled;

    bool m_WUVarReferencedByCustomUpdate;

    VarLocation m_InSynLocation;

    VarLocation m_DendriticDelayLocation;

    const WeightUpdateModels::Base *m_WUModel;

    const std::vector<double> m_WUParams;

    std::vector<double> m_WUDerivedParams;

    std::vector<Models::VarInit> m_WUVarInitialisers;

    std::vector<Models::VarInit> m_WUPreVarInitialisers;

    std::vector<Models::VarInit> m_WUPostVarInitialisers;
    
    const PostsynapticModels::Base *m_PSModel;

    const std::vector<double> m_PSParams;

    std::vector<double> m_PSDerivedParams;

    std::vector<Models::VarInit> m_PSVarInitialisers;

    std::vector<VarLocation> m_WUVarLocation;

    std::vector<VarLocation> m_WUPreVarLocation;

    std::vector<VarLocation> m_WUPostVarLocation;

    std::vector<VarLocation> m_WUExtraGlobalParamLocation;

    std::vector<VarLocation> m_PSVarLocation;

    std::vector<VarLocation> m_PSExtraGlobalParamLocation;

    InitSparseConnectivitySnippet::Init m_SparseConnectivityInitialiser;

    InitToeplitzConnectivitySnippet::Init m_ToeplitzConnectivityInitialiser;

    VarLocation m_SparseConnectivityLocation;

    std::vector<VarLocation> m_ConnectivityExtraGlobalParamLocation;


    std::string m_FusedPSVarSuffix;


    std::string m_FusedWUPreVarSuffix;
    

    std::string m_FusedWUPostVarSuffix;


    std::string m_FusedPreOutputSuffix;


    std::string m_PSTargetVar;


    std::string m_PreTargetVar;
};