neuronGroup.h

Go to the documentation of this file.

#pragma once

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

// GeNN includes
#include "global.h"
#include "newNeuronModels.h"
#include "variableMode.h"

class CurrentSource;

//------------------------------------------------------------------------
// NeuronGroup
//------------------------------------------------------------------------
class NeuronGroup
{
public:
    NeuronGroup(const std::string &name, int numNeurons, const NeuronModels::Base *neuronModel,
                const std::vector<double> &params, const std::vector<NewModels::VarInit> &varInitialisers, int hostID, int deviceID) :
        m_Name(name), m_NumNeurons(numNeurons), m_IDRange(0, 0), m_PaddedIDRange(0, 0),
        m_NeuronModel(neuronModel), m_Params(params), m_VarInitialisers(varInitialisers),
        m_SpikeTimeRequired(false), m_TrueSpikeRequired(false), m_SpikeEventRequired(false),
        m_NumDelaySlots(1), m_VarQueueRequired(varInitialisers.size(), false),
        m_SpikeVarMode(GENN_PREFERENCES::defaultVarMode), m_SpikeEventVarMode(GENN_PREFERENCES::defaultVarMode),
        m_SpikeTimeVarMode(GENN_PREFERENCES::defaultVarMode), m_VarMode(varInitialisers.size(), GENN_PREFERENCES::defaultVarMode),
        m_HostID(hostID), m_DeviceID(deviceID)
    {
    }
    NeuronGroup(const NeuronGroup&) = delete;
    NeuronGroup() = delete;

    //------------------------------------------------------------------------
    // Public methods
    //------------------------------------------------------------------------
    void checkNumDelaySlots(unsigned int requiredDelay);

    void updatePreVarQueues(const std::string &code);

    void updatePostVarQueues(const std::string &code);

    void setSpikeTimeRequired(bool req){ m_SpikeTimeRequired = req; }
    void setTrueSpikeRequired(bool req){ m_TrueSpikeRequired = req; }
    void setSpikeEventRequired(bool req){ m_SpikeEventRequired = req; }


    void setSpikeZeroCopyEnabled(bool enabled)
    {
        m_SpikeVarMode = enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST;
    }


    void setSpikeEventZeroCopyEnabled(bool enabled)
    {
        m_SpikeEventVarMode = enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST;
    }


    void setSpikeTimeZeroCopyEnabled(bool enabled)
    {
        m_SpikeTimeVarMode = enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST;
    }


    void setVarZeroCopyEnabled(const std::string &varName, bool enabled)
    {
        setVarMode(varName, enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST);
    }


    void setSpikeVarMode(VarMode mode) { m_SpikeVarMode = mode; }


    void setSpikeEventVarMode(VarMode mode) { m_SpikeEventVarMode = mode; }


    void setSpikeTimeVarMode(VarMode mode) { m_SpikeTimeVarMode = mode; }


    void setVarMode(const std::string &varName, VarMode mode);

    void addSpkEventCondition(const std::string &code, const std::string &supportCodeNamespace);

    void addInSyn(SynapseGroup *synapseGroup){ m_InSyn.push_back(synapseGroup); }
    void addOutSyn(SynapseGroup *synapseGroup){ m_OutSyn.push_back(synapseGroup); }

    void initDerivedParams(double dt);
    void calcSizes(unsigned int blockSize, unsigned int &idStart, unsigned int &paddedIDStart);

    void mergeIncomingPSM();

    void injectCurrent(CurrentSource *source);

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

    unsigned int getNumNeurons() const{ return m_NumNeurons; }
    const std::pair<unsigned int, unsigned int> &getPaddedIDRange() const{ return m_PaddedIDRange; }
    const std::pair<unsigned int, unsigned int> &getIDRange() const{ return m_IDRange; }

    const NeuronModels::Base *getNeuronModel() const{ return m_NeuronModel; }

    const std::vector<double> &getParams() const{ return m_Params; }
    const std::vector<double> &getDerivedParams() const{ return m_DerivedParams; }
    const std::vector<NewModels::VarInit> &getVarInitialisers() const{ return m_VarInitialisers; }

    const std::vector<SynapseGroup*> &getInSyn() const{ return m_InSyn; }
    const std::vector<std::pair<SynapseGroup*, std::vector<SynapseGroup*>>> &getMergedInSyn() const{ return m_MergedInSyn; }

