Support ObjectMap for std::bitset<N>, std::vector<bool> and std::atomic<T> (#1483)

Author: leekillough

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

@@ -26,32 +26,52 @@ namespace SST::Core::Serialization {
 template <class T>
 class serialize_impl<std::atomic<T>>
 {
+    // Proxy class which represents a reference to std::atomic<T>, is copyable, convertible to T, and assignable from T
+    //
+    // This is only used in mapping mode
+    class atomic_reference
+    {
+        std::atomic<T>& ref;
+
+    public:
+        explicit atomic_reference(std::atomic<T>& ref) :
+            ref(ref)
+        {}
+
+        // Set the referenced atomic to a value
+        atomic_reference& operator=(const T& value)
+        {
+            ref.store(value);
+            return *this;
+        }
+
+        // Convert the referenced atomic to its value
+        operator T() const { return ref.load(); }
+    };
+
     void operator()(std::atomic<T>& v, serializer& ser, ser_opt_t UNUSED(options))
     {
         switch ( ser.mode() ) {
         case serializer::SIZER:
-        {
-            T t = v.load();
-            SST_SER(t);
-            // ser.size(t);
-            break;
-        }
         case serializer::PACK:
         {
-            T t = v.load();
-            SST_SER(t);
+            T value { v.load() };
+            SST_SER(value);
             break;
         }
         case serializer::UNPACK:
         {
-            T val {};
-            SST_SER(val);
-            v.store(val);
+            T value {};
+            SST_SER(value);
+            v.store(value);
             break;
         }
         case serializer::MAP:
         {
-            // TODO: Add support for mapping mode
+            // Create an ObjectMapFundamentalReference referring to a atomic_reference proxy wrapper class
+            ser.mapper().map_hierarchy_start(ser.getMapName(),
+                new ObjectMapFundamentalReference<T, atomic_reference, std::atomic<T>>(atomic_reference(v)));
+            ser.mapper().map_hierarchy_end();
             break;
         }
         }

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

@@ -21,45 +21,62 @@
 
 #include <bitset>
 #include <cstddef>
-#include <type_traits>
 
 namespace SST::Core::Serialization {
 
-// Serialize std::bitset
+// Serialize std::bitset<N>
 template <size_t N>
 class serialize_impl<std::bitset<N>>
 {
-    using T = std::bitset<N>;
-    void operator()(T& t, serializer& ser, ser_opt_t UNUSED(options))
+    void operator()(std::bitset<N>& t, serializer& ser, ser_opt_t UNUSED(options))
     {
         switch ( ser.mode() ) {
         case serializer::MAP:
         {
-            // TODO: Should this be mapped as an array? It will have the same problems as std::vector<bool>
+            ser.mapper().map_hierarchy_start(ser.getMapName(), new ObjectMapContainer<std::bitset<N>>(&t));
+
+            // Serialize reference wrappers to each bit
+            for ( size_t i = 0; i < N; ++i )
+                SST_SER_NAME(pvt::bit_reference_wrapper<std::bitset<N>>(t[i]), std::to_string(i).c_str());
+
+            ser.mapper().map_hierarchy_end();
             break;
         }
 
         default:
-            static_assert(std::is_trivially_copyable_v<T> && std::is_standard_layout_v<T>);
             ser.primitive(t);
             break;
         }
     }
     SST_FRIEND_SERIALIZE();
 };
 
+// Serialize std::bitset<N>*
 template <size_t N>
 class serialize_impl<std::bitset<N>*>
 {
-    using T = std::bitset<N>;
-    void operator()(T*& t, serializer& ser, ser_opt_t UNUSED(options))
+    void operator()(std::bitset<N>*& t, serializer& ser, ser_opt_t UNUSED(options))
     {
-        if ( ser.mode() == serializer::UNPACK ) t = new T {};
+        if ( ser.mode() == serializer::UNPACK ) t = new std::bitset<N>;
         SST_SER(*t);
     }
     SST_FRIEND_SERIALIZE();
 };
 
+// Serialize a std::bitset<N> bit using the pvt::bit_reference_wrapper<std::bitset<N>>
+// This is only used in mapping mode
+template <size_t N>
+class serialize_impl<pvt::bit_reference_wrapper<std::bitset<N>>>
+{
+    void operator()(pvt::bit_reference_wrapper<std::bitset<N>>& t, serializer& ser, ser_opt_t UNUSED(options))
+    {
+        ser.mapper().map_hierarchy_start(
+            ser.getMapName(), new ObjectMapFundamentalReference<bool, typename std::bitset<N>::reference>(t.ref));
+        ser.mapper().map_hierarchy_end();
+    }
+    SST_FRIEND_SERIALIZE();
+};
+
 } // namespace SST::Core::Serialization
 
 #endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_BITSET_H

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

@@ -228,18 +228,18 @@ class serialize_impl<OBJ, std::enable_if_t<is_insertable_v<OBJ>>>
 
         case serializer::MAP:
         {
-            using SST::Core::to_string;
             const std::string& name = ser.getMapName();
             ser.mapper().map_hierarchy_start(name, new ObjectMapContainer<OBJ>(&obj));
 
             if constexpr ( is_vector_bool_v<OBJ> ) {
                 // std::vector<bool>
-                size_t i = 0;
-                for ( bool e : obj )
-                    SST_SER_NAME(e, to_string(i++).c_str());
+                // Serialize reference wrappers to each bit.
+                for ( size_t i = 0; i < obj.size(); ++i )
+                    SST_SER_NAME(pvt::bit_reference_wrapper<OBJ>(obj[i]), std::to_string(i).c_str());
             }
             else if constexpr ( is_simple_map_v<OBJ> ) {
                 // non-multi maps with a simple key
+                using SST::Core::to_string;
                 for ( auto& [key, value] : obj )
                     SST_SER_NAME(value, to_string(key).c_str());
             }
@@ -251,7 +251,7 @@ class serialize_impl<OBJ, std::enable_if_t<is_insertable_v<OBJ>>>
                 size_t i = 0;
                 for ( auto& e : obj )
                     SST_SER_NAME(
-                        const_cast<value_type&>(reinterpret_cast<const value_type&>(e)), to_string(i++).c_str());
+                        const_cast<value_type&>(reinterpret_cast<const value_type&>(e)), std::to_string(i++).c_str());
             }
             ser.mapper().map_hierarchy_end();
             break;
@@ -274,6 +274,21 @@ class serialize_impl<OBJ*, std::enable_if_t<is_insertable_v<OBJ>>>
     SST_FRIEND_SERIALIZE();
 };
 
+// Serialize a std::vector<bool> bit using the pvt::bit_reference_wrapper<std::vector<bool>>
+// This is only used in mapping mode
+template <typename ALLOC>
+class serialize_impl<pvt::bit_reference_wrapper<std::vector<bool, ALLOC>>>
+{
+    void operator()(pvt::bit_reference_wrapper<std::vector<bool, ALLOC>>& t, serializer& ser, ser_opt_t UNUSED(options))
+    {
+        ser.mapper().map_hierarchy_start(ser.getMapName(),
+            new ObjectMapFundamentalReference<bool, typename std::vector<bool, ALLOC>::reference>(t.ref));
+        ser.mapper().map_hierarchy_end();
+    }
+    SST_FRIEND_SERIALIZE();
+};
+
+
 } // namespace SST::Core::Serialization
 
 #endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_INSERTABLE_H