Access to postsynaptic variables with heterogeneous delay

include/genn/genn/code_generator/environment.h

@@ -807,41 +807,35 @@ class VarCachePolicy
     using GroupInternal = typename G::GroupInternal;
     using AdapterDef = typename std::invoke_result_t<decltype(&A::getDefs), A>::value_type;
     using AdapterAccess = typename AdapterDef::AccessType;
-    using GetIndexFn = std::function<std::string(const std::string&, AdapterAccess)>;
-    using ShouldAlwaysCopyFn = std::function<bool(const std::string&, AdapterAccess)>;
+    using GetIndexFn = std::function<std::string(const std::string&, AdapterAccess, bool)>;
 
     VarCachePolicy(GetIndexFn getReadIndex, GetIndexFn getWriteIndex,
-                   ShouldAlwaysCopyFn shouldAlwaysCopy = ShouldAlwaysCopyFn())
+                   bool alwaysCopyIfDelayed = true)
     :   m_GetReadIndex(getReadIndex), m_GetWriteIndex(getWriteIndex), 
-        m_ShouldAlwaysCopy(shouldAlwaysCopy)
+        m_AlwaysCopyIfDelayed(alwaysCopyIfDelayed)
     {}
 
-    VarCachePolicy(GetIndexFn getIndex, ShouldAlwaysCopyFn shouldAlwaysCopy = ShouldAlwaysCopyFn())
+    VarCachePolicy(GetIndexFn getIndex, bool alwaysCopyIfDelayed = true)
     :   m_GetReadIndex(getIndex), m_GetWriteIndex(getIndex),
-        m_ShouldAlwaysCopy(shouldAlwaysCopy)
+        m_AlwaysCopyIfDelayed(alwaysCopyIfDelayed)
     {}
 
     //------------------------------------------------------------------------
     // Public API
     //------------------------------------------------------------------------
-    bool shouldAlwaysCopy(G&, const AdapterDef &var) const
+    bool shouldAlwaysCopy(G &group, const AdapterDef &var) const
     {
-        if(m_ShouldAlwaysCopy) {
-            return m_ShouldAlwaysCopy(var.name, var.access);
-        }
-        else {
-            return false;
-        }
+        return A(group.getArchetype()).isVarDelayed(var.name) && m_AlwaysCopyIfDelayed;
     }
 
-    std::string getReadIndex(G&, const AdapterDef &var) const
+    std::string getReadIndex(G &group, const AdapterDef &var) const
     {
-        return m_GetReadIndex(var.name, var.access);
+        return m_GetReadIndex(var.name, var.access, A(group.getArchetype()).isVarDelayed(var.name));
     }
 
-    std::string getWriteIndex(G&, const AdapterDef &var) const
+    std::string getWriteIndex(G &group, const AdapterDef &var) const
     {
-        return m_GetWriteIndex(var.name, var.access);
+        return m_GetWriteIndex(var.name, var.access, A(group.getArchetype()).isVarDelayed(var.name));
     }
 
     const Runtime::ArrayBase *getArray(const Runtime::Runtime &runtime, const GroupInternal &g, const AdapterDef &var) const
@@ -855,7 +849,7 @@ class VarCachePolicy
     //------------------------------------------------------------------------
     GetIndexFn m_GetReadIndex;
     GetIndexFn m_GetWriteIndex;
-    ShouldAlwaysCopyFn m_ShouldAlwaysCopy;
+    bool m_AlwaysCopyIfDelayed;
 };
 
 //------------------------------------------------------------------------

include/genn/genn/code_generator/synapseUpdateGroupMerged.h

@@ -41,28 +41,8 @@ class GENN_EXPORT SynapseGroupMergedBase : public GroupMerged<SynapseGroupIntern
     //! Should the Toeplitz connectivity initialization parameter be implemented heterogeneously?
     bool isToeplitzConnectivityInitDerivedParamHeterogeneous(const std::string &paramName) const;
 