    const std::vector<SynapseGroup*> &getOutSyn() const{ return m_OutSyn; }

    const std::vector<CurrentSource*> &getCurrentSources() const { return m_CurrentSources; }

    int getClusterHostID() const{ return m_HostID; }

    int getClusterDeviceID() const{ return m_DeviceID; }

    bool isSpikeTimeRequired() const{ return m_SpikeTimeRequired; }
    bool isTrueSpikeRequired() const{ return m_TrueSpikeRequired; }
    bool isSpikeEventRequired() const{ return m_SpikeEventRequired; }

    bool isVarQueueRequired(const std::string &var) const;
    bool isVarQueueRequired(size_t index) const{ return m_VarQueueRequired[index]; }

    const std::set<std::pair<std::string, std::string>> &getSpikeEventCondition() const{ return m_SpikeEventCondition; }

    unsigned int getNumDelaySlots() const{ return m_NumDelaySlots; }
    bool isDelayRequired() const{ return (m_NumDelaySlots > 1); }

    bool isSpikeZeroCopyEnabled() const{ return (m_SpikeVarMode & VarLocation::ZERO_COPY); }
    bool isSpikeEventZeroCopyEnabled() const{ return (m_SpikeEventVarMode & VarLocation::ZERO_COPY); }
    bool isSpikeTimeZeroCopyEnabled() const{ return (m_SpikeTimeVarMode & VarLocation::ZERO_COPY); }
    bool isZeroCopyEnabled() const;
    bool isVarZeroCopyEnabled(const std::string &var) const{ return (getVarMode(var) & VarLocation::ZERO_COPY); }

    VarMode getSpikeVarMode() const{ return m_SpikeVarMode; }

    VarMode getSpikeEventVarMode() const{ return m_SpikeEventVarMode; }

    VarMode getSpikeTimeVarMode() const{ return m_SpikeTimeVarMode; }

    VarMode getVarMode(const std::string &varName) const;

    VarMode getVarMode(size_t index) const{ return m_VarMode[index]; }

    bool isParamRequiredBySpikeEventCondition(const std::string &pnamefull) const;

    void addExtraGlobalParams(std::map<std::string, std::string> &kernelParameters) const;

    bool isInitCodeRequired() const;

    bool isSimRNGRequired() const;

    bool isInitRNGRequired(VarInit varInitMode) const;

    bool isDeviceVarInitRequired() const;

    bool isDeviceInitRequired() const;


    bool canRunOnCPU() const;

    bool hasOutputToHost(int targetHostID) const;

    std::string getCurrentQueueOffset(const std::string &devPrefix) const;

    std::string getPrevQueueOffset(const std::string &devPrefix) const;

private:
    //------------------------------------------------------------------------
    // Private methods
    //------------------------------------------------------------------------
    void updateVarQueues(const std::string &code, const std::string &suffix);

    //------------------------------------------------------------------------
    // Members
    //------------------------------------------------------------------------
    std::string m_Name;

    unsigned int m_NumNeurons;
    std::pair<unsigned int, unsigned int> m_IDRange;
    std::pair<unsigned int, unsigned int> m_PaddedIDRange;

    const NeuronModels::Base *m_NeuronModel;
    std::vector<double> m_Params;
    std::vector<double> m_DerivedParams;
    std::vector<NewModels::VarInit> m_VarInitialisers;
    std::vector<SynapseGroup*> m_InSyn;
    std::vector<SynapseGroup*> m_OutSyn;
    std::vector<std::pair<SynapseGroup*, std::vector<SynapseGroup*>>> m_MergedInSyn;
    bool m_SpikeTimeRequired;
    bool m_TrueSpikeRequired;
    bool m_SpikeEventRequired;
    std::set<std::pair<std::string, std::string>> m_SpikeEventCondition;
    unsigned int m_NumDelaySlots;
    std::vector<CurrentSource*> m_CurrentSources;

    std::vector<bool> m_VarQueueRequired;

    VarMode m_SpikeVarMode;

    VarMode m_SpikeEventVarMode;

    VarMode m_SpikeTimeVarMode;

    std::vector<VarMode> m_VarMode;

    int m_HostID;

    int m_DeviceID;
};