Merge pull request #1292 from sstsimulator/devel

Automatically Merged using SST Master Branch Merger

Author: sst-autotester

src/sst/core/cfgoutput/jsonConfigOutput.cc

@@ -32,13 +32,15 @@ JSONConfigGraphOutput::JSONConfigGraphOutput(const char* path) : ConfigGraphOutp
 namespace {
 struct CompWrapper
 {
-    SST::ConfigComponent const* comp;
-    bool                        output_parition_info;
+    SST::ConfigComponent const*                comp;
+    std::map<SST::StatisticId_t, std::string>& sharedStatMap;
+    bool                                       output_parition_info;
 };
 
 struct SubCompWrapper
 {
-    SST::ConfigComponent const* comp;
+    SST::ConfigComponent const*                comp;
+    std::map<SST::StatisticId_t, std::string>& sharedStatMap;
 };
 
 struct LinkConfPair
@@ -50,6 +52,7 @@ struct LinkConfPair
 struct StatPair
 {
     std::pair<std::string, unsigned long> const& statkey;
+    std::map<SST::StatisticId_t, std::string>&   sharedStatMap;
     SST::ConfigComponent const*                  comp;
 };
 
@@ -69,10 +72,22 @@ struct StatGroupParamPair
 void
 to_json(json::ordered_json& j, StatPair const& sp)
 {
-    auto const& name = sp.statkey.first;
-    j                = json::ordered_json { { "name", name } };
-
     auto* si = sp.comp->findStatistic(sp.statkey.second);
+    if ( si->shared ) {
+        if ( sp.sharedStatMap.find(si->id) == sp.sharedStatMap.end() ) {
+            std::string name = "statObj" + std::to_string(sp.sharedStatMap.size()) + "_" + si->name;
+            sp.sharedStatMap[si->id].assign(name);
+            j = json::ordered_json { { "name", name } };
+        }
+        else {
+            std::string name = sp.sharedStatMap.find(si->id)->second;
+            j                = json::ordered_json { { "name", name } };
+        }
+    }
+    else {
+        auto const& name = sp.statkey.first;
+        j                = json::ordered_json { { "name", name } };
+    }
     for ( auto const& parmItr : si->params.getKeys() ) {
         j["params"][parmItr] = si->params.find<std::string>(parmItr);
     }
@@ -93,11 +108,11 @@ to_json(json::ordered_json& j, SubCompWrapper const& comp_wrapper)
     }
 
     for ( auto const& scItr : comp->subComponents ) {
-        j["subcomponents"].push_back(SubCompWrapper { scItr });
+        j["subcomponents"].push_back(SubCompWrapper { scItr, comp_wrapper.sharedStatMap });
     }
 
     for ( auto const& pair : comp->enabledStatNames ) {
-        j["statistics"].push_back(StatPair { pair, comp });
+        j["statistics"].push_back(StatPair { pair, comp_wrapper.sharedStatMap, comp });
     }
 }
 
@@ -116,11 +131,11 @@ to_json(json::ordered_json& j, CompWrapper const& comp_wrapper)
     }
 
     for ( auto const& scItr : comp->subComponents ) {
-        j["subcomponents"].push_back(SubCompWrapper { scItr });
+        j["subcomponents"].push_back(SubCompWrapper { scItr, comp_wrapper.sharedStatMap });
     }
 
     for ( auto const& pair : comp->enabledStatNames ) {
-        j["statistics"].push_back(StatPair { pair, comp });
+        j["statistics"].push_back(StatPair { pair, comp_wrapper.sharedStatMap, comp });
     }
 
     if ( comp_wrapper.output_parition_info ) {
@@ -256,7 +271,7 @@ JSONConfigGraphOutput::generate(const Config* cfg, ConfigGraph* graph)
     if ( const_cast<ConfigComponentMap_t&>(compMap).size() == 0 ) { outputJson["components"]; }
 
     for ( const auto& compItr : compMap ) {
-        outputJson["components"].emplace_back(CompWrapper { compItr, cfg->output_partition() });
+        outputJson["components"].emplace_back(CompWrapper { compItr, sharedStatMap, cfg->output_partition() });
     }
 
     // no links exist in this rank
@@ -273,4 +288,6 @@ JSONConfigGraphOutput::generate(const Config* cfg, ConfigGraph* graph)
     // lifetime extension, but this temp is the careful way.
     std::string outputString = ss.str();
     fprintf(outputFile, "%s", outputString.c_str());
+
+    sharedStatMap.clear();
 }

