Step 5 - Dynamic and typed parameters

include/genn/backends/cuda/backend.h

@@ -359,7 +359,7 @@ class BACKEND_EXPORT Backend : public BackendSIMT
                 os << "Merged" << T::name << "Group" << g.getIndex() << " group = {";
                 const auto sortedFields = g.getSortedFields(*this);
                 for(const auto &f : sortedFields) {
-                    os << std::get<1>(f) << ", ";
+                    os << f.name << ", ";
                 }
                 os << "};" << std::endl;
 

include/genn/genn/code_generator/backendBase.h

@@ -21,7 +21,7 @@
 #include "synapseMatrixType.h"
 #include "type.h"
 #include "varAccess.h"
-#include "variableMode.h"
+#include "varLocation.h"
 
 // GeNN code generator includes
 #include "code_generator/codeStream.h"

include/genn/genn/code_generator/codeGenUtils.h

@@ -13,7 +13,7 @@
 #include "gennUtils.h"
 #include "neuronGroupInternal.h"
 #include "type.h"
-#include "variableMode.h"
+#include "varLocation.h"
 
 // GeNN code generator includes
 #include "backendBase.h"

include/genn/genn/code_generator/groupMerged.h

@@ -3,6 +3,7 @@
 // Standard includes
 #include <algorithm>
 #include <functional>
+#include <set>
 #include <type_traits>
 #include <vector>
 
@@ -24,6 +25,7 @@ class CodeStream;
 namespace GeNN::Runtime
 {
 class ArrayBase;
+class MergedDynamicFieldDestinations;
 class Runtime;
 }
 
@@ -64,9 +66,27 @@ class ChildGroupMerged
     // Typedefines
     //------------------------------------------------------------------------
     typedef G GroupInternal;
-    typedef std::variant<Type::NumericValue, const Runtime::ArrayBase*> FieldValue;
-    typedef std::function<FieldValue(const Runtime::Runtime &, const G &, size_t)> GetFieldValueFunc;
-    typedef std::tuple<Type::ResolvedType, std::string, GetFieldValueFunc, GroupMergedFieldType> Field;
+    typedef std::variant<Type::NumericValue, const Runtime::ArrayBase*,
+                         std::pair<Type::NumericValue, Runtime::MergedDynamicFieldDestinations&>> FieldValue;
+    typedef std::function<FieldValue(Runtime::Runtime &, const G &, size_t)> GetFieldValueFunc;
+
+    //------------------------------------------------------------------------
+    // Field
+    //------------------------------------------------------------------------
+    struct Field
+    {
+        std::string name;
+        Type::ResolvedType type;
+        GroupMergedFieldType fieldType;
+        GetFieldValueFunc getValue;
+
+        //! Less than operator (used for std::set::insert), 
+        //! compares using only name
+        bool operator < (const Field &other) const
+        {
+            return (name < other.name);
+        }
+    };
 
     ChildGroupMerged(size_t index, const Type::TypeContext &typeContext, const std::vector<std::reference_wrapper<const GroupInternal>> groups)
     :   m_Index(index), m_TypeContext(typeContext), m_Groups(std::move(groups))
@@ -101,7 +121,7 @@ class ChildGroupMerged
     bool isParamValueHeterogeneous(const std::string &name, P getParamValuesFn) const
     {
         // Get value of parameter in archetype group
-        const double archetypeValue = getParamValuesFn(getArchetype()).at(name);
+        const auto archetypeValue = getParamValuesFn(getArchetype()).at(name);
 
         // Return true if any parameter values differ from the archetype value
         return std::any_of(getGroups().cbegin(), getGroups().cend(),
@@ -129,7 +149,7 @@ class ChildGroupMerged
             // Loop through groups
             for(const auto &g : getGroups()) {
                 // Update hash with parameter value
-                Utils::updateHash(getValueFn(g.get()).at(p.first), hash);
+                Type::updateHash(getValueFn(g.get()).at(p.first), hash);
             }
         }
     }
