Merge pull request #1349 from sstsimulator/devel

Automatically Merged using SST Master Branch Merger

Author: sst-autotester

src/sst/core/Makefile.am

@@ -101,14 +101,18 @@ nobase_dist_sst_HEADERS = \
 	serialization/impl/serialize_adapter.h \
 	serialization/impl/serialize_array.h \
 	serialization/impl/serialize_atomic.h \
+	serialization/impl/serialize_bitset.h \
 	serialization/impl/ser_buffer_accessor.h \
 	serialization/impl/serialize_insertable.h \
+        serialization/impl/serialize_optional.h \
 	serialization/impl/serialize_tuple.h \
 	serialization/impl/serialize_utility.h \
+	serialization/impl/serialize_variant.h \
 	serialization/impl/mapper.h \
 	serialization/impl/packer.h \
 	serialization/impl/sizer.h \
 	serialization/impl/serialize_string.h \
+	serialization/impl/serialize_valarray.h \
 	serialization/impl/unpacker.h \
 	serialization/serializer.h \
 	serialization/serializer_fwd.h \

src/sst/core/impl/interactive/simpleDebug.cc

@@ -57,6 +57,44 @@ SimpleDebugger::tokenize(std::vector<std::string>& tokens, const std::string& in
     return tokens;
 }
 
+void
+SimpleDebugger::cmd_help(std::vector<std::string>& UNUSED(tokens))
+{
+    std::string help = "SimpleDebug Console Commands\n";
+    help.append("  Navigation: Navigate the current object map\n");
+    help.append("   - pwd: print the current working directory in the object map\n");
+    help.append("   - cd: change directory level in the object map\n");
+    help.append("   - ls: list the objects in the current level of the object map\n");
+
+    help.append("  Current State: Print information about the current simulation state\n");
+    help.append("   - time: print current simulation time in cycles\n");
+    help.append("   - print [-rN][<obj>]: print objects in the current level of the object map;\n");
+    help.append("                         if -rN is provided print recursive N levels (default N=4)\n");
+
+    help.append("  Modify State: Modify simulation variables\n");
+    help.append("   - set <obj> <value>: sets an object in the current scope to the provided value;\n");
+    help.append("                        object must be a \"fundamental type\" e.g. int \n");
+
+    help.append("  Watch Points: Manage watch points which break into interactive console when triggered\n");
+    help.append("   - watch: prints the current list of watch points and their associated indices\n");
+    help.append("     watch <var>: adds var to the watch list; triggered when value changes\n");
+    help.append("     watch <var> <comp> <val>: add var to watch list; triggered when comparison with val is true\n");
+    help.append("                 Valid <comp> operators: <, <=, >, >=, ==, !=\n");
+    help.append("   - unwatch <index>: removes the indexed watch point from the watch list;\n");
+    help.append("                 <index> is the associated index from the list of watch points\n");
+
+    help.append("  Execute: Execute the simulation for a specified duration\n");
+    help.append("   - run [TIME]: runs the simulation from the current point for TIME and then returns to\n");
+    help.append("                 interactive mode; if no time is given, the simulation runs to completion;\n");
+    help.append("                 TIME is of the format <Number><unit> e.g. 4us\n");
+
+    help.append("  Exit: Exit the interactive console\n");
+    help.append("   - exit or quit: exits the interactive console and resumes simulation execution\n");
+    help.append("   - shutdown: exits the interactive console and does a clean shutdown of the simulation\n");
+
+    printf("%s", help.c_str());
+}
+
 void
 SimpleDebugger::cmd_pwd(std::vector<std::string>& UNUSED(tokens))
 {
@@ -378,6 +416,15 @@ SimpleDebugger::cmd_unwatch(std::vector<std::string>& tokens)
     watch_points_.erase(watch_points_.begin() + index);
 }
 
+void
+SimpleDebugger::cmd_shutdown(std::vector<std::string>& UNUSED(tokens))
+{
+    simulationShutdown();
+    done = true;
+    printf("Exiting ObjectExplorer and shutting down simulation\n");
+    return;
+}
+
 void
 SimpleDebugger::dispatch_cmd(std::string cmd)
 {
@@ -415,6 +462,12 @@ SimpleDebugger::dispatch_cmd(std::string cmd)
     else if ( tokens[0] == "unwatch" ) {
         cmd_unwatch(tokens);
     }
+    else if ( tokens[0] == "shutdown" ) {
+        cmd_shutdown(tokens);
+    }
+    else if ( tokens[0] == "help" ) {
+        cmd_help(tokens);
+    }
     else {
         printf("Unknown command: %s\n", tokens[0].c_str());
     }

src/sst/core/impl/interactive/simpleDebug.h

@@ -66,6 +66,7 @@ class SimpleDebugger : public SST::InteractiveConsole
 
     std::vector<std::string> tokenize(std::vector<std::string>& tokens, const std::string& input);
 
+    void cmd_help(std::vector<std::string>& tokens);
     void cmd_pwd(std::vector<std::string>& tokens);
     void cmd_ls(std::vector<std::string>& tokens);
     void cmd_cd(std::vector<std::string>& tokens);
@@ -75,6 +76,7 @@ class SimpleDebugger : public SST::InteractiveConsole
     void cmd_run(std::vector<std::string>& tokens);
     void cmd_watch(std::vector<std::string>& tokens);
     void cmd_unwatch(std::vector<std::string>& tokens);
+    void cmd_shutdown(std::vector<std::string>& tokens);
 
     void dispatch_cmd(std::string cmd);
 };

src/sst/core/interactiveConsole.cc

@@ -111,4 +111,11 @@ InteractiveConsole::getComponentObjectMap()
     return Simulation_impl::getSimulation()->getComponentObjectMap();
 }
 
+void
+InteractiveConsole::simulationShutdown()
+{
+    Simulation_impl::getSimulation()->endSimulation();
+}
+
+
 } // namespace SST

src/sst/core/interactiveConsole.h

@@ -124,6 +124,8 @@ class InteractiveConsole
 
     SST::Core::Serialization::ObjectMap* getComponentObjectMap();
 
+    void simulationShutdown();
+
 private:
     InteractiveConsole(const InteractiveConsole&)            = delete;
     InteractiveConsole& operator=(const InteractiveConsole&) = delete;

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

@@ -0,0 +1,65 @@
+// Copyright 2009-2025 NTESS. Under the terms
+// of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Copyright (c) 2009-2025, NTESS
+// All rights reserved.
+//
+// This file is part of the SST software package. For license
+// information, see the LICENSE file in the top level directory of the
+// distribution.
+
+#ifndef SST_CORE_SERIALIZATION_IMPL_SERIALIZE_BITSET_H
+#define SST_CORE_SERIALIZATION_IMPL_SERIALIZE_BITSET_H
+
+#ifndef SST_INCLUDING_SERIALIZE_H
+#warning \
+    "The header file sst/core/serialization/impl/serialize_bitset.h should not be directly included as it is not part of the stable public API.  The file is included in sst/core/serialization/serialize.h"
+#endif
+
+#include "sst/core/serialization/serializer.h"
+
+#include <bitset>
+#include <cstddef>
+#include <type_traits>
+
+namespace SST::Core::Serialization {
+
+// Serialize std::bitset
+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))
+    {
+        switch ( ser.mode() ) {
+        case serializer::MAP:
+        {
+            // TODO: Should this be mapped as an array? It will have the same problems as std::vector<bool>
+            break;
+        }
+
+        default:
+            static_assert(std::is_trivially_copyable_v<T> && std::is_standard_layout_v<T>);
+            ser.primitive(t);
+            break;
+        }
+    }
+    SST_FRIEND_SERIALIZE();
+};
+
+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))
+    {
+        if ( ser.mode() == serializer::UNPACK ) t = new T {};
+        SST_SER(*t);
+    }
+    SST_FRIEND_SERIALIZE();
+};
+
+} // namespace SST::Core::Serialization
+
+#endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_BITSET_H

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

@@ -0,0 +1,69 @@
+// Copyright 2009-2025 NTESS. Under the terms
+// of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Copyright (c) 2009-2025, NTESS
+// All rights reserved.
+//
+// This file is part of the SST software package. For license
+// information, see the LICENSE file in the top level directory of the
+// distribution.
+
+#ifndef SST_CORE_SERIALIZATION_IMPL_SERIALIZE_OPTIONAL_H
+#define SST_CORE_SERIALIZATION_IMPL_SERIALIZE_OPTIONAL_H
+
+#ifndef SST_INCLUDING_SERIALIZE_H
+#warning \
+    "The header file sst/core/serialization/impl/serialize_optional.h should not be directly included as it is not part of the stable public API.  The file is included in sst/core/serialization/serialize.h"
+#endif
+
+#include "sst/core/serialization/serializer.h"
+
+#include <optional>
+
+namespace SST::Core::Serialization {
+
+// Serialize std::optional
+template <typename T>
+class serialize_impl<std::optional<T>>
+{
+    void operator()(std::optional<T>& obj, serializer& ser, ser_opt_t options)
+    {
+        bool has_value = false;
+
+        switch ( ser.mode() ) {
+        case serializer::SIZER:
+            has_value = obj.has_value();
+            ser.size(has_value);
+            break;
+
+        case serializer::PACK:
+            has_value = obj.has_value();
+            ser.pack(has_value);
+            break;
+
+        case serializer::UNPACK:
+            ser.unpack(has_value);
+            if ( has_value )
+                obj.emplace();
+            else
+                obj.reset();
+            break;
+
+        case serializer::MAP:
+        {
+            // TODO: how to map std::optional ?
+            return;
+        }
+        }
+
+        // Serialize the optional object if it is present
+        if ( has_value ) sst_ser_object(ser, *obj, options, nullptr);
+    }
+
+    SST_FRIEND_SERIALIZE();
+};
+
+} // namespace SST::Core::Serialization
+
+#endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_OPTIONAL_H

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

@@ -0,0 +1,80 @@
+// Copyright 2009-2025 NTESS. Under the terms
+// of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Copyright (c) 2009-2025, NTESS
+// All rights reserved.
+//
+// This file is part of the SST software package. For license
+// information, see the LICENSE file in the top level directory of the
+// distribution.
+
+#ifndef SST_CORE_SERIALIZATION_IMPL_SERIALIZE_VALARRAY_H
+#define SST_CORE_SERIALIZATION_IMPL_SERIALIZE_VALARRAY_H
+
+#ifndef SST_INCLUDING_SERIALIZE_H
+#warning \
+    "The header file sst/core/serialization/impl/serialize_valarray.h should not be directly included as it is not part of the stable public API.  The file is included in sst/core/serialization/serialize.h"
+#endif
+
+#include "sst/core/serialization/serializer.h"
+
+#include <string>
+#include <type_traits>
+#include <valarray>
+
+namespace SST::Core::Serialization {
+
+// Whether a type is a std::valarray type
+template <typename>
+constexpr bool is_valarray_v = false;
+
+// We must make sure that T is trivially copyable and standard layout type, although this is almost always true
+template <typename T>
+constexpr bool is_valarray_v<std::valarray<T>> = std::is_trivially_copyable_v<T> && std::is_standard_layout_v<T>;
+
+// Serialize std::valarray and pointers to std::valarray
+template <typename T>
+class serialize_impl<T, std::enable_if_t<is_valarray_v<std::remove_pointer_t<T>>>>
+{
+    void operator()(T& obj, serializer& ser, ser_opt_t UNUSED(options))
+    {
+        const auto& objPtr = get_ptr(obj);
+        size_t      size   = 0;
+        switch ( ser.mode() ) {
+        case serializer::SIZER:
+            size = objPtr->size();
+            ser.size(size);
+            break;
+
+        case serializer::PACK:
+            size = objPtr->size();
+            ser.pack(size);
+            break;
+
+        case serializer::UNPACK:
+            ser.unpack(size);
+            if constexpr ( std::is_pointer_v<T> )
+                obj = new std::remove_pointer_t<T>(size);
+            else
+                obj.resize(size);
+            break;
+
+        case serializer::MAP:
+            size = objPtr->size();
+            ser.mapper().map_hierarchy_start(
+                ser.getMapName(), new ObjectMapContainer<std::remove_pointer_t<T>>(objPtr));
+            for ( size_t i = 0; i < size; ++i )
+                sst_ser_object(ser, (*objPtr)[i], SerOption::none, std::to_string(i).c_str());
+            ser.mapper().map_hierarchy_end();
+            return;
+        }
+        ser.raw(&(*objPtr)[0], size * sizeof((*objPtr)[0]));
+    }
+
+    SST_FRIEND_SERIALIZE();
+};
+
+} // namespace SST::Core::Serialization
+
+#endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_VALARRAY_H