src/sst/core/cfgoutput/jsonConfigOutput.h

@@ -24,6 +24,9 @@ class JSONConfigGraphOutput : public ConfigGraphOutput
 public:
     JSONConfigGraphOutput(const char* path);
     virtual void generate(const Config* cfg, ConfigGraph* graph) override;
+
+private:
+    std::map<SST::StatisticId_t, std::string> sharedStatMap;
 };
 
 } // namespace SST::Core

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

@@ -60,6 +60,9 @@ class serialize_impl<
            // whether end() method exists
            decltype(std::declval<T>().end()),
 
+           // whether a clear() method exists
+           decltype(std::declval<T>().clear()),
+
            // whether get_size() can determine size because it has a matching overload
            decltype(get_size(std::declval<T>())),
 
@@ -85,13 +88,22 @@ class serialize_impl<
     // Note: the following use struct templates because of a GCC bug which does
     // not allow static constexpr variable templates defined inside of a class.
 
+    // Whether it is a std::vector
+    template <typename>
+    struct is_vector : std::false_type
+    {};
+
+    template <typename... Ts>
+    struct is_vector<std::vector<Ts...>> : std::true_type
+    {};
+
     // Whether it is a std::vector<bool>
     template <typename>
     struct is_vector_bool : std::false_type
     {};
 
-    template <typename U>
-    struct is_vector_bool<std::vector<bool, U>> : std::true_type
+    template <typename... Ts>
+    struct is_vector_bool<std::vector<bool, Ts...>> : std::true_type
     {};
 
     // Whether it is a std::forward_list
@@ -103,16 +115,29 @@ class serialize_impl<
     struct is_forward_list<std::forward_list<Ts...>> : std::true_type
     {};
 
-    // Whether it is a "map" (i.e. has [key, value] elements)
+    // Whether it is a simple map (not a multimap and has integral, floating-point, enum, or convertible to string keys)
     template <typename, typename = void>
-    struct is_map : std::false_type
+    struct is_simple_map : std::false_type
     {};
 
-    template <template <typename...> class U, typename... Us>
-    struct is_map<
-        U<Us...>, std::enable_if_t<
-                      is_same_template_v<U, std::map> || is_same_template_v<U, std::multimap> ||
-                      is_same_template_v<U, std::unordered_map> || is_same_template_v<U, std::unordered_multimap>>> :
+    template <template <typename...> class MAP, typename KEY, typename... REST>
+    struct is_simple_map<
+        MAP<KEY, REST...>,
+        std::enable_if_t<(is_same_template_v<MAP, std::map> || is_same_template_v<MAP, std::unordered_map>)&&(
+            std::is_arithmetic_v<KEY> || std::is_enum_v<KEY> || std::is_convertible_v<KEY, std::string>)>> :
+        std::true_type
+    {};
+
+    // Whether it is a simple set (not a multiset and has integral, floating-point, enum, or convertible to string keys)
+    template <typename, typename = void>
+    struct is_simple_set : std::false_type
+    {};
+
+    template <template <typename...> class SET, typename KEY, typename... REST>
+    struct is_simple_set<
+        SET<KEY, REST...>,
+        std::enable_if_t<(is_same_template_v<SET, std::set> || is_same_template_v<SET, std::unordered_set>)&&(
+            std::is_arithmetic_v<KEY> || std::is_enum_v<KEY> || std::is_convertible_v<KEY, std::string>)>> :
         std::true_type
     {};
 
