Add ObjectMultimapCmp functor to sort ObjectMap entries numerically when possible

Author: leekillough

src/sst/core/serialization/objectMap.cc

@@ -19,9 +19,6 @@
 
 namespace SST::Core::Serialization {
 
-// Static variable instantiation
-const std::multimap<std::string, ObjectMap*> ObjectMap::emptyVars;
-
 std::string
 ObjectMap::getName()
 {

src/sst/core/serialization/objectMap.h

@@ -15,13 +15,20 @@
 #include "sst/core/from_string.h"
 #include "sst/core/warnmacros.h"
 
+#include <bitset>
 #include <cassert>
+#include <cerrno>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
+#include <cstdlib>
+#include <exception>
+#include <functional>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <ostream>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
@@ -32,12 +39,31 @@
 
 namespace SST::Core::Serialization {
 
+// Comparison of two keys: If both keys are integers, use numeric comparison, else lexicographic
+struct ObjectMultimapCmp
+{
+    bool operator()(const std::string& a, const std::string& b) const
+    {
+        errno = 0;
+        char*     ea;
+        long long na = strtoll(a.c_str(), &ea, 10);
+        // *ea and *eb are 0 after strtol() if there are no invalid characters for integers left in the string
+        // errno is nonzero if either value is out of range; we fall back on string comparison then
+        if ( !*ea && !errno ) {
+            char*     eb;
+            long long nb = strtoll(b.c_str(), &eb, 10);
+            if ( !*eb && !errno ) return na < nb;
+        }
+        return std::less<>()(a, b);
+    }
+};
+
 class ObjectMap;
 class TraceBuffer;
 class ObjectBuffer;
 
+using ObjectMultimap = std::multimap<std::string, ObjectMap*, ObjectMultimapCmp>;
 
-// class ObjectMapComparison_impl<T>;
 /**
    Metadata object that each ObjectMap has a pointer to in order to
    track the hierarchy information while traversing the data
@@ -158,14 +184,6 @@ class ObjectMapComparison
 class ObjectMap
 {
 protected:
-    /**
-       Static empty variable map for use by versions that don't have
-       variables (i.e. are fundamentals or classes treated as
-       fundamentals.  This is needed because getVariables() returns a
-       reference to the map.
-    */
-    static const std::multimap<std::string, ObjectMap*> emptyVars;
-
     /**
        Metadata object for walking the object hierarchy.  When this
        object is selected by a parent object, a metadata object will
@@ -184,7 +202,6 @@ class ObjectMap
      */
     ObjectMapMetaData* mdata_ = nullptr;
 
-
     /**
        Indicates whether or not the variable is read-only
      */
@@ -218,7 +235,7 @@ class ObjectMap
        longer needed and the object will delete itself if refCount_
        reaches 0.
      */
-    int32_t refCount_ = 1;
+    size_t refCount_ = 1;
 
 public:
     /**
@@ -297,7 +314,17 @@ class ObjectMap
        ObjectMap's child variables. Fundamental types will return the
        same empty map.
      */
-    virtual const std::multimap<std::string, ObjectMap*>& getVariables() { return emptyVars; }
+    virtual const ObjectMultimap& getVariables()
+    {
+        /**
+           Static empty variable map for use by versions that don't have
+           variables (i.e. are fundamentals or classes treated as
+           fundamentals.  This is needed because getVariables() returns a
+           reference to the map.
+        */
+        static ObjectMultimap emptyVars;
+        return emptyVars;
+    }
 
     /**
        Increment the reference counter for this ObjectMap. When
@@ -577,7 +604,7 @@ class ObjectMapWithChildren : public ObjectMap
     /**
        Map that child ObjectMaps are stored in
      */
-    std::multimap<std::string, ObjectMap*> variables_;
+    ObjectMultimap variables_;
 
     /**
        Default constructor
@@ -623,8 +650,8 @@ class ObjectMapWithChildren : public ObjectMap
        child variables. pair.first is the name of the variable in the
        context of this object. pair.second is a pointer to the ObjectMap.
      */
-    const std::multimap<std::string, ObjectMap*>& getVariables() override { return variables_; }
-};
+    const ObjectMultimap& getVariables() override { return variables_; }
+}; // class ObjectMapWithChildren
 
 /**
    ObjectMap object to create a level of hierarchy that doesn't

src/sst/core/serialization/objectMapDeferred.h

@@ -52,7 +52,7 @@ class ObjectMapDeferred : public ObjectMap
        ObjectMap's child variables. pair.first is the name of the
        variable in the context of this object.
      */
-    const std::multimap<std::string, ObjectMap*>& getVariables() override { return obj_->getVariables(); }
+    const ObjectMultimap& getVariables() override { return obj_->getVariables(); }
 
     /**
        For the Deferred Build, the only variable that gets added will