TimeVortex is no longer serialized during checkpoint/restart. (#1334)

On checkpoint, the TimeVortex returns a copy of its contents, which are
then sorted. Events are serialized with the Component trees they are
targetting. Actions are ignored and are recreated on restart. The Actions
that are recreated are: StopAction, Exit, Clocks, OneShots (for stats).

As a consequence, a couple things were added:
- BaseComponent now sorts the clocks that are registered through it so
  that it can ensure they exist after restart
- OneShotManager was added and can create OneShots whose trigger time
  is either absolute or relative to current time

Stat Groups now checkpoint/restart correctly

Event and Action now define both isAction() and isEvent() as final

Unrelated fix: TimeVortexPQ can now properly print its contents

Author: feldergast

src/sst/core/Makefile.am

@@ -198,7 +198,6 @@ sst_core_sources = \
 	mempool.cc \
 	mempoolAccessor.h \
 	namecheck.cc \
-	oneshot.cc \
 	output.cc \
 	params.cc \
 	pollingLinkQueue.cc \

src/sst/core/action.h

@@ -29,7 +29,8 @@ class Action : public Activity
     Action() {}
     ~Action() {}
 
-    bool isAction() override final { return true; }
+    bool isEvent() const override final { return false; }
+    bool isAction() const override final { return true; }
 
 protected:
     /** Called to signal to the Simulation object to end the simulation */

src/sst/core/activity.h

@@ -159,8 +159,8 @@ class Activity : public SST::Core::MemPoolItem
     /** Returns the queue order associated with this activity */
     inline uint64_t getQueueOrder() const { return queue_order; }
 
-    virtual bool isEvent() { return false; }
-    virtual bool isAction() { return false; }
+    virtual bool isEvent() const  = 0;
+    virtual bool isAction() const = 0;
 
     /** Get a string represenation of the event.  The default version
      * will just use the name of the class, retrieved through the

src/sst/core/baseComponent.cc

@@ -122,6 +122,8 @@ BaseComponent::pushValidParams(Params& params, const std::string& type)
 void
 BaseComponent::registerClock_impl(TimeConverter* tc, Clock::HandlerBase* handler, bool regAll)
 {
+    // Add this clock to our registered_clocks_ set
+    registered_clocks_.insert(tc->getFactor());
 
     // Need to see if I already know about this clock handler
     bool found = false;
@@ -962,6 +964,9 @@ BaseComponent::serialize_order(SST::Core::Serialization::serializer& ser)
     case SST::Core::Serialization::serializer::SIZER:
     case SST::Core::Serialization::serializer::PACK:
     {
+        // Serialize our registered_clocks_
+        SST_SER(registered_clocks_);
+
         // Need to serialize each handler
         std::pair<Clock::HandlerBase*, SimTime_t> p;
         size_t                                    num_handlers = clock_handlers_.size();
@@ -985,6 +990,11 @@ BaseComponent::serialize_order(SST::Core::Serialization::serializer& ser)
             primaryComponentDoNotEndSim();
         }
 
+        SST_SER(registered_clocks_);
+        for ( auto x : registered_clocks_ ) {
+            sim_->reportClock(x, CLOCKPRIORITY);
+        }
+
         std::pair<Clock::HandlerBase*, SimTime_t> p;
         size_t                                    num_handlers;
         SST_SER(num_handlers);

src/sst/core/baseComponent.h

@@ -17,7 +17,6 @@
 #include "sst/core/eli/elementinfo.h"
 #include "sst/core/event.h"
 #include "sst/core/factory.h"
-#include "sst/core/oneshot.h"
 #include "sst/core/portModule.h"
 #include "sst/core/profile/componentProfileTool.h"
 #include "sst/core/serialization/serializable_base.h"
@@ -1143,6 +1142,7 @@ class BaseComponent : public SST::Core::Serialization::serializable_base
     // Need to track clock handlers for checkpointing.  We need to
     // know what clock handlers we have registered with the core
     std::vector<Clock::HandlerBase*> clock_handlers_;
+    std::set<SimTime_t>              registered_clocks_;
 
     void  addSelfLink(const std::string& name);
     Link* getLinkFromParentSharedPort(const std::string& port, std::vector<ConfigPortModule>& port_modules);

src/sst/core/clock.cc

@@ -128,10 +128,12 @@ Clock::schedule()
     // simtime.  This happens if the clock would have fired at this
     // tick and if the current priority is less than my priority.
     // However, if we are at time = 0, then we always go out to the
-    // next cycle;
-    if ( sim->getCurrentPriority() < getPriority() && sim->getCurrentSimCycle() != 0 ) {
+    // next cycle. Also, if the call happens during complete() or
+    // finish(), then we don't adjust either.
+    if ( sim->getCurrentPriority() < getPriority() && sim->getCurrentSimCycle() != 0 && !sim->endSim ) {
         if ( sim->getCurrentSimCycle() % period->getFactor() == 0 ) {
             next = sim->getCurrentSimCycle();
+            currentCycle--; // First thing execute does in increment currentCycle
         }
     }
 

src/sst/core/componentInfo.cc

@@ -268,7 +268,9 @@ ComponentInfo::serialize_order(SST::Core::Serialization::serializer& ser)
         if ( !is_null ) SST_SER(*enabled_stat_names_);
     }
 
-    SST_SER(statLoadLevel); // Potentially needed for late stat registration
+    // Potentially needed for late stat registration
+    SST_SER(statLoadLevel);
+    SST_SER(enabled_all_stats_);
 
     // For SubComponents map, need to serialize map by hand since we
     // we will need to use the track non-pointer as pointer feature in

src/sst/core/event.h

@@ -27,12 +27,18 @@ class NullEvent;
 class RankSync;
 class ThreadSync;
 
+namespace pvt {
+class DeliveryInfoCompEvent;
+} // namespace pvt
+
 /**
  * Base class for Events - Items sent across links to communicate between
  * components.
  */
 class Event : public Activity
 {
+    friend class pvt::DeliveryInfoCompEvent;
+
 public:
     /**
        Base handler for event delivery.
@@ -69,6 +75,28 @@ class Event : public Activity
     template <typename classT, auto funcT, typename dataT = void>
     using Handler2 = SSTHandler2<void, Event*, classT, dataT, funcT>;
 
+    /**
+       Class used to sort events during checkpointing.  This is used
+       to sort events by delivery_info so we can use std::lower_bound
+       to easily find events targeting a specific handler.  For Events
+       targetting the same handler, it will sort according to
+       Activity::less.  This will ensure that things get inserted back
+       in correct order, though the only important thing is that
+       insertion order is maintained, so two events to be delivered at
+       the same time maintain their send order.
+
+     */
+    class less
+    {
+    public:
+        bool operator()(const Event* lhs, const Event* rhs) const
+        {
+            if ( lhs->delivery_info != rhs->delivery_info ) return lhs->delivery_info < rhs->delivery_info;
+            return Activity::less<true, true, true>()(lhs, rhs);
+        }
+    };
+
+
     /** Type definition of unique identifiers */
     using id_type = std::pair<uint64_t, int>;
     /** Constant, default value for id_types */
@@ -123,7 +151,8 @@ class Event : public Activity
 
 #endif
 
-    bool isEvent() override final { return true; }
+    bool isEvent() const override final { return true; }
+    bool isAction() const override final { return false; }
 
     void copyAllDeliveryInfo(const Activity* act) override final
     {
@@ -184,6 +213,15 @@ class Event : public Activity
         this->delivery_info = delivery_info;
     }
 
+    /**
+       Update the delivery_info during a restart.  This will fixup the
+       handler pointer.
+
+       @param dinfo New handler pointer cast as a uintptr_t
+     */
+    void updateDeliveryInfo(uintptr_t dinfo) { delivery_info = dinfo; }
+
+
     /** Gets the link id used for delivery.  For use by SST Core only */
     inline Link* getDeliveryLink() { return reinterpret_cast<Link*>(delivery_info); }
 
@@ -250,6 +288,22 @@ class EventHandlerMetaData : public AttachPointMetaData
     ~EventHandlerMetaData() {}
 };
 
+namespace pvt {
+
+/**
+   Class used with std::lower_bound to find the start of events in a
+   sorted list with the specified delivery_info.
+ */
+class DeliveryInfoCompEvent : public Event
+{
+public:
+    static uintptr_t getDeliveryInfo(Event* ev) { return ev->delivery_info; }
+
+    DeliveryInfoCompEvent(uintptr_t delivery_info) { setDeliveryInfo(0, delivery_info); }
+};
+
+} // namespace pvt
+
 } // namespace SST
 
 #endif // SST_CORE_EVENT_H

src/sst/core/impl/Makefile.inc

@@ -3,6 +3,11 @@
 #
 #
 
+sst_core_sources += \
+	impl/oneshotManager.h \
+	impl/oneshotManager.cc
+
+
 include impl/interactive/Makefile.inc
 include impl/timevortex/Makefile.inc
 include impl/partitioners/Makefile.inc

src/sst/core/impl/oneshotManager.cc

@@ -0,0 +1,109 @@
+// 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.
+
+#include "sst_config.h"
+
+#include "sst/core/impl/oneshotManager.h"
+
+#include "sst/core/simulation_impl.h"
+#include "sst/core/timeVortex.h"
+
+namespace SST::Core {
+
+void
+OneShot::execute()
+{
+    // Call all the handlers.  Delete each one once after calling.
+    // The handlers are guaranteed not to be shared.
+    for ( auto* x : handlers ) {
+        (*x)();
+        delete x;
+    }
+
+    manager->oneshotCallback(time, this);
+}
+
+
+OneShotManager::OneShotManager(Simulation_impl* sim) :
+    sim_(sim)
+{}
+
+OneShotManager::~OneShotManager()
+{
+    // Need to delete all the Handlers
+    for ( auto& list : handler_vector_map_ ) {
+        for ( auto* item : list.second.first ) {
+            delete item;
+        }
+    }
+}
+
+void
+OneShotManager::registerHandlerBase(SimTime_t trigger_time, int priority, bool relative, OneShot::HandlerBase* handler)
+{
+
+    // Check to make sure this isn't in the past
+    TimeStamp_t curr_time = std::make_pair(sim_->getCurrentSimCycle(), sim_->getCurrentPriority());
+    TimeStamp_t trig_time = std::make_pair(trigger_time + (relative ? sim_->getCurrentSimCycle() : 0), priority);
+
+    if ( trig_time <= curr_time ) {
+        // Emit warning and ignore request
+        sim_->getSimulationOutput().output(
+            "WARNING: Trying to register a OneShot for a time in the past, ignoring request\n");
+        return;
+    }
+
+    // Get the handler list for the specified time stamp.  If it's not
+    // already there, it will be created.
+    std::pair<OneShot::HandlerList_t, bool>& map_item = handler_vector_map_[trig_time];
+
+    // Push handler onto the list
+    map_item.first.push_back(handler);
+
+    // Check to see if anything needs to be scheduled
+    scheduleNextOneShot();
+}
+
+void
+OneShotManager::oneshotCallback(TimeStamp_t time, OneShot* oneshot)
+{
+    // Remove the data for this time, schedule the next time and
+    // delete the OneShot.
+    handler_vector_map_.erase(time);
+    delete oneshot;
+
+    scheduleNextOneShot();
+}
+
+void
+OneShotManager::scheduleNextOneShot()
+{
+    // Get next event to schdule.  Iterator maps as follows:
+    // it.first : TimeStamp_t : trigger time
+    // it.second.first = HandlerList_t : list of handlers to call
+    // it.second.second = bool : scheduled
+    auto it = handler_vector_map_.begin();
+
+    // If there are no events, return
+    if ( it == handler_vector_map_.end() ) return;
+
+    // If first event is already scheduled, nothing to do
+    if ( it->second.second ) return;
+
+    // Not yet scheduled, create a OneShot and insert into TimeVortex
+    TimeStamp_t t = it->first;
+
+    OneShot* oneshot = new OneShot(t, this, it->second.first);
+    sim_->timeVortex->insert(oneshot);
+    it->second.second = true;
+}
+
+} // namespace SST::Core