Clean up serialization mapper to use much less code (sstsimulator#1501)

Author: leekillough

src/sst/core/Makefile.am

@@ -231,7 +231,6 @@ sst_core_sources = \
 	serialization/impl/unpacker.cc \
 	serialization/impl/ser_shared_ptr_tracker.cc \
 	serialization/statics.cc \
-	serialization/impl/mapper.cc \
 	serialization/impl/serialize_array.cc \
 	serialization/impl/serialize_trivial.cc \
 	serialization/impl/serialize_shared_ptr.cc \

src/sst/core/serialization/impl/mapper.cc

@@ -17,42 +17,56 @@
     "The header file sst/core/serialization/impl/mapper.h should not be directly included as it is not part of the stable public API.  The file is included in sst/core/serialization/serializer.h"
 #endif
 
+#include "sst/core/serialization/objectMap.h"
+
 #include <cstdint>
-#include <map>
+#include <deque>
 #include <string>
-#include <vector>
-
-namespace SST::Core::Serialization {
-
-class ObjectMap;
+#include <unordered_map>
 
-namespace pvt {
+namespace SST::Core::Serialization::pvt {
 
 class ser_mapper
 {
-    std::map<uintptr_t, uintptr_t> pointer_map;
-    std::vector<ObjectMap*>        obj_;
-    bool                           next_item_read_only = false;
-    int                            indent              = 0;
+    std::unordered_map<uintptr_t, uintptr_t> pointer_map_;
+    std::deque<ObjectMap*>                   obj_;
 
 public:
-    ser_mapper() = default;
-
     explicit ser_mapper(ObjectMap* object) :
         obj_ { object }
     {}
 
-    void       map_primitive(const std::string& name, ObjectMap* map);
-    void       map_container(const std::string& name, ObjectMap* map);
-    void       map_existing_object(const std::string& name, ObjectMap* map);
-    void       map_hierarchy_start(const std::string& name, ObjectMap* map);
-    void       map_hierarchy_end();
-    void       setNextObjectReadOnly() { next_item_read_only = true; }
-    void       report_object_map(ObjectMap* ptr);
-    ObjectMap* check_pointer_map(uintptr_t ptr);
-};
-
-} // namespace pvt
-} // namespace SST::Core::Serialization
+    void map_primitive(const std::string& name, ObjectMap* map) { obj_.back()->addVariable(name, map); }
+
+    void map_container(const std::string& name, ObjectMap* map) { obj_.back()->addVariable(name, map); }
+
+    void map_existing_object(const std::string& name, ObjectMap* map)
+    {
+        map->incRefCount();
+        obj_.back()->addVariable(name, map);
+    }
+
+    void map_hierarchy_start(const std::string& name, ObjectMap* map)
+    {
+        obj_.back()->addVariable(name, map);
+        obj_.push_back(map);
+    }
+
+    void map_hierarchy_end() { obj_.pop_back(); }
+
+    void report_object_map(ObjectMap* ptr)
+    {
+        pointer_map_.insert_or_assign(reinterpret_cast<uintptr_t>(ptr->getAddr()), reinterpret_cast<uintptr_t>(ptr));
+    }
+
+    ObjectMap* check_pointer_map(uintptr_t ptr)
+    {
+        auto it = pointer_map_.find(ptr);
+        return it != pointer_map_.end() ? reinterpret_cast<ObjectMap*>(it->second) : nullptr;
+    }
+
+}; // class ser_wrapper
+
+} // namespace SST::Core::Serialization::pvt
 
 #endif // SST_CORE_SERIALIZATION_IMPL_MAPPER_H

src/sst/core/serialization/impl/mapper.h

@@ -74,10 +74,9 @@ class serialize_impl<T, std::enable_if_t<std::is_same_v<std::remove_pointer_t<T>
         const auto& sPtr = get_ptr(str);
         const auto  mode = ser.mode();
         if ( mode == serializer::MAP ) {
-            if ( options & SerOption::map_read_only ) {
-                ser.mapper().setNextObjectReadOnly();
-            }
-            ser.mapper().map_primitive(ser.getMapName(), new ObjectMapString(sPtr));
+            ObjectMap* obj_map = new ObjectMapString(sPtr);
+            if ( SerOption::is_set(options, SerOption::map_read_only) ) obj_map->setReadOnly();
+            ser.mapper().map_primitive(ser.getMapName(), obj_map);
         }
         else {
             if constexpr ( std::is_pointer_v<T> ) {

src/sst/core/serialization/impl/serialize_string.h

@@ -64,7 +64,7 @@ class serialize_impl<T,
                     obj_map = new ObjectMapFundamental<std::remove_pointer_t<T>>(t);
                 else
                     obj_map = new ObjectMapFundamental<T>(&t);
-                if ( SerOption::is_set(options, SerOption::map_read_only) ) ser.mapper().setNextObjectReadOnly();
+                if ( SerOption::is_set(options, SerOption::map_read_only) ) obj_map->setReadOnly();
                 ser.mapper().map_primitive(ser.getMapName(), obj_map);
             }
             else {

src/sst/core/serialization/impl/serialize_trivial.h

@@ -279,9 +279,7 @@ serialize_impl<TimeConverter>::operator()(TimeConverter& s, serializer& ser, ser
     case serializer::MAP:
     {
         ObjectMap* obj_map = new ObjectMapFundamental<TimeConverter>(&s);
-        if ( options & SerOption::map_read_only ) {
-            ser.mapper().setNextObjectReadOnly();
-        }
+        if ( SerOption::is_set(options, SerOption::map_read_only) ) obj_map->setReadOnly();
         ser.mapper().map_primitive(ser.getMapName(), obj_map);
         break;
     }
@@ -322,9 +320,7 @@ serialize_impl<TimeConverter*>::operator()(TimeConverter*& s, serializer& ser, s
     case serializer::MAP:
     {
         ObjectMap* obj_map = new ObjectMapFundamental<TimeConverter*>(&s);
-        if ( options & SerOption::map_read_only ) {
-            ser.mapper().setNextObjectReadOnly();
-        }
+        if ( SerOption::is_set(options, SerOption::map_read_only) ) obj_map->setReadOnly();
         ser.mapper().map_primitive(ser.getMapName(), obj_map);
         break;
     }

src/sst/core/timeLord.cc

@@ -451,9 +451,7 @@ class serialize_impl<UnitAlgebra>
         case serializer::MAP:
         {
             ObjectMap* obj_map = new ObjectMapFundamental<UnitAlgebra>(&ua);
-            if ( options & SerOption::map_read_only ) {
-                ser.mapper().setNextObjectReadOnly();
-            }
+            if ( SerOption::is_set(options, SerOption::map_read_only) ) obj_map->setReadOnly();
             ser.mapper().map_primitive(ser.getMapName(), obj_map);
             break;
         }