-    std::string getPreSlot(unsigned int batchSize) const;
-    std::string getPostSlot(unsigned int batchSize) const;
-
-    std::string getPreVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const
-    {
-        return getPreVarIndex(getArchetype().getSrcNeuronGroup()->isDelayRequired(), batchSize, varDims, index);
-    }
-
-    std::string getPostVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const
-    {
-        return getPostVarIndex(getArchetype().getTrgNeuronGroup()->isDelayRequired(), batchSize, varDims, index);
-    }
-
-    std::string getPreWUVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const
-    {
-        return getPreVarIndex(getArchetype().getAxonalDelaySteps() != 0, batchSize, varDims, index);
-    }
-
-    std::string getPostWUVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const
-    {
-        return getPostVarIndex(getArchetype().getBackPropDelaySteps() != 0, batchSize, varDims, index);
-    }
+    std::string getPreSlot(bool delay, unsigned int batchSize) const;
+    std::string getPostSlot(bool delay, unsigned int batchSize) const;
 
     std::string getPostDenDelayIndex(unsigned int batchSize, const std::string &index, const std::string &offset) const;
 
@@ -89,6 +69,9 @@ class GENN_EXPORT SynapseGroupMergedBase : public GroupMerged<SynapseGroupIntern
         return ((batchSize == 1) ? "" : "$(_pre_batch_offset) + ") + index;
     }
 
+    std::string getPostVarHetDelayIndex(unsigned int batchSize, VarAccessDim varDims,
+                                        const std::string &index) const;
+
     std::string getSynVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const;
     std::string getKernelVarIndex(unsigned int batchSize, VarAccessDim varDims, const std::string &index) const;
 

include/genn/genn/customConnectivityUpdateInternal.h

@@ -85,13 +85,13 @@
     //----------------------------------------------------------------------------
     VarLocation getLoc(const std::string &varName) const{ return m_CU.getPreVarLocation(varName); }
 
-    std::vector<Models::Base::Var> getDefs() const{ return m_CU.getModel()->getPreVars(); }
+    auto getDefs() const{ return m_CU.getModel()->getPreVars(); }
 
-    const std::map<std::string, InitVarSnippet::Init> &getInitialisers() const{ return m_CU.getPreVarInitialisers(); }
+    const auto &getInitialisers() const{ return m_CU.getPreVarInitialisers(); }
 
-    bool isVarDelayed(const std::string &) const { return false; }
+    bool isVarDelayed(const std::string&) const { return false; }
 
-    const CustomConnectivityUpdate &getTarget() const{ return m_CU; }
+    const auto &getTarget() const{ return m_CU; }
 
     VarAccessDim getVarDims(const Models::Base::Var &var) const{ return getVarAccessDim(var.access); }
 
@@ -116,13 +116,13 @@
     //----------------------------------------------------------------------------
     VarLocation getLoc(const std::string &varName) const{ return m_CU.getPostVarLocation(varName); }
 
-    std::vector<Models::Base::Var> getDefs() const{ return m_CU.getModel()->getPostVars(); }
+    auto getDefs() const{ return m_CU.getModel()->getPostVars(); }
 
-    const std::map<std::string, InitVarSnippet::Init> &getInitialisers() const{ return m_CU.getPostVarInitialisers(); }
+    const auto &getInitialisers() const{ return m_CU.getPostVarInitialisers(); }
 
-    bool isVarDelayed(const std::string &) const { return false; }
+    bool isVarDelayed(const std::string&) const { return false; }
 
-    const CustomConnectivityUpdate &getTarget() const{ return m_CU; }
+    const auto &getTarget() const{ return m_CU; }
 
     VarAccessDim getVarDims(const Models::Base::Var &var) const{ return getVarAccessDim(var.access); }
 

include/genn/genn/gennUtils.h

@@ -46,6 +46,9 @@ GENN_EXPORT bool areTokensEmpty(const std::vector<Transpiler::Token> &tokens);
 //! Checks whether the sequence of token references a given identifier
 GENN_EXPORT bool isIdentifierReferenced(const std::string &identifierName, const std::vector<Transpiler::Token> &tokens);
 
+//! Checks whether the sequence of tokens references a given identifier with a delay
+GENN_EXPORT bool isIdentifierDelayed(const std::string &identifierName, const std::vector<Transpiler::Token> &tokens);
+
 //! Checks whether the sequence of token includes an RNG function identifier
 GENN_EXPORT bool isRNGRequired(const std::vector<Transpiler::Token> &tokens);
 

include/genn/genn/neuronGroup.h

@@ -154,6 +154,9 @@ class GENN_EXPORT NeuronGroup
     // Set a variable as requiring queueing
     void setVarQueueRequired(const std::string &varName){ m_VarQueueRequired.insert(varName); }
 
+    void setSpikeQueueRequired(){ m_SpikeQueueRequired = true; }
+    void setSpikeEventQueueRequired(){ m_SpikeEventQueueRequired = true; }
+
     void addInSyn(SynapseGroupInternal *synapseGroup){ m_InSyn.push_back(synapseGroup); }
     void addOutSyn(SynapseGroupInternal *synapseGroup){ m_OutSyn.push_back(synapseGroup); }
 
@@ -224,6 +227,13 @@ class GENN_EXPORT NeuronGroup
 
     bool isVarQueueRequired(const std::string &var) const;
 
+    bool isSpikeQueueRequired() const{ return m_SpikeQueueRequired; }
+
+    bool isSpikeEventQueueRequired() const{ return m_SpikeEventQueueRequired; }
+
+    bool isSpikeDelayRequired() const{ return isDelayRequired() && isSpikeQueueRequired(); }
+    bool isSpikeEventDelayRequired() const{ return isDelayRequired() && isSpikeEventQueueRequired(); }
+
     //! Updates hash with neuron group
     /*! \note this can only be called after model is finalized */
     boost::uuids::detail::sha1::digest_type getHashDigest() const;
@@ -272,6 +282,12 @@ class GENN_EXPORT NeuronGroup
 
     //! Set of names of variable requiring queueing
     std::set<std::string> m_VarQueueRequired;
+
+    //! Is queueing required for spikes?
+    bool m_SpikeQueueRequired;
+
+    //! Is queueing required for spike-like events?
+    bool m_SpikeEventQueueRequired;
 
     //! Should zero-copy memory (if available) be used 
     //! for spike and spike-like event recording?

include/genn/genn/neuronGroupInternal.h

@@ -23,6 +23,8 @@ class NeuronGroupInternal : public NeuronGroup
 
     using NeuronGroup::checkNumDelaySlots;
     using NeuronGroup::setVarQueueRequired;
+    using NeuronGroup::setSpikeQueueRequired;
+    using NeuronGroup::setSpikeEventQueueRequired;
     using NeuronGroup::addInSyn;
     using NeuronGroup::addOutSyn;
     using NeuronGroup::finalise;
@@ -49,6 +51,10 @@ class NeuronGroupInternal : public NeuronGroup
     using NeuronGroup::isRecordingEnabled;
     using NeuronGroup::isVarInitRequired;
     using NeuronGroup::isVarQueueRequired;
+    using NeuronGroup::isSpikeQueueRequired;
+    using NeuronGroup::isSpikeEventQueueRequired;
+    using NeuronGroup::isSpikeDelayRequired;
+    using NeuronGroup::isSpikeEventDelayRequired;
     using NeuronGroup::getHashDigest;
     using NeuronGroup::getInitHashDigest;
     using NeuronGroup::getSpikeQueueUpdateHashDigest;

include/genn/genn/synapseGroup.h

@@ -1,6 +1,7 @@
 #pragma once
 
 // Standard includes
+#include <optional>
 #include <map>
 #include <string>
 #include <vector>
