Step 6 - Fused event generation and postsynaptic spike-like events

Jenkinsfile

@@ -199,7 +199,7 @@ for(b = 0; b < builderNodes.size(); b++) {
                     ${env.PYTHON} -m venv ${WORKSPACE}/venv
                     . ${WORKSPACE}/venv/bin/activate
                     pip install -U pip
-                    pip install numpy scipy pybind11 pytest flakey pytest-cov wheel flake8 bitarray
+                    pip install numpy scipy pybind11 pytest flaky pytest-cov wheel flake8 bitarray
                     """;
                 }
 
@@ -234,7 +234,7 @@ for(b = 0; b < builderNodes.size(); b++) {
                         // Run ML GeNN test suite
                         def commandsTest = """
                         . ${WORKSPACE}/venv/bin/activate
-                        pytest -v --cov ../../pygenn --cov-report=xml:${coveragePython} --junitxml test_results_feature.xml 1>> "${outputFilename}" 2>&1
+                        pytest -s -v --cov ../../pygenn --cov-report=xml:${coveragePython} --junitxml test_results_feature.xml 1>> "${outputFilename}" 2>&1
                         """;
                         def statusTests = sh script:commandsTest, returnStatus:true;
                         if (statusTests != 0) {

include/genn/backends/single_threaded_cpu/backend.h

@@ -223,8 +223,13 @@ class BACKEND_EXPORT Backend : public BackendBase
     //--------------------------------------------------------------------------
     void genPresynapticUpdate(EnvironmentExternalBase &env, PresynapticUpdateGroupMerged &sg, 
                               double dt, bool trueSpike) const;
+    void genPostsynapticUpdate(EnvironmentExternalBase &env, PostsynapticUpdateGroupMerged &sg, 
+                               double dt, bool trueSpike) const;
 
-    void genEmitSpike(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng, bool trueSpike, bool recordingEnabled) const;
+    void genPrevEventTimeUpdate(EnvironmentExternalBase &env, NeuronPrevSpikeTimeUpdateGroupMerged &ng,
+                                bool trueSpike) const;
+
+    void genEmitEvent(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng, bool trueSpike) const;
 
     //! Helper to generate code to copy reduced custom update group variables back to memory
     /*! Because reduction operations are unnecessary in unbatched single-threaded CPU models so there's no need to actually reduce */

include/genn/genn/code_generator/backendSIMT.h

@@ -460,13 +460,20 @@ class GENN_EXPORT BackendSIMT : public BackendBase
         }
     }
 
-    void genEmitSpike(EnvironmentExternalBase &env, const std::string &suffix, 
-                      bool spikeRequired, bool recordingEnabled) const;
-
-    void genRecordingSharedMemInit(CodeStream &os, const std::string &suffix) const;
+    void genRecordingSharedMemInit(CodeStream &os, const std::string &suffix, size_t numArrays) const;
 
     void genSynapseVariableRowInit(EnvironmentExternalBase &env, HandlerEnv handler) const;
 
+    void genPostsynapticUpdate(EnvironmentExternalBase &env, PostsynapticUpdateGroupMerged &sg, 
+                               double dt, unsigned int batchSize, bool trueSpike) const;
+
+    void genPrevEventTimeUpdate(EnvironmentExternalBase &env, NeuronPrevSpikeTimeUpdateGroupMerged &ng,
+                                unsigned int batchSize, bool trueSpike) const;
+    void genEmitEvent(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng,
+                      size_t index, bool trueSpike) const;
+    void genCopyEventToGlobal(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng,
+                              unsigned int batchSize, size_t index, bool trueSpike) const;
+
     // Get appropriate presynaptic update strategy to use for this synapse group
     const PresynapticUpdateStrategySIMT::Base *getPresynapticUpdateStrategy(const SynapseGroupInternal &sg) const
     {

include/genn/genn/code_generator/codeGenUtils.h

@@ -55,75 +55,28 @@ inline size_t padSize(size_t size, size_t blockSize)
 
 GENN_EXPORT void genTypeRange(CodeStream &os, const Type::ResolvedType &type, const std::string &prefix);
 
-//--------------------------------------------------------------------------
-/*! \brief This function uses the transpiler to parse, type check and pretty print previously scanned vector of tokens representing an expression
- */
- //--------------------------------------------------------------------------
+//! Parse, type check and pretty print previously scanned vector of tokens representing an expression
+GENN_EXPORT void prettyPrintExpression(const std::vector<Transpiler::Token> &tokens, const Type::TypeContext &typeContext, 
+                                       Transpiler::TypeChecker::EnvironmentInternal &typeCheckEnv, Transpiler::PrettyPrinter::EnvironmentInternal &prettyPrintEnv,
+                                       Transpiler::ErrorHandler &errorHandler);
+
+//! Parse, type check and pretty print previously scanned vector of tokens representing an expression
 GENN_EXPORT void prettyPrintExpression(const std::vector<Transpiler::Token> &tokens, const Type::TypeContext &typeContext, 
                                        EnvironmentExternalBase &env, Transpiler::ErrorHandler &errorHandler);
 
-//--------------------------------------------------------------------------
-/*! \brief This function uses the transpiler to parse, type check and pretty print previously scanned vector of tokens representing a statemebt
- */
- //--------------------------------------------------------------------------
+//! Parse, type check and pretty print previously scanned vector of tokens representing a statement
+GENN_EXPORT void prettyPrintStatements(const std::vector<Transpiler::Token> &tokens, const Type::TypeContext &typeContext,
+                                       Transpiler::TypeChecker::EnvironmentInternal &typeCheckEnv, Transpiler::PrettyPrinter::EnvironmentInternal &prettyPrintEnv,
+                                       Transpiler::ErrorHandler &errorHandler, Transpiler::TypeChecker::StatementHandler forEachSynapseTypeCheckHandler = nullptr,
+                                       Transpiler::PrettyPrinter::StatementHandler forEachSynapsePrettyPrintHandler = nullptr);
+
+//! Parse, type check and pretty print previously scanned vector of tokens representing a statement
 GENN_EXPORT void prettyPrintStatements(const std::vector<Transpiler::Token> &tokens, const Type::TypeContext &typeContext, EnvironmentExternalBase &env, 
                                        Transpiler::ErrorHandler &errorHandler, Transpiler::TypeChecker::StatementHandler forEachSynapseTypeCheckHandler = nullptr,
                                        Transpiler::PrettyPrinter::StatementHandler forEachSynapsePrettyPrintHandler = nullptr);
 
 GENN_EXPORT std::string printSubs(const std::string &format, Transpiler::PrettyPrinter::EnvironmentBase &env);
 
-//-------------------------------------------------------------------------
-/*!
-  \brief Function for performing the code and value substitutions necessary to insert neuron related variables, parameters, and extraGlobal parameters into synaptic code.
-*/
-//-------------------------------------------------------------------------
-/*template<typename P, typename D, typename V, typename S>
-void neuronSubstitutionsInSynapticCode(CodeGenerator::Substitutions &substitutions, const NeuronGroupInternal *archetypeNG, 
-                                       const std::string &delayOffset, const std::string &sourceSuffix, const std::string &destSuffix, 
-                                       const std::string &varPrefix, const std::string &varSuffix, bool useLocalNeuronVars,
-                                       P isParamHeterogeneousFn, D isDerivedParamHeterogeneousFn, V getVarIndexFn, S getPrevSpikeTimeIndexFn)
-{
-
-    // Substitute spike times
-    const bool delay = archetypeNG->isDelayRequired();
-    const std::string spikeTimeVarIndex = getVarIndexFn(delay, VarAccessDuplication::DUPLICATE);
-    const std::string prevSpikeTimeVarIndex = getPrevSpikeTimeIndexFn(delay, VarAccessDuplication::DUPLICATE);
-    substitutions.addVarSubstitution("sT" + sourceSuffix,
-                                     "(" + delayOffset + varPrefix + "group->sT" + destSuffix + "[" + spikeTimeVarIndex + "]" + varSuffix + ")");
-    substitutions.addVarSubstitution("prev_sT" + sourceSuffix,
-                                     "(" + delayOffset + varPrefix + "group->prevST" + destSuffix + "[" + prevSpikeTimeVarIndex + "]" + varSuffix + ")");
-
-    // Substitute spike-like-event times
-    substitutions.addVarSubstitution("seT" + sourceSuffix,
-                                     "(" + delayOffset + varPrefix + "group->seT" + destSuffix + "[" + spikeTimeVarIndex + "]" + varSuffix + ")");
-    substitutions.addVarSubstitution("prev_seT" + sourceSuffix,
-                                     "(" + delayOffset + varPrefix + "group->prevSET" + destSuffix + "[" + prevSpikeTimeVarIndex + "]" + varSuffix + ")");
-
-    // Substitute neuron variables
-    const auto *nm = archetypeNG->getNeuronModel();
-    if(useLocalNeuronVars) {
-        substitutions.addVarNameSubstitution(nm->getVars(), sourceSuffix, "l");
-    }
-    else {
-        for(const auto &v : nm->getVars()) {
-            const std::string varIdx = getVarIndexFn(delay && archetypeNG->isVarQueueRequired(v.name),
-                                                     getVarAccessDuplication(v.access));
-
-            substitutions.addVarSubstitution(v.name + sourceSuffix,
-                                             varPrefix + "group->" + v.name + destSuffix + "[" + varIdx + "]" + varSuffix);
-        }
-    }
-
-    // Substitute (potentially heterogeneous) parameters and derived parameters from neuron model
-    substitutions.addParamValueSubstitution(nm->getParamNames(), archetypeNG->getParams(), isParamHeterogeneousFn,
-                                            sourceSuffix, "group->", destSuffix);
-    substitutions.addVarValueSubstitution(nm->getDerivedParams(), archetypeNG->getDerivedParams(), isDerivedParamHeterogeneousFn,
-                                          sourceSuffix, "group->", destSuffix);
-
-    // Substitute extra global parameters from neuron model
-    substitutions.addVarNameSubstitution(nm->getExtraGlobalParams(), sourceSuffix, "group->", destSuffix);
-}*/
-
 template<typename G>
 bool isKernelSizeHeterogeneous(const G &group, size_t dimensionIndex)
 {

include/genn/genn/code_generator/environment.h

@@ -165,7 +165,7 @@ class EnvironmentFieldPolicy
     const G &getGroup() const{ return m_Group; }
 
 protected:
-    using Payload = std::tuple<bool, bool, LazyString, std::optional<typename G::Field>>;
+    using Payload = std::tuple<bool, LazyString, std::optional<typename G::Field>>;
 
     EnvironmentFieldPolicy(G &group, F &fieldGroup)
     :   m_Group(group), m_FieldGroup(fieldGroup)
@@ -180,15 +180,15 @@ class EnvironmentFieldPolicy
     std::string getNameInternal(const Payload &payload)
     {
         // If a field is specified
-        const auto str = std::get<2>(payload).str();
-        if(std::get<3>(payload)) {
+        const auto str = std::get<1>(payload).str();
+        if(std::get<2>(payload)) {
             // If there is no value specified, access field directly
             if(str.empty()) {
-                 return "group->" + std::get<3>(payload).value().name;
+                 return "group->" + std::get<2>(payload).value().name;
             }
             // Otherwise, treat value as index
             else {
-                return "group->" + std::get<3>(payload).value().name + "[" + str + "]"; 
+                return "group->" + std::get<2>(payload).value().name + "[" + str + "]"; 
             }
         }
         // Otherwise, use value directly
@@ -200,9 +200,9 @@ class EnvironmentFieldPolicy
     void setRequired(Payload &payload)
     {
         // If a field is specified but it hasn't already been added
-        if (std::get<3>(payload) && !std::get<0>(payload)) {
+        if (std::get<2>(payload) && !std::get<0>(payload)) {
             // Extract field from payload
-            const auto &field = std::get<3>(payload).value();
+            const auto &field = std::get<2>(payload).value();
             const auto &group = getGroup();
 
             // Add to field group using lambda function to potentially map from group to field
@@ -212,7 +212,7 @@ class EnvironmentFieldPolicy
                                         {
                                             return field.getValue(runtime, group.getGroups().at(i), i);
                                         },
-                                        field.fieldType, std::get<1>(payload));
+                                        field.fieldType);
 
             // Set flag so field doesn't get re-added
             std::get<0>(payload) = true;
@@ -432,26 +432,26 @@ class EnvironmentGroupMergedField : public EnvironmentExternalDynamicBase<Enviro
     void add(const GeNN::Type::ResolvedType &type, const std::string &name, const std::string &value,
              const std::vector<size_t> &initialisers = {})
     {
-        this->addInternal(type, name, std::make_tuple(false, false, LazyString{value, *this}, std::nullopt), initialisers);
+        this->addInternal(type, name, std::make_tuple(false, LazyString{value, *this}, std::nullopt), initialisers);
     }
 
     //! Map a type (for type-checking) and a group merged field to back it to an identifier
     void addField(const GeNN::Type::ResolvedType &type, const std::string &name,
                   const GeNN::Type::ResolvedType &fieldType, const std::string &fieldName, typename G::GetFieldValueFunc getFieldValue,
                   const std::string &indexSuffix = "", GroupMergedFieldType mergedFieldType = GroupMergedFieldType::STANDARD, 
-                  bool allowDuplicates = false, const std::vector<size_t> &initialisers = {})
+                  const std::vector<size_t> &initialisers = {})
     {
         typename G::Field field{fieldName, fieldType, mergedFieldType, getFieldValue};
-        this->addInternal(type, name, std::make_tuple(false, allowDuplicates, LazyString{indexSuffix, *this}, std::make_optional(field)),
+        this->addInternal(type, name, std::make_tuple(false, LazyString{indexSuffix, *this}, std::make_optional(field)),
                           initialisers);
     }
 
     //! Map a type (for type-checking) and a group merged field to back it to an identifier
     void addField(const GeNN::Type::ResolvedType &type, const std::string &name, const std::string &fieldName, 
                   typename G::GetFieldValueFunc getFieldValue, const std::string &indexSuffix = "", GroupMergedFieldType mergedFieldType = GroupMergedFieldType::STANDARD,
-                  bool allowDuplicates = false, const std::vector<size_t> &initialisers = {})
+                  const std::vector<size_t> &initialisers = {})
     {
-         addField(type, name, type, fieldName, getFieldValue, indexSuffix, mergedFieldType, allowDuplicates, initialisers);
+         addField(type, name, type, fieldName, getFieldValue, indexSuffix, mergedFieldType, initialisers);
     }
 
     void addParams(const Snippet::Base::ParamVec &params, const std::string &fieldSuffix, 
@@ -722,7 +722,7 @@ class EnvironmentGroupMergedField : public EnvironmentExternalDynamicBase<Enviro
     }
 
     template<typename A>
-    void addVarPointers(const std::string &fieldSuffix = "", bool hidden = false, bool allowDuplicates = false)
+    void addVarPointers(const std::string &fieldSuffix = "", bool hidden = false)
     {
         // Loop through variables and add private pointer field 
         const A archetypeAdaptor(this->getGroup().getArchetype());
@@ -733,8 +733,7 @@ class EnvironmentGroupMergedField : public EnvironmentExternalDynamicBase<Enviro
                      [v](auto &runtime, const auto &g, size_t) 
                      { 
                          return runtime.getArray(g, v.name);
-                     }, 
-                     "", GroupMergedFieldType::STANDARD, allowDuplicates);
+                     });
         }
     }
 
@@ -924,10 +923,10 @@ class EnvironmentLocalCacheBase : public EnvironmentExternalBase, public P
     template<typename... PolicyArgs>
     EnvironmentLocalCacheBase(G &group, F &fieldGroup, const Type::TypeContext &context, EnvironmentExternalBase &enclosing, 
                               const std::string &fieldSuffix, const std::string &localPrefix,
-                              bool hidden, bool allowDuplicates, PolicyArgs&&... policyArgs)
+                              bool hidden, PolicyArgs&&... policyArgs)
     :   EnvironmentExternalBase(enclosing), P(std::forward<PolicyArgs>(policyArgs)...), m_Group(group), 
         m_FieldGroup(fieldGroup),  m_Context(context), m_Contents(m_ContentsStream), 
-        m_FieldSuffix(fieldSuffix), m_LocalPrefix(localPrefix), m_AllowDuplicates(allowDuplicates)
+        m_FieldSuffix(fieldSuffix), m_LocalPrefix(localPrefix)
     {
         // Copy variables into variables referenced, alongside boolean
         const auto defs = A(m_Group.get().getArchetype()).getDefs();
@@ -961,8 +960,7 @@ class EnvironmentLocalCacheBase : public EnvironmentExternalBase, public P
                                         [v, &group, this](auto &runtime, const typename F::GroupInternal &, size_t i)
                                         {
                                             return this->getArray(runtime, group.getGroups().at(i), v);
-                                        },
-                                        GroupMergedFieldType::STANDARD, m_AllowDuplicates);
+                                        });
 
             if(getVarAccessMode(v.access) == VarAccessMode::READ_ONLY) {
                 getContextStream() << "const ";
@@ -1050,7 +1048,6 @@ class EnvironmentLocalCacheBase : public EnvironmentExternalBase, public P
     CodeStream m_Contents;
     std::string m_FieldSuffix;
     std::string m_LocalPrefix;
-    bool m_AllowDuplicates;
     std::unordered_map<std::string, std::pair<bool, AdapterDef>> m_VariablesReferenced;
 };
 

include/genn/genn/code_generator/groupMerged.h

@@ -362,24 +362,14 @@ class GroupMerged : public ChildGroupMerged<G>
     }
 
     void addField(const Type::ResolvedType &type, const std::string &name, typename ChildGroupMerged<G>::GetFieldValueFunc getFieldValue,
-                  GroupMergedFieldType fieldType = GroupMergedFieldType::STANDARD, bool allowDuplicate = false)
+                  GroupMergedFieldType fieldType = GroupMergedFieldType::STANDARD)
     {
         // Add field to data structure
         auto r = m_Fields.insert({name, type, fieldType, getFieldValue});
 
-        // If field wasn't successfully inserted
-        if(!r.second) {
-            // If duplicate fields are allowed
-            if(allowDuplicate) {
-                // If other properties of the field don't match
-                if(r.first->type != type || r.first->fieldType != fieldType) {
-                    throw std::runtime_error("Unable to add duplicate field '" + name + "' with different properties to merged group");
-                }
-            }
-            // Otherwise, give error
-            else {
-                throw std::runtime_error("Unable to add duplicate field '" + name + "' to merged group");
-            }
+        // If field wasn't successfully and inserted other properties of the field don't match
+        if(!r.second && (r.first->type != type || r.first->fieldType != fieldType)) {
+            throw std::runtime_error("Unable to add duplicate field '" + name + "' with different properties to merged group");
         }
      }
 
@@ -450,7 +440,7 @@ class GENN_EXPORT NeuronGroupMergedBase : public GroupMerged<NeuronGroupInternal
             // Loop through children and add them and their digests to vector
             childDigests.clear();
             for(auto *c : groupChildren) {
-                childDigests.emplace_back((c->*getHashDigestFunc)(), c);
+                childDigests.emplace_back(std::invoke(getHashDigestFunc, c, &g.get()), c);
             }
 
             // Sort by digest