@@ -145,15 +170,16 @@ class serialize_impl<
 
         case serializer::UNPACK:
         {
-            t.~T();        // Destroy the old container
-            new (&t) T {}; // Create an empty new container
+            size_t size;
+            ser.unpack(size);
+
+            t.clear();                                            // Clear the container
+            if constexpr ( is_vector<T>::value ) t.reserve(size); // Reserve size of vector
 
             // For std::forward_list, last is iterator of last element inserted
             decltype(t.begin()) last [[maybe_unused]];
             if constexpr ( is_forward_list<T>::value ) last = t.before_begin();
 
-            size_t size;
-            ser.unpack(size);
             for ( size_t i = 0; i < size; ++i ) {
                 value_type e {}; // For now, elements have to be default-initializable
                 ser&       e;    // Unpack the element
@@ -175,26 +201,26 @@ class serialize_impl<
             auto*              obj_map = new ObjectMapContainer<T>(&t);
             ser.mapper().map_hierarchy_start(name, obj_map);
 
-            if constexpr ( is_map<T>::value ) {
-                // (key, value) mappings
-                // TODO: how to handle std::multimap and std::unordered_multimap with equal keys
-                // auto [ begin, end ] = equal_range(key) returns range of elements equal to key
+            if constexpr ( is_vector_bool<T>::value ) {
+                // std::vector<bool>
+                size_t i = 0;
+                for ( bool e : t )
+                    sst_map_object(ser, e, to_string(i++));
+            }
+            else if constexpr ( is_simple_map<T>::value ) {
+                // non-multi maps with a simple key
                 for ( auto& [key, value] : t )
                     sst_map_object(ser, value, to_string(key));
             }
-            else if constexpr ( !is_vector_bool<T>::value ) {
-                // std::vector, std::deque, std::list, std::forward_list, std::set, std::multiset
-                // std::unordered_set, std::unordered_multiset
+            // TODO: handle is_simple_set
+            else {
+                // std::vector, std::deque, std::list, std::forward_list, std::multimap,
+                // std::unordered_multimap, std::multiset, std::unordered_multiset, and
+                // std::map, std::set, std::unordered_map std::unordered_set with non-simple keys
                 size_t i = 0;
                 for ( auto& e : t )
                     sst_map_object(ser, (value_type&)e, to_string(i++));
             }
-            else {
-                // std::vector<bool>
-                size_t i = 0;
-                for ( bool e : t )
-                    sst_map_object(ser, e, to_string(i++));
-            }
             ser.mapper().map_hierarchy_end();
             break;
         }

src/sst/core/testingframework/sst_unittest.py

@@ -22,24 +22,18 @@
     test developer.  More support functions exist within sst_unittest_support.py
 """
 
-import sys
+import multiprocessing
 import os
-import unittest
-import threading
 import signal
+import sys
 import time
-import multiprocessing
+import unittest
 from typing import Optional
 
 import test_engine_globals
 from sst_unittest_support import *
-from test_engine_support import OSCommand
-from test_engine_support import check_param_type
-from test_engine_support import strclass
-from test_engine_support import strqual
-from test_engine_junit import JUnitTestSuite
-from test_engine_junit import junit_to_xml_report_file
-#from test_engine_junit import junit_to_xml_report_string
+from test_engine_junit import JUnitTestSuite, junit_to_xml_report_file
+from test_engine_support import check_param_type, strclass, strqual
 
 if not sys.warnoptions:
     import warnings
@@ -370,7 +364,7 @@ def run_sst(
             log_fatal("OpenMPI IS NOT FOUND/AVAILABLE")
 
         # Launch SST
-        rtn = OSCommand(oscmd, output_file_path = out_file,
+        rtn = os_command(oscmd, output_file_path = out_file,
                         error_file_path = err_file,
                         set_cwd = set_cwd).run(timeout_sec=timeout_sec, send_signal=send_signal, signal_sec=signal_sec)
         if num_ranks > 1: