Merge remote-tracking branch 'sstcore/devel' into override

Author: leekillough

configure.ac

@@ -62,7 +62,7 @@ esac
 
 SST_CHECK_PICKY
 AS_IF([test "x$use_picky" = "xyes"],
-      [WARNFLAGS="-Wall -Wextra -Wnon-virtual-dtor -Wsuggest-override"],
+      [WARNFLAGS="-Wall -Wextra -Wvla -Wnon-virtual-dtor -Wsuggest-override"],
       [WARNFLAGS=""])
 CFLAGS="$CFLAGS $WARNFLAGS"
 CXXFLAGS="$CXXFLAGS $WARNFLAGS"

src/sst/core/activity.h

@@ -213,9 +213,9 @@ class Activity : public SST::Core::MemPoolItem
     // inherit from it need to be serializable.
     void serialize_order(SST::Core::Serialization::serializer& ser) override
     {
-        ser& delivery_time;
-        ser& priority_order;
-        ser& queue_order;
+        SST_SER(delivery_time);
+        SST_SER(priority_order);
+        SST_SER(queue_order);
     }
 
     ImplementVirtualSerializable(SST::Activity);

src/sst/core/baseComponent.cc

@@ -887,8 +887,8 @@ BaseComponent::initiateInteractive(const std::string& msg)
 void
 BaseComponent::serialize_order(SST::Core::Serialization::serializer& ser)
 {
-    ser& my_info;
-    ser& isExtension;
+    SST_SER(my_info);
+    SST_SER(isExtension);
 
     switch ( ser.mode() ) {
     case SST::Core::Serialization::serializer::SIZER:
@@ -897,12 +897,12 @@ BaseComponent::serialize_order(SST::Core::Serialization::serializer& ser)
         // Need to serialize each handler
         std::pair<Clock::HandlerBase*, SimTime_t> p;
         size_t                                    num_handlers = clock_handlers.size();
-        ser&                                      num_handlers;
+        SST_SER(num_handlers);
         for ( auto* handler : clock_handlers ) {
             p.first  = handler;
             // See if it's currently registered with a clock
             p.second = sim_->getClockForHandler(handler);
-            ser& p;
+            SST_SER(p);
         }
         break;
     }
@@ -911,9 +911,9 @@ BaseComponent::serialize_order(SST::Core::Serialization::serializer& ser)
         sim_ = Simulation_impl::getSimulation();
         std::pair<Clock::HandlerBase*, SimTime_t> p;
         size_t                                    num_handlers;
-        ser&                                      num_handlers;
+        SST_SER(num_handlers);
         for ( size_t i = 0; i < num_handlers; ++i ) {
-            ser& p;
+            SST_SER(p);
             // Add handler to clock_handlers list
             clock_handlers.push_back(p.first);
             // If it was previously registered, register it now
@@ -1077,19 +1077,18 @@ SerializeBaseComponentHelper::map_basecomponent(serializable_base*& s, serialize
             // on slotname and slotnum
             name_str += it->second.getSlotName() + "[" + std::to_string(it->second.getSlotNum()) + "]";
         }
-        // sst_map_object(ser, it->second.component, it->second.getShortName().c_str());
-        sst_map_object(ser, it->second.component, name_str.c_str());
+        SST_SER_NAME(it->second.component, name_str.c_str());
         it->second.serialize_comp(ser);
     }
 
     // Put in ComponentInfo data
     ObjectMap* my_info_dir = new ObjectMapHierarchyOnly();
     ser.mapper().map_hierarchy_start("my_info", my_info_dir);
-    ser.mapper().setNextObjectReadOnly();
-    sst_map_object(ser, const_cast<ComponentId_t&>(comp->my_info->id_), "id");
-    ser.mapper().setNextObjectReadOnly();
-    sst_map_object(ser, const_cast<std::string&>(comp->my_info->type), "type");
-    sst_map_object(ser, comp->my_info->defaultTimeBase, "defaultTimeBase");
+
+    SST_SER_NAME(const_cast<ComponentId_t&>(comp->my_info->id_), "id", SerOption::map_read_only);
+    SST_SER_NAME(const_cast<std::string&>(comp->my_info->type), "type", SerOption::map_read_only);
+    SST_SER_NAME(comp->my_info->defaultTimeBase, "defaultTimeBase");
+
     ser.mapper().map_hierarchy_end(); // for my_info_dir
 
     s->serialize_order(ser);

src/sst/core/baseComponent.h

@@ -1156,9 +1156,7 @@ class SerializeBaseComponentHelper
 template <class T>
 class serialize_impl<T*, std::enable_if_t<std::is_base_of_v<SST::BaseComponent, T>>>
 {
-    template <class A>
-    friend class serialize;
-    void operator()(T*& s, serializer& ser)
+    void operator()(T*& s, serializer& ser, ser_opt_t UNUSED(options))
     {
         serializable_base* sp = static_cast<serializable_base*>(s);
         switch ( ser.mode() ) {
@@ -1177,6 +1175,8 @@ class serialize_impl<T*, std::enable_if_t<std::is_base_of_v<SST::BaseComponent,
         }
         s = static_cast<T*>(sp);
     }
+
+    SST_FRIEND_SERIALZE();
 };
 
 } // namespace Core::Serialization

src/sst/core/bootsst.cc

@@ -15,7 +15,8 @@
 #include "sst/core/configShared.h"
 
 #include <cstdlib>
-#include <string.h>
+#include <cstring>
+#include <memory>
 #include <unistd.h> // for opterr
 
 int
@@ -31,14 +32,14 @@ main(int argc, char* argv[])
     SST::ConfigShared cfg(true, true, true, true);
 
     // Make a copy of the argv array (shallow)
-    char* argv_copy[argc + 1];
+    auto argv_copy = std::make_unique<char*[]>(argc + 1);
     for ( int i = 0; i < argc; ++i ) {
         argv_copy[i] = argv[i];
     }
     argv[argc] = nullptr;
 
     // All ranks parse the command line
-    cfg.parseCmdLine(argc, argv_copy);
+    cfg.parseCmdLine(argc, argv_copy.get());
 
     if ( cfg.no_env_config() ) config_env = 0;
     if ( cfg.verbose() ) verbose = 1;

src/sst/core/bootsstinfo.cc

@@ -14,6 +14,9 @@
 #include "sst/core/bootshared.h"
 #include "sst/core/configShared.h"
 
+#include <cstdio>
+#include <memory>
+
 int
 main(int argc, char* argv[])
 {
@@ -26,13 +29,13 @@ main(int argc, char* argv[])
     SST::ConfigShared cfg(true, true, true, true);
 
     // Make a copy of the argv array (shallow)
-    char* argv_copy[argc + 1];
+    auto argv_copy = std::make_unique<char*[]>(argc + 1);
     for ( int i = 0; i < argc; ++i ) {
         argv_copy[i] = argv[i];
     }
     argv[argc] = nullptr;
 
-    cfg.parseCmdLine(argc, argv_copy, true);
+    cfg.parseCmdLine(argc, argv_copy.get(), true);
 
     if ( cfg.no_env_config() ) config_env = false;
 

src/sst/core/clock.cc

@@ -157,10 +157,10 @@ Clock::serialize_order(SST::Core::Serialization::serializer& ser)
 
     // Won't serialize the handlers; they'll be re-registered at
     // restart
-    ser& currentCycle;
-    ser& period;
-    ser& next;
-    ser& scheduled;
+    SST_SER(currentCycle);
+    SST_SER(period);
+    SST_SER(next);
+    SST_SER(scheduled);
 }
 
 

src/sst/core/componentInfo.cc

@@ -199,8 +199,8 @@ ComponentInfo::~ComponentInfo()
 void
 ComponentInfo::serialize_comp(SST::Core::Serialization::serializer& ser)
 {
-    ser& component;
-    ser& link_map;
+    SST_SER(component);
+    SST_SER(link_map);
     for ( auto it = subComponents.begin(); it != subComponents.end(); ++it ) {
         it->second.serialize_comp(ser);
     }
@@ -219,21 +219,21 @@ ComponentInfo::serialize_order(SST::Core::Serialization::serializer& ser)
 
     // Serialize all my data except the component and link_map
 
-    ser& const_cast<ComponentId_t&>(id_);
-    ser& parent_info;
-    ser& const_cast<std::string&>(name);
-    ser& const_cast<std::string&>(type);
+    SST_SER(const_cast<ComponentId_t&>(id_));
+    SST_SER(parent_info);
+    SST_SER(const_cast<std::string&>(name));
+    SST_SER(const_cast<std::string&>(type));
 
     // Not used after construction, no need to serialize
-    // ser& params;
+    // SST_SER(params);
 
-    ser& defaultTimeBase;
+    SST_SER(defaultTimeBase);
 
-    // ser& coordinates;
-    ser& subIDIndex;
-    ser& const_cast<std::string&>(slot_name);
-    ser& slot_num;
-    ser& share_flags;
+    // SST_SER(coordinates);
+    SST_SER(subIDIndex);
+    SST_SER(const_cast<std::string&>(slot_name));
+    SST_SER(slot_num);
+    SST_SER(share_flags);
 
     // Serialize statistic data structures - only needed for late stat registration
     // No one else has these pointers so serialize the data structure & reallocate on UNPACK
@@ -243,39 +243,39 @@ ComponentInfo::serialize_order(SST::Core::Serialization::serializer& ser)
         std::map<std::string, StatisticId_t>     enabled_stat_names;
         bool                                     is_null = true;
 
-        ser& is_null;
+        SST_SER(is_null);
         if ( !is_null ) {
-            ser& stat_configs;
+            SST_SER(stat_configs);
             stat_configs_ = new std::map<StatisticId_t, ConfigStatistic>(stat_configs);
         }
 
-        ser& is_null;
+        SST_SER(is_null);
         if ( !is_null ) {
-            ser& all_stat_config;
+            SST_SER(all_stat_config);
             all_stat_config_ = new ConfigStatistic(all_stat_config);
         }
 
-        ser& is_null;
+        SST_SER(is_null);
         if ( !is_null ) {
-            ser& enabled_stat_names;
+            SST_SER(enabled_stat_names);
             enabled_stat_names_ = new std::map<std::string, StatisticId_t>(enabled_stat_names);
         }
     }
     else {
         bool is_null = stat_configs_ == nullptr;
-        ser& is_null;
-        if ( !is_null ) ser&(*stat_configs_);
+        SST_SER(is_null);
+        if ( !is_null ) SST_SER(*stat_configs_);
 
         is_null = all_stat_config_ == nullptr;
-        ser& is_null;
-        if ( !is_null ) ser&(*all_stat_config_);
+        SST_SER(is_null);
+        if ( !is_null ) SST_SER(*all_stat_config_);
 
         is_null = enabled_stat_names_ == nullptr;
-        ser& is_null;
-        if ( !is_null ) ser&(*enabled_stat_names_);
+        SST_SER(is_null);
+        if ( !is_null ) SST_SER(*enabled_stat_names_);
     }
 
-    ser& statLoadLevel; // Potentially needed for late stat registration
+    SST_SER(statLoadLevel); // Potentially needed for late stat registration
 
     // For SubComponents map, need to serialize map by hand since we
     // we will need to use the track non-pointer as pointer feature in
@@ -284,48 +284,7 @@ ComponentInfo::serialize_order(SST::Core::Serialization::serializer& ser)
     // own SubCompenents that will need to point to the data location
     // in the map.
 
-    // ser& subComponents;
-    switch ( ser.mode() ) {
-    case SST::Core::Serialization::serializer::SIZER:
-    {
-        size_t size = subComponents.size();
-        ser&   size;
-        for ( auto it = subComponents.begin(); it != subComponents.end(); ++it ) {
-            // keys are const values - annoyingly
-            ser& const_cast<ComponentId_t&>(it->first);
-            ser | it->second;
-        }
-        break;
-    }
-    case SST::Core::Serialization::serializer::PACK:
-    {
-        size_t size = subComponents.size();
-        ser&   size;
-        for ( auto it = subComponents.begin(); it != subComponents.end(); ++it ) {
-            // keys are const values - annoyingly
-            ser& const_cast<ComponentId_t&>(it->first);
-            ser | it->second;
-        }
-        break;
-    }
-    case SST::Core::Serialization::serializer::UNPACK:
-    {
-        size_t size;
-        ser&   size;
-        for ( size_t i = 0; i < size; ++i ) {
-            ComponentId_t key;
-            ser&          key;
-
-            auto p = subComponents.emplace(key, ComponentInfo {});
-
-            ser | p.first->second;
-        }
-        break;
-    }
-    case SST::Core::Serialization::serializer::MAP:
-        // Add your code here
-        break;
-    }
+    SST_SER(subComponents, SerOption::as_ptr_elem);
 
     // Only the parent Component will call serialize_comp directly.
     // This function will walk the hierarchy and call it on all of its