Deprecated Handler in favor of Handler2. (#1300)

Author: feldergast

src/sst/core/interfaces/simpleNetwork.h

@@ -215,11 +215,40 @@ class SimpleNetwork : public SubComponent
     template <typename classT, typename dataT = void>
     using Handler = SSTHandler<bool, int, classT, dataT>;
 
+    /**
+       Used to create checkpointable handlers to notify the endpoint
+       when the SimpleNetwork sends or recieves a packet..  The
+       callback function is expected to be in the form of:
+
+         bool func(int vn)
+
+       In which case, the class is created with:
+
+         new SimpleNetwork::Handler2<classname, &classname::function_name>(this)
+
+       Or, to add static data, the callback function is:
+
+         bool func(int vn, dataT data)
+
+       and the class is created with:
+
+         new SimpleNetwork::Handler<classname, &classname::function_name, dataT>(this, data)
+
+       In both cases, the boolean that's returned indicates whether
+       the handler should be kept in the list or not.  On return
+       of true, the handler will be kept.  On return of false, the
+       handler will be removed from the clock list.
+    */
+    template <typename classT, auto funcT, typename dataT = void>
+    using Handler2 = SSTHandler2<bool, int, classT, dataT, funcT>;
+
 
 public:
     /** Constructor, designed to be used via 'loadUserSubComponent or loadAnonymousSubComponent'. */
     SimpleNetwork(SST::ComponentId_t id) : SubComponent(id) {}
 
+    SimpleNetwork() : SubComponent() {} // For serialization
+
     /**
      * Sends a network request during untimed phases (init() and
      * complete()).
@@ -318,6 +347,9 @@ class SimpleNetwork : public SubComponent
      * @return Link bandwidth of associated link
      */
     virtual const UnitAlgebra& getLinkBW() const = 0;
+
+    void serialize_order(SST::Core::Serialization::serializer& ser) override { SubComponent::serialize_order(ser); }
+    ImplementVirtualSerializable(SST::Interfaces::SimpleNetwork)
 };
 
 } // namespace SST::Interfaces

src/sst/core/interfaces/stdMem.h

@@ -98,9 +98,24 @@ class StandardMem : public SubComponent
     template <typename classT, typename dataT = void>
     using Handler = SSTHandler<void, Request*, classT, dataT>;
 
-    // /**
-    //    New style (checkpointable) SSTHandler
-    // */
+    /**
+       Used to create checkpointable handlers for request handling.
+       The callback function is expected to be in the form of:
+
+         void func(Request* event)
+
+       In which case, the class is created with:
+
+         new StdMem::Handler<classname, &classname::function_name>(this)
+
+       Or, to add static data, the callback function is:
+
+         void func(Request* event, dataT data)
+
+       and the class is created with:
+
+         new stdMem::Handler<classname, &classname::function_name, dataT>(this, data)
+     */
     template <typename classT, auto funcT, typename dataT = void>
     using Handler2 = SSTHandler2<void, Request*, classT, dataT, funcT>;
 

src/sst/core/oneshot.h

@@ -38,7 +38,7 @@ class OneShot : public Action
     using HandlerBase = SSTHandlerBaseNoArgs<void>;
 
     /**
-       Used to create handlers for clock.  The callback function is
+       Used to create handlers for OneShot.  The callback function is
        expected to be in the form of:
 
          void func()
@@ -58,6 +58,27 @@ class OneShot : public Action
     template <typename classT, typename dataT = void>
     using Handler = SSTHandlerNoArgs<void, classT, dataT>;
 
+    /**
+       Used to create checkpointable handlers for OneShot.  The callback function is
+       expected to be in the form of:
+
+         void func()
+
+       In which case, the class is created with:
+
+         new OneShot::Handler2<classname, &classname::function_name>(this)
+
+       Or, to add static data, the callback function is:
+
+         void func(dataT data)
+
+       and the class is created with:
+
+         new OneShot::Handler2<classname, &classname::function_name, dataT>(this, data)
+     */
+    template <typename classT, auto funcT, typename dataT = void>
+    using Handler2 = SSTHandler2<void, void, classT, dataT, funcT>;
+
 
     /////////////////////////////////////////////////
 

src/sst/core/ssthandler.h

@@ -1129,7 +1129,9 @@ using SSTHandlerBaseNoArgs = SSTHandlerBase<returnT, void>;
  * Handler class with user-data argument
  */
 template <typename returnT, typename argT, typename classT, typename dataT = void>
-class SSTHandler : public SSTHandlerBase<returnT, argT>
+class [[deprecated(
+    "Handler has been deprecated.  Please use Handler2 instead as it supports checkpointing")]] SSTHandler :
+    public SSTHandlerBase<returnT, argT>
 {
 private:
     using PtrMember = returnT (classT::*)(argT, dataT);
@@ -1163,7 +1165,8 @@ class SSTHandler : public SSTHandlerBase<returnT, argT>
  * Event Handler class with no user-data.
  */
 template <typename returnT, typename argT, typename classT>
-class SSTHandler<returnT, argT, classT, void> : public SSTHandlerBase<returnT, argT>
+class [[deprecated("Handler has been deprecated.  Please use Handler2 instead as it supports "
+                   "checkpointing")]] SSTHandler<returnT, argT, classT, void> : public SSTHandlerBase<returnT, argT>
 {
 private:
     using PtrMember = returnT (classT::*)(argT);
@@ -1191,7 +1194,9 @@ class SSTHandler<returnT, argT, classT, void> : public SSTHandlerBase<returnT, a
  * Event Handler class with user-data argument
  */
 template <typename returnT, typename classT, typename dataT = void>
-class SSTHandlerNoArgs : public SSTHandlerBaseNoArgs<returnT>
+class [[deprecated(
+    "Handler has been deprecated.  Please use Handler2 instead as it supports checkpointing")]] SSTHandlerNoArgs :
+    public SSTHandlerBaseNoArgs<returnT>
 {
 private:
     using PtrMember = returnT (classT::*)(dataT);
@@ -1225,7 +1230,8 @@ class SSTHandlerNoArgs : public SSTHandlerBaseNoArgs<returnT>
  * Event Handler class with no user-data.
  */
 template <typename returnT, typename classT>
-class SSTHandlerNoArgs<returnT, classT, void> : public SSTHandlerBaseNoArgs<returnT>
+class [[deprecated("Handler has been deprecated.  Please use Handler2 instead as it supports "
+                   "checkpointing")]] SSTHandlerNoArgs<returnT, classT, void> : public SSTHandlerBaseNoArgs<returnT>
 {
 private:
     using PtrMember = returnT (classT::*)();

src/sst/core/statapi/statbase.cc

@@ -198,58 +198,6 @@ StatisticBase::operator==(StatisticBase& check_stat)
     return (getFullStatName() == check_stat.getFullStatName());
 }
 
-// GV_TODO: Potentially remove this. It doesn't work as intended and delays should be user-set, not component-set
-void
-StatisticBase::delayOutput(const char* delay_time)
-{
-    // Make sure only a single output delay is active
-    if ( false == info_->output_delayed_ ) {
-
-        // Save the Stat Output Enable setting and then disable the output
-        info_->saved_output_enabled_ = info_->output_enabled_;
-        info_->output_enabled_       = false;
-        info_->output_delayed_       = true;
-
-        Simulation_impl::getSimulation()->registerOneShot(
-            delay_time, new OneShot::Handler<StatisticBase>(this, &StatisticBase::delayOutputExpiredHandler),
-            STATISTICCLOCKPRIORITY);
-    }
-}
-
-// GV_TODO: Potentially remove this. It doesn't work as intended and delays should be user-set, not component-set
-void
-StatisticBase::delayCollection(const char* delay_time)
-{
-    // Make sure only a single collection delay is active
-    if ( false == info_->collection_delayed_ ) {
-
-        // Save the Stat Enable setting and then disable the Stat for collection
-        info_->saved_stat_enabled_ = info_->stat_enabled_;
-        info_->stat_enabled_       = false;
-        info_->collection_delayed_ = true;
-
-        Simulation_impl::getSimulation()->registerOneShot(
-            delay_time, new OneShot::Handler<StatisticBase>(this, &StatisticBase::delayCollectionExpiredHandler),
-            STATISTICCLOCKPRIORITY);
-    }
-}
-
-void
-StatisticBase::delayOutputExpiredHandler()
-{
-    // Restore the Output Enable to its stored value
-    info_->output_enabled_ = info_->saved_output_enabled_;
-    info_->output_delayed_ = false;
-}
-
-void
-StatisticBase::delayCollectionExpiredHandler()
-{
-    // Restore the Statistic Enable to its stored value
-    info_->stat_enabled_       = info_->saved_stat_enabled_;
-    info_->collection_delayed_ = false;
-}
-
 void
 StatisticBase::serialize_order(SST::Core::Serialization::serializer& ser)
 {

src/sst/core/statapi/statbase.h

@@ -171,17 +171,6 @@ class StatisticBase
     /** Return the collection mode that is registered */
     StatMode_t getRegisteredCollectionMode() const { return info_->registered_collection_mode_; }
 
-    // Delay Methods (Uses OneShot to disable Statistic or Collection)
-    /** Delay the statistic from outputting data for a specified delay time
-     * @param delay_time - Value in UnitAlgebra format for delay (i.e. 10ns).
-     */
-    void delayOutput(const char* delay_time);
-
-    /** Delay the statistic from collecting data for a specified delay time.
-     * @param delayTime - Value in UnitAlgebra format for delay (i.e. 10ns).
-     */
-    void delayCollection(const char* delay_time);
-
     // Status of Statistic
     /** Indicate that the Statistic is Ready to be used */
     virtual bool isReady() const { return true; }
@@ -258,10 +247,6 @@ class StatisticBase
 
     void checkEventForOutput();
 
-    // OneShot Callbacks:
-    void delayOutputExpiredHandler();     // Enable Output in handler
-    void delayCollectionExpiredHandler(); // Enable Collection in Handler
-
     const StatisticGroup* getGroup() const { return info_->group_; }
     void                  setGroup(const StatisticGroup* group) { info_->group_ = group; }
 

src/sst/core/statapi/statengine.cc

@@ -185,8 +185,9 @@ StatisticProcessingEngine::finalizeInitialization()
         if ( g.outputFreq.getValue() != 0 ) {
             Simulation_impl::getSimulation()->registerClock(
                 g.outputFreq,
-                new Clock::Handler<StatisticProcessingEngine, StatisticGroup*>(
-                    this, &StatisticProcessingEngine::handleGroupClockEvent, &g),
+                new Clock::Handler2<
+                    StatisticProcessingEngine, &StatisticProcessingEngine::handleGroupClockEvent, StatisticGroup*>(
+                    this, &g),
                 STATISTICCLOCKPRIORITY);
         }
     }
@@ -304,8 +305,9 @@ StatisticProcessingEngine::addPeriodicBasedStatistic(const UnitAlgebra& freq, St
         if ( 0 != freq.getValue() ) {
 
             // This tcFactor is not found in the map, so create a new clock handler.
-            ClockHandler = new Clock::Handler<StatisticProcessingEngine, SimTime_t>(
-                this, &StatisticProcessingEngine::handleStatisticEngineClockEvent, tcFactor);
+            ClockHandler = new Clock::Handler2<
+                StatisticProcessingEngine, &StatisticProcessingEngine::handleStatisticEngineClockEvent, SimTime_t>(
+                this, tcFactor);
 
             // Set the clock priority so that normal clocks events will occur before
             // this clock event.
@@ -357,8 +359,9 @@ StatisticProcessingEngine::setStatisticStartTime(StatisticBase* stat)
         // See if the map contains an entry for this factor
         if ( m_StartTimeMap.find(tcFactor) == m_StartTimeMap.end() ) {
             // This tcFactor is not found in the map, so create a new OneShot handler.
-            OneShot::HandlerBase* OneShotHandler = new OneShot::Handler<StatisticProcessingEngine, SimTime_t>(
-                this, &StatisticProcessingEngine::handleStatisticEngineStartTimeEvent, tcFactor);
+            OneShot::HandlerBase* OneShotHandler = new OneShot::Handler2<
+                StatisticProcessingEngine, &StatisticProcessingEngine::handleStatisticEngineStartTimeEvent, SimTime_t>(
+                this, tcFactor);
 
             // Set the OneShot priority so that normal events will occur before this event.
             sim->registerOneShot(startTime, OneShotHandler, STATISTICCLOCKPRIORITY);
@@ -393,8 +396,9 @@ StatisticProcessingEngine::setStatisticStopTime(StatisticBase* stat)
         // See if the map contains an entry for this factor
         if ( m_StopTimeMap.find(tcFactor) == m_StopTimeMap.end() ) {
             // This tcFactor is not found in the map, so create a new OneShot handler.
-            OneShot::HandlerBase* OneShotHandler = new OneShot::Handler<StatisticProcessingEngine, SimTime_t>(
-                this, &StatisticProcessingEngine::handleStatisticEngineStopTimeEvent, tcFactor);
+            OneShot::HandlerBase* OneShotHandler = new OneShot::Handler2<
+                StatisticProcessingEngine, &StatisticProcessingEngine::handleStatisticEngineStopTimeEvent, SimTime_t>(
+                this, tcFactor);
 
             // Set the OneShot priority so that normal events will occur before this event.
             sim->registerOneShot(stopTime, OneShotHandler, STATISTICCLOCKPRIORITY);

src/sst/core/testElements/coreTest_ClockerComponent.cc

@@ -30,26 +30,27 @@ coreTestClockerComponent::coreTestClockerComponent(ComponentId_t id, Params& par
 
     // set our Main Clock
     registerClock(
-        clock_frequency_str, new Clock::Handler<coreTestClockerComponent>(this, &coreTestClockerComponent::tick));
+        clock_frequency_str, new Clock::Handler2<coreTestClockerComponent, &coreTestClockerComponent::tick>(this));
 
     // Set some other clocks
     // Second Clock (5ns)
     std::cout << "REGISTER CLOCK #2 at 5 ns" << std::endl;
     registerClock(
         "5 ns",
-        new Clock::Handler<coreTestClockerComponent, uint32_t>(this, &coreTestClockerComponent::Clock2Tick, 222));
+        new Clock::Handler2<coreTestClockerComponent, &coreTestClockerComponent::Clock2Tick, uint32_t>(this, 222));
 
     // Third Clock (15ns)
     std::cout << "REGISTER CLOCK #3 at 15 ns" << std::endl;
     Clock3Handler =
-        new Clock::Handler<coreTestClockerComponent, uint32_t>(this, &coreTestClockerComponent::Clock3Tick, 333);
+        new Clock::Handler2<coreTestClockerComponent, &coreTestClockerComponent::Clock3Tick, uint32_t>(this, 333);
     tc = registerClock("15 ns", Clock3Handler);
 
     // Create the OneShot Callback Handlers
-    callback1Handler = new OneShot::Handler<coreTestClockerComponent, uint32_t>(
-        this, &coreTestClockerComponent::Oneshot1Callback, 456);
+    callback1Handler =
+        new OneShot::Handler2<coreTestClockerComponent, &coreTestClockerComponent::Oneshot1Callback, uint32_t>(
+            this, 456);
     callback2Handler =
-        new OneShot::Handler<coreTestClockerComponent>(this, &coreTestClockerComponent::Oneshot2Callback);
+        new OneShot::Handler2<coreTestClockerComponent, &coreTestClockerComponent::Oneshot2Callback>(this);
 }
 
 coreTestClockerComponent::coreTestClockerComponent() : Component(-1)

src/sst/core/testElements/coreTest_DistribComponent.cc

@@ -103,7 +103,7 @@ coreTestDistribComponent::coreTestDistribComponent(ComponentId_t id, Params& par
     }
 
     // set our clock
-    registerClock("1GHz", new Clock::Handler<coreTestDistribComponent>(this, &coreTestDistribComponent::tick));
+    registerClock("1GHz", new Clock::Handler2<coreTestDistribComponent, &coreTestDistribComponent::tick>(this));
 }
 
 coreTestDistribComponent::coreTestDistribComponent() : Component(-1)

src/sst/core/testElements/coreTest_Links.cc

@@ -36,10 +36,10 @@ coreTestLinks::coreTestLinks(ComponentId_t id, Params& params) : Component(id),
     // configure out links
     E = configureLink(
         "Elink", link_tb.toString(),
-        new Event::Handler<coreTestLinks, std::string>(this, &coreTestLinks::handleEvent, "East"));
+        new Event::Handler2<coreTestLinks, &coreTestLinks::handleEvent, std::string>(this, "East"));
     W = configureLink(
         "Wlink", link_tb.toString(),
-        new Event::Handler<coreTestLinks, std::string>(this, &coreTestLinks::handleEvent, "West"));
+        new Event::Handler2<coreTestLinks, &coreTestLinks::handleEvent, std::string>(this, "West"));
 
     if ( found_sendlat ) {
         E->addSendLatency(1, send_lat.toString());
@@ -52,7 +52,7 @@ coreTestLinks::coreTestLinks(ComponentId_t id, Params& params) : Component(id),
     }
 
     // set our clock
-    registerClock("100 MHz", new Clock::Handler<coreTestLinks>(this, &coreTestLinks::clockTic));
+    registerClock("100 MHz", new Clock::Handler2<coreTestLinks, &coreTestLinks::clockTic>(this));
 }
 
 // incoming events are scanned and deleted