@@ -150,7 +151,7 @@ class GENN_EXPORT SynapseGroup
     unsigned int getAxonalDelaySteps() const{ return m_AxonalDelaySteps; }
     unsigned int getMaxConnections() const{ return m_MaxConnections; }
     unsigned int getMaxSourceConnections() const{ return m_MaxSourceConnections; }
-    unsigned int getMaxDendriticDelayTimesteps() const{ return m_MaxDendriticDelayTimesteps; }
+    unsigned int getMaxDendriticDelayTimesteps() const{ return m_MaxDendriticDelayTimesteps.value_or(1); }
     SynapseMatrixType getMatrixType() const{ return m_MatrixType; }
     const auto &getKernelSize() const { return m_KernelSize; }
     size_t getKernelSizeFlattened() const;
@@ -329,8 +330,14 @@ class GENN_EXPORT SynapseGroup
     //! model been fused with those from other synapse groups?
     bool isWUPostModelFused() const { return m_FusedWUPostTarget != nullptr; }
 
-    //! Does this synapse group require dendritic delay?
-    bool isDendriticDelayRequired() const;
+    //! Is this synapse group's output dendritically delayed?
+    bool isDendriticOutputDelayRequired() const;
+
+    //! Is the named postsynaptic weight update model variable heterogeneously delayed?
+    bool isWUPostVarHeterogeneouslyDelayed(const std::string &var) const;
+
+    //! Are any postsynaptic weight update model variable heterogeneously delayed?
+    bool areAnyWUPostVarHeterogeneouslyDelayed() const;
 
     //! Does this synapse group provide presynaptic output?
     bool isPresynapticOutputRequired() const; 
@@ -465,7 +472,7 @@ class GENN_EXPORT SynapseGroup
     unsigned int m_MaxSourceConnections;
 
     //! Maximum dendritic delay timesteps supported for synapses in this population
-    unsigned int m_MaxDendriticDelayTimesteps;
+    std::optional<unsigned int> m_MaxDendriticDelayTimesteps;
 
     //! Kernel size 
     std::vector<unsigned int> m_KernelSize;
@@ -502,6 +509,10 @@ class GENN_EXPORT SynapseGroup
     //! Initialiser used for creating toeplitz connectivity
     InitToeplitzConnectivitySnippet::Init m_ToeplitzConnectivityInitialiser;
 
+    //! Set of names of postsynaptic weight update 
+    //! model variables which are heterogeneously delayed
+    std::set<std::string> m_HeterogeneouslyDelayedWUPostVars;
+
     //! Location of individual per-synapse state variables.
     /*! This is ignored for simulations on hardware with a single memory space */
     LocationContainer m_WUVarLocation;

include/genn/genn/synapseGroupInternal.h

@@ -58,7 +58,9 @@ class SynapseGroupInternal : public SynapseGroup
     using SynapseGroup::isPreSpikeFused;
     using SynapseGroup::isWUPreModelFused;
     using SynapseGroup::isWUPostModelFused;
-    using SynapseGroup::isDendriticDelayRequired;
+    using SynapseGroup::isDendriticOutputDelayRequired;
+    using SynapseGroup::isWUPostVarHeterogeneouslyDelayed;
+    using SynapseGroup::areAnyWUPostVarHeterogeneouslyDelayed;
     using SynapseGroup::isPresynapticOutputRequired; 
     using SynapseGroup::isPostsynapticOutputRequired;
     using SynapseGroup::isProceduralConnectivityRNGRequired;
@@ -247,7 +249,7 @@ class SynapseWUPostVarAdapter
 
     const SynapseGroup &getTarget() const{ return m_SG.getFusedWUPostTarget(); }
 
-    bool isVarDelayed(const std::string&) const{ return (m_SG.getBackPropDelaySteps() != 0); }
+    bool isVarDelayed(const std::string &name) const{ return (m_SG.getBackPropDelaySteps() != 0) || m_SG.isWUPostVarHeterogeneouslyDelayed(name); }
 
     VarAccessDim getVarDims(const Models::Base::Var &var) const{ return getVarAccessDim(var.access); }