@@ -147,7 +167,7 @@ class ChildGroupMerged
                     const auto &values = A(g.get()).getInitialisers().at(varInit.first).getParams();
 
                     // Update hash with parameter value
-                    Utils::updateHash(values.at(p.first), hash);
+                    Type::updateHash(values.at(p.first), hash);
                 }
             }
         }
@@ -166,7 +186,7 @@ class ChildGroupMerged
                     const auto &values = A(g.get()).getInitialisers().at(varInit.first).getDerivedParams();
 
                     // Update hash with parameter value
-                    Utils::updateHash(values.at(d.first), hash);
+                    Type::updateHash(values.at(d.first), hash);
                 }
             }
         }
@@ -203,19 +223,19 @@ class GroupMerged : public ChildGroupMerged<G>
     const std::string &getMemorySpace() const { return m_MemorySpace; }
 
     //! Get group fields
-    const std::vector<typename ChildGroupMerged<G>::Field> &getFields() const{ return m_Fields; }
+    const std::set<typename ChildGroupMerged<G>::Field> &getFields() const{ return m_Fields; }
 
     //! Get group fields, sorted into order they will appear in struct
     std::vector<typename ChildGroupMerged<G>::Field> getSortedFields(const BackendBase &backend) const
     {
-        // Make a copy of fields and sort so largest come first. This should mean that due
+        // Copy fields into vectorand sort so largest come first. This should mean that due
         // to structure packing rules, significant memory is saved and estimate is more precise
-        auto sortedFields = m_Fields;
+        std::vector<typename ChildGroupMerged<G>::Field> sortedFields(m_Fields.cbegin(), m_Fields.cend());
         const size_t pointerBytes = backend.getPointerBytes();
         std::sort(sortedFields.begin(), sortedFields.end(),
                   [pointerBytes](const auto &a, const auto &b)
                   {
-                      return (std::get<0>(a).getSize(pointerBytes) > std::get<0>(b).getSize(pointerBytes));
+                      return (a.type.getSize(pointerBytes) > b.type.getSize(pointerBytes));
                   });
         return sortedFields;
 
@@ -232,22 +252,21 @@ class GroupMerged : public ChildGroupMerged<G>
             for(const auto &f : sortedFields) {
                 // If field is a pointer and not marked as being a host field 
                 // (in which case the backend should leave its type alone!)
-                const auto &type = std::get<0>(f);
-                if(type.isPointer() && !(std::get<3>(f) & GroupMergedFieldType::HOST)) {
+                if(f.type.isPointer() && !(f.fieldType & GroupMergedFieldType::HOST)) {
                     // If we are generating a host structure, allow the backend to override the type
                     if(host) {
-                        os << backend.getMergedGroupFieldHostTypeName(type);
+                        os << backend.getMergedGroupFieldHostTypeName(f.type);
                     }
                     // Otherwise, allow the backend to add a prefix 
                     else {
-                        os << backend.getPointerPrefix() << type.getName();
+                        os << backend.getPointerPrefix() << f.type.getName();
                     }
                 }
                 // Otherwise, leave the type alone
                 else {
-                    os << type.getName();
+                    os << f.type.getName();
                 }
-                os << " " << std::get<1>(f) << ";" << std::endl;
+                os << " " << f.name << ";" << std::endl;
             }
             os << std::endl;
         }
@@ -261,7 +280,7 @@ class GroupMerged : public ChildGroupMerged<G>
         const auto sortedFields = getSortedFields(backend);
         for(size_t fieldIndex = 0; fieldIndex < sortedFields.size(); fieldIndex++) {
             const auto &f = sortedFields[fieldIndex];
-            os << backend.getMergedGroupFieldHostTypeName(std::get<0>(f)) << " " << std::get<1>(f);
+            os << backend.getMergedGroupFieldHostTypeName(f.type) << " " << f.name;
             if(fieldIndex != (sortedFields.size() - 1)) {
                 os << ", ";
             }
@@ -283,7 +302,7 @@ class GroupMerged : public ChildGroupMerged<G>
             // Loop through sorted fields and set array entry
             const auto sortedFields = getSortedFields(backend);
             for(const auto &f : sortedFields) {
-                os << "merged" << name << "Group" << this->getIndex() << "[idx]." << std::get<1>(f) << " = " << std::get<1>(f) << ";" << std::endl;
+                os << "merged" << name << "Group" << this->getIndex() << "[idx]." << f.name << " = " << f.name << ";" << std::endl;
             }
         }
     }
@@ -297,7 +316,7 @@ class GroupMerged : public ChildGroupMerged<G>
         const auto sortedFields = getSortedFields(backend);
         for(const auto &f : sortedFields) {
             // Add size of field to total
-            const size_t fieldSize = std::get<0>(f).getSize(backend.getPointerBytes());
+            const size_t fieldSize = f.type.getSize(backend.getPointerBytes());
             structSize += fieldSize;
 
             // Update largest field size
@@ -343,11 +362,26 @@ class GroupMerged : public ChildGroupMerged<G>
     }
 
     void addField(const Type::ResolvedType &type, const std::string &name, typename ChildGroupMerged<G>::GetFieldValueFunc getFieldValue,
-                  GroupMergedFieldType fieldType = GroupMergedFieldType::STANDARD)
+                  GroupMergedFieldType fieldType = GroupMergedFieldType::STANDARD, bool allowDuplicate = false)
     {
-        // Add field to data structurChildGroupMergede
-        m_Fields.emplace_back(type, name, getFieldValue, fieldType);
-    }
+        // 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");
+            }
+        }
+     }
 
 protected:
     //------------------------------------------------------------------------
@@ -362,14 +396,14 @@ class GroupMerged : public ChildGroupMerged<G>
 
         // Loop through fields again to generate any dynamic field pushing functions that are required
         for(const auto &f : m_Fields) {
-            if((std::get<3>(f) & GroupMergedFieldType::DYNAMIC)) {
-                definitions << "EXPORT_FUNC void pushMerged" << name << this->getIndex() << std::get<1>(f) << "ToDevice(unsigned int idx, ";
-                definitions << backend.getMergedGroupFieldHostTypeName(std::get<0>(f)) << " value);" << std::endl;
+            if((f.fieldType & GroupMergedFieldType::DYNAMIC)) {
+                definitions << "EXPORT_FUNC void pushMerged" << name << this->getIndex() << f.name << "ToDevice(unsigned int idx, ";
+                definitions << backend.getMergedGroupFieldHostTypeName(f.type) << " value);" << std::endl;
             }
 
             // If field is a pointer, assert that this is a host structure if field is a host or host object field
-            if(std::get<0>(f).isPointer()) {
-                assert((!(std::get<3>(f) & GroupMergedFieldType::HOST) && !(std::get<3>(f) & GroupMergedFieldType::HOST_OBJECT)) || host);
+            if(f.type.isPointer()) {
+                assert((!(f.fieldType & GroupMergedFieldType::HOST) && !(f.fieldType & GroupMergedFieldType::HOST_OBJECT)) || host);
             }
         }
     }
@@ -379,7 +413,7 @@ class GroupMerged : public ChildGroupMerged<G>
     // Members
     //------------------------------------------------------------------------
     std::string m_MemorySpace;
-    std::vector<typename ChildGroupMerged<G>::Field> m_Fields;
+    std::set<typename ChildGroupMerged<G>::Field> m_Fields;
 };
 
 //----------------------------------------------------------------------------

include/genn/genn/code_generator/modelSpecMerged.h

@@ -276,19 +276,18 @@ class GENN_EXPORT ModelSpecMerged
             const auto &mergedGroup = groups[g];
             for(const auto &f : mergedGroup.getFields()) {
                 // If field is dynamic, add record to merged EGPS
-                if((std::get<3>(f) & GroupMergedFieldType::DYNAMIC)) {
+                if((f.fieldType & GroupMergedFieldType::DYNAMIC)) {
                     // Add reference to this group's variable to data structure
                     // **NOTE** this works fine with EGP references because the function to
                     // get their value will just return the name of the referenced EGP
-                    assert(std::get<0>(f).isPointer());
-                    os << "void pushMerged" << T::name << g << std::get<1>(f) << "ToDevice(unsigned int idx, " << backend.getMergedGroupFieldHostTypeName(std::get<0>(f)) << " value)";
+                    os << "void pushMerged" << T::name << g << f.name << "ToDevice(unsigned int idx, " << backend.getMergedGroupFieldHostTypeName(f.type) << " value)";
                     {
                         CodeStream::Scope b(os);
                         if(host) {
-                            os << "merged" << T::name << "Group" << g << "[idx]." << std::get<1>(f) << " = value;" << std::endl;
+                            os << "merged" << T::name << "Group" << g << "[idx]." << f.name << " = value;" << std::endl;
                         }
                         else {
-                            backend.genMergedDynamicVariablePush(os, T::name, g, "idx", std::get<1>(f), "value");
+                            backend.genMergedDynamicVariablePush(os, T::name, g, "idx", f.name, "value");
                         }
                     }
                 }

include/genn/genn/code_generator/neuronUpdateGroupMerged.h

@@ -34,13 +34,6 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
 
         //! Should the current source derived parameter be implemented heterogeneously?
         bool isDerivedParamHeterogeneous(const std::string &paramName) const;
-
-    private:
-        //----------------------------------------------------------------------------
-        // Private API
-        //----------------------------------------------------------------------------
-        //! Is the parameter referenced? **YUCK** only used for hashing
-        bool isParamReferenced(const std::string &paramName) const;
     };
 
     //----------------------------------------------------------------------------
@@ -66,13 +59,6 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
 
         //! Should the current source derived parameter be implemented heterogeneously?
         bool isDerivedParamHeterogeneous(const std::string &paramName) const;
-
-    private:
-        //----------------------------------------------------------------------------
-        // Private API
-        //----------------------------------------------------------------------------
-        //! Is the parameter referenced? **YUCK** only used for hashing
-        bool isParamReferenced(const std::string &paramName) const;
     };
 
     //----------------------------------------------------------------------------
@@ -106,7 +92,7 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
         void generate(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng,
                       unsigned int batchSize, bool dynamicsNotSpike);
 
-        void genCopyDelayedVars(EnvironmentExternalBase &env, const NeuronUpdateGroupMerged &ng,
+        void genCopyDelayedVars(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng, 
                                 unsigned int batchSize);
 
         //! Update hash with child groups
@@ -117,13 +103,6 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
 
         //! Should the current source derived parameter be implemented heterogeneously?
         bool isDerivedParamHeterogeneous(const std::string &paramName) const;
-
-    private:
-        //----------------------------------------------------------------------------
-        // Private API
-        //----------------------------------------------------------------------------
-        //! Is the parameter referenced? **YUCK** only used for hashing
-        bool isParamReferenced(const std::string &paramName) const;
     };
 
     //----------------------------------------------------------------------------
@@ -141,7 +120,7 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
         void generate(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng,
                       unsigned int batchSize, bool dynamicsNotSpike);
 
-        void genCopyDelayedVars(EnvironmentExternalBase &env, const NeuronUpdateGroupMerged &ng,
+        void genCopyDelayedVars(EnvironmentExternalBase &env, NeuronUpdateGroupMerged &ng,
                                 unsigned int batchSize);
 
         //! Update hash with child groups
@@ -152,13 +131,6 @@ class GENN_EXPORT NeuronUpdateGroupMerged : public NeuronGroupMergedBase
 
         //! Should the current source derived parameter be implemented heterogeneously?
         bool isDerivedParamHeterogeneous(const std::string &paramName) const;
-
-    private:
-        //----------------------------------------------------------------------------
-        // Private API
-        //----------------------------------------------------------------------------
-        //! Is the parameter referenced? **YUCK** only used for hashing
-        bool isParamReferenced(const std::string &paramName) const;
     };
 
     NeuronUpdateGroupMerged(size_t index, const Type::TypeContext &typeContext,