baseComponent.h

// Copyright 2009-2026 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2026, 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_BASECOMPONENT_H
#define SST_CORE_BASECOMPONENT_H
 
#include "sst/core/clock.h"
#include "sst/core/componentInfo.h"
#include "sst/core/eli/elementinfo.h"
#include "sst/core/event.h"
#include "sst/core/factory.h"
#include "sst/core/portModule.h"
#include "sst/core/profile/componentProfileTool.h"
#include "sst/core/serialization/serializable_base.h"
#include "sst/core/serialization/serialize.h"
#include "sst/core/sst_types.h"
#include "sst/core/statapi/statbase.h"
#include "sst/core/statapi/statengine.h"
#include "sst/core/timeConverter.h"
#include "sst/core/warnmacros.h"
 
#include <cstdarg>
#include <cstdint>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
using namespace SST::Statistics;
 
namespace SST {
 
class Component;
class ComponentExtension;
class Clock;
class Link;
class LinkMap;
class Module;
class Params;
class Simulation;
class Simulation;
class SubComponent;
class SubComponentSlotInfo;
class TimeConverter;
class UnitAlgebra;
class WatchPoint;
 
namespace Core::Serialization::pvt {
class SerializeBaseComponentHelper;
}
 
namespace pvt {
 
/**
   Extracts the owning class from a pointer-to-member-function type.
   Used to infer classT for the registerClock()/registerOrderedClock()
   and configureLink()/configureSelfLink() overloads that only require
   funcT to be specified explicitly.
*/
template <typename T>
struct member_function_class;
 
template <typename classT, typename returnT, typename... Args>
struct member_function_class<returnT (classT::*)(Args...)>
{
    using type = classT;
};
 
template <auto funcT>
using member_function_class_t = typename member_function_class<decltype(funcT)>::type;
 
/**
   Restricts the handler-building overloads to calls where obj points to the class that owns funcT (or a class derived
   from it). This keeps a string-literal timebase from being deduced as obj in the metadata overloads, and allows
   handlers inherited from a base class.
*/
template <auto funcT, typename objT>
using enable_if_handler_obj_t = std::enable_if_t<std::is_base_of_v<member_function_class_t<funcT>, objT>, int>;
 
} // namespace pvt
 
 
/**
 * Main component object for the simulation.
 */
class BaseComponent : public SST::Core::Serialization::serializable_base
{
 
    friend class Component;
    friend class ComponentExtension;
    friend class ComponentInfo;
    friend class SubComponent;
    friend class SubComponentSlotInfo;
    friend class PortModule;
 
protected:
    using StatCreateFunction = std::function<Statistics::StatisticBase*(BaseComponent*,
        Statistics::StatisticProcessingEngine*, const std::string& /*name*/, const std::string& /*sub_id*/, Params&)>;
 
    BaseComponent() = default; // For serialization only
 
public:
    explicit BaseComponent(ComponentId_t id);
    virtual ~BaseComponent();
 
    BaseComponent(const BaseComponent&)            = delete;
    BaseComponent& operator=(const BaseComponent&) = delete;
 
    /**
       Gets the ELI type for this BaseComponent
 
       @return ELI type as a string
    */
    const std::string& getType() const { return my_info_->getType(); }
 
    /**
       Get the unique component ID
 
       @return ID of BaseComponent
    */
    inline ComponentId_t getId() const { return my_info_->id_; }
 
    /**
       Get the BaseComponent Statistic load level
 
       @return Statistic load level of BaseComponent
    */
    inline uint8_t getStatisticLoadLevel() const { return my_info_->statLoadLevel; }
 
    /**
       Called when SIGINT or SIGTERM has been seen.  Allows components opportunity to clean up external state.
    */
    virtual void emergencyShutdown() {}
 
    /**
       Get the name of the BaseComponent
 
       @return BaseComponent's name
    */
    inline const std::string& getName() const { return my_info_->getName(); }
 
    /**
       Get the name of the parent Component for the Component tree. If called on a Component, returns the name of that
       Component.
 
       @return The name of the parent Component for the Component tree.
    */
    inline const std::string& getParentComponentName() const { return my_info_->getParentComponentName(); }
 
    /**
       Used during the init phase.  The method will be called each phase of initialization.  Initialization ends when no
       components have sent any data.
 
       @param phase Current phase number
    */
    virtual void init(unsigned int UNUSED(phase)) {}
 
    /**
       Used during the complete phase after the end of simulation.  The method will be called each phase of
       complete. Complete phase ends when no components have sent any data.
 
       @param phase Current phase number
    */
    virtual void complete(unsigned int UNUSED(phase)) {}
 
    /**
       Called after all components have been constructed and initialization has completed, but before simulation time
       has begun.
    */
    virtual void setup() {}
 
    /**
       Called after complete phase, but before objects are destroyed. A good place to print out statistics.
    */
    virtual void finish() {}
 
    /** Currently unused function */
    virtual bool Status() { return 0; }
 
    /**
       Called by the Simulation to request that the component print its current status.  Useful for debugging.
 
       @param out The Output class which should be used to print component status.
     */
    virtual void printStatus(Output& UNUSED(out)) {}
 
    /**
       Get the core timebase
 
       @return Core timebase set at the beginning of the simulation.  Returned as a UnitAlgebra
    */
    UnitAlgebra getCoreTimeBase() const;
 
    /**
       Get the current simulation time as a cycle count
 
       @return Current simulation cycle for the simulation
    */
    SimTime_t getCurrentSimCycle() const;
 
    /**
       Get the current priority
 
       @return Current priority for the simulation
    */
    int getCurrentPriority() const;
 
    /**
       get the elapsed simulation time as a UnitAlgebra
 
       @return Time in seconds as a UnitAlgebra
    */
    UnitAlgebra getElapsedSimTime() const;
 
    /**
       Get the end simulation time as a cycle count
 
       @return End simulation time as cycle count
    */
    SimTime_t getEndSimCycle() const;
 
    /**
       Get the end simulation time as a UnitAlgebra
 
       @return End time in seconds as a UnitAlgebra
    */
    UnitAlgebra getEndSimTime() const;
 
    /**
       Get this instance's parallel rank
 
       @return Get the rank for this objects partition
    */
    RankInfo getRank() const;
 
    /**
       Get the number of parallel ranks in the simulation
 
       @return Number of ranks in simulation
    */
    RankInfo getNumRanks() const;
 
    /**
       Get the default simulation Output class instance.  Elements do not have to use this Output object and can create
       their own to use instead.
 
       @return Default Output object for this partition
    */
    static Output& getSimulationOutput();
 
    /**
       Return the simulated time since the simulation began in the default timebase
 
       @return Current simulation time in units of the default timebase for the object
    */
    inline SimTime_t getCurrentSimTime() const { return getCurrentSimTime(my_info_->defaultTimeBase); }
 
    /**
       Get the simulated time since the simulation began in units specified by
       the parameter.
 
       @param tc TimeConverter specifying the units
 
       @return Current time as a cycle count based on the provided timebase
    */
    SimTime_t getCurrentSimTime(TimeConverter base) const;
 
    /**
       Return the simulated time since the simulation began in the specified timebase.
 
       NOTE: This version of getCurrentSimTime() can accept a timebase that is not normally representable because it is
       smaller than the global timebase set by the user. If this happens, the underlying code will use UnitAlgebra to
       compute the cycle count.  Because UnitAlgebra is computationally intense, it is best to avoid this case during
       the run loop of the simulation.
 
       @param base Timebase frequency in SI Units
 
       @return Current time as a cycle count based on the provided timebase
 
    */
    SimTime_t getCurrentSimTime(const std::string& base) const;
 
    /**
       Return the simulated time since the simulation began in the specified timebase
 
       NOTE: This version of getCurrentSimTime() exists because both std::string and TimeConverter can be implicitly
       created with a const char*.  Having this implementation removes ambiguity and ensures that a const char* is
       passed through the std::string version, which can accept timebases that are not representable with TimeConverter
       due to being smaller than the global timebase.
 
       @param base Timebase frequency in SI Units
 
       @return Current time as a cycle count based on the provided timebase
    */
    SimTime_t getCurrentSimTime(const char* base) const { return getCurrentSimTime(std::string(base)); }
 
    /**
       Utility function to return the time since the simulation began in nanoseconds
 
       @return Current time as a count of nanoseconds expired in the simulation
    */
    SimTime_t getCurrentSimTimeNano() const;
 
    /**
       Utility function to return the time since the simulation began in microseconds
 
       @return Current time as a count of microseconds expired in the simulation
    */
    SimTime_t getCurrentSimTimeMicro() const;
 
    /**
       Utility function to return the time since the simulation began in milliseconds
 
       @return Current time as a count of milliseconds expired in the simulation
    */
    SimTime_t getCurrentSimTimeMilli() const;
 
    /**
       Get the amount of real-time spent executing the run phase of the simulation.
 
      @return Real time in seconds spent executing the run phase
    */
    double getRunPhaseElapsedRealTime() const;
 
    /**
       Get the amount of real-time spent executing the init phase of the simulation.
 
      @return Real time in seconds spent executing the init phase
    */
    double getInitPhaseElapsedRealTime() const;
 
    /**
       Get the amount of real-time spent executing the complete phase of the simulation.
 
       @return Real time in seconds spent executing the complete phase
    */
    double getCompletePhaseElapsedRealTime() const;
 
 
    /**
       Add a watch point to all handlers in the Component Tree
    */
    void addWatchPoint(WatchPoint* pt);
 
    /**
       Remove a watch point from all handlers in the Component Tree
    */
    void removeWatchPoint(WatchPoint* pt);
 
 
private:
    /**
       Recursively add Watch point to myself and all my children
    */
    void addWatchPointRecursive(WatchPoint* pt);
 
    /**
       Recursively removes a Watch point from myself and all my children
    */
    void removeWatchPointRecursive(WatchPoint* pt);
 
    /**
       This function is called by ComponentInfo after all SubComponents have been serialized.  Currently only Component
       uses this functionality to make sure SubComponents are serialized before serializing any ordered clock handlers.
    */
    virtual void serialize_final(SST::Core::Serialization::serializer& ser);
 
 
protected:
    /**
       Check to see if the run mode was set to INIT
 
       @return True if simulation run mode is set to INIT
    */
    bool isSimulationRunModeInit() const;
 
    /**
       Check to see if the run mode was set to RUN
 
       @return True if simulation run mode is set to RUN
    */
    bool isSimulationRunModeRun() const;
 
    /**
       Check to see if the run mode was set to BOTH
 
       @return True if simulation run mode is set to BOTH
    */
    bool isSimulationRunModeBoth() const;
 
    /**
       Returns the output directory of the simulation
 
        @return Directory in which simulation outputs should be placed.  Returns empty string if output directory not
        set by user.
     */
    std::string& getOutputDirectory() const;
 
    /**
       Signifies that a library is required for this simulation.  Causes the Factory to verify that the required library
       is loaded.
 
       NOTE: This function should rarely be required, as most dependencies are automatically detected in the simulator
       core.  However, if the component uses an event from another library that is not wholly defined in a header file,
       this call may be required to ensure that all the code from the event is loaded.  Similarly, if you use a class
       from another library that does not have ELI information, this call may also be required to make sure all
       dependencies are loaded.
 
       @param name Name of library this BaseComponent depends on
    */
    void requireLibrary(const std::string& name);
 
 
    /**
       Determine if a port name is connected to any links
 
       @param name Name of the port
 
       @return True if port is connected, false otherwise
    */
    bool isPortConnected(const std::string& name) const;
 
    /**
       Configure a Link
 
       @param name Port Name on which the link to configure is attached.
 
       @param timebase Timebase of the link provided as either a std::string, SST::UnitAlgebra, or
       SST::TimeConverter
 
       @param handler Optional Handler to be called when an Event is received
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    Link* configureLink(const std::string& name, TimeConverter timebase, Event::HandlerBase* handler = nullptr)
    {
        return configureLink_impl(name, timebase.getFactor(), handler);
    }
 
    /**
       Configure a Link
 
       @param name Port Name on which the link to configure is attached.
 
       @param handler Optional Handler to be called when an Event is received
 
       @return A pointer to the configured link, or nullptr if an error occurred.
     */
    Link* configureLink(const std::string& name, Event::HandlerBase* handler = nullptr);
 
    /**
       Configure a Link. This version builds the Event::Handler internally, so only funcT needs to be specified
       explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param name Port Name on which the link to configure is attached.
 
       @param timebase Timebase of the link provided as either a std::string, SST::UnitAlgebra, or
       SST::TimeConverter
 
       @param obj Pointer to object that the handler function should be called on
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureLink(const std::string& name, TimeConverter timebase, objT* obj)
    {
        auto* handler = new Event::Handler<pvt::member_function_class_t<funcT>, funcT, void>(obj);
        Link* link    = configureLink(name, timebase, handler);
        if ( nullptr == link ) delete handler;
        return link;
    }
 
    /**
       Configure a Link with metadata. This version builds the Event::Handler internally, so only funcT and dataT
       need to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param name Port Name on which the link to configure is attached.
 
       @param timebase Timebase of the link provided as either a std::string, SST::UnitAlgebra, or
       SST::TimeConverter
 
       @param obj Pointer to object that the handler function should be called on
 
       @param data Metadata to associate with the handler
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureLink(const std::string& name, TimeConverter timebase, objT* obj, dataT data)
    {
        auto* handler = new Event::Handler<pvt::member_function_class_t<funcT>, funcT, dataT>(obj, data);
        Link* link    = configureLink(name, timebase, handler);
        if ( nullptr == link ) delete handler;
        return link;
    }
 
    /**
       Configure a Link using the component's default timebase. This version builds the Event::Handler internally,
       so only funcT needs to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param name Port Name on which the link to configure is attached.
 
       @param obj Pointer to object that the handler function should be called on
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureLink(const std::string& name, objT* obj)
    {
        auto* handler = new Event::Handler<pvt::member_function_class_t<funcT>, funcT, void>(obj);
        Link* link    = configureLink(name, handler);
        if ( nullptr == link ) delete handler;
        return link;
    }
 
    /**
       Configure a Link with metadata, using the component's default timebase. This version builds the
       Event::Handler internally, so only funcT and dataT need to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param name Port Name on which the link to configure is attached.
 
       @param obj Pointer to object that the handler function should be called on
 
       @param data Metadata to associate with the handler
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureLink(const std::string& name, objT* obj, dataT data)
    {
        auto* handler = new Event::Handler<pvt::member_function_class_t<funcT>, funcT, dataT>(obj, data);
        Link* link    = configureLink(name, handler);
        if ( nullptr == link ) delete handler;
        return link;
    }
 
    /**
       Configure a SelfLink  (Loopback link)
 
       @param name Name of the self-link port
 
       @param timebase Timebase of the link.  Timebase can be a std::string, SST::UnitAlgebra or SST::TimeConverter
 
       @param handler Optional Handler to be called when an Event is received
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    Link* configureSelfLink(const std::string& name, TimeConverter timebase, Event::HandlerBase* handler = nullptr)
    {
        addSelfLink(name);
        return configureLink(name, timebase, handler);
    }
 
 
    /**
       Configure a SelfLink (Loopback link) that uses the (Sub)Component's defaultTimeBase
 
       @param name Name of the self-link port
 
       @param handler Optional Handler to be called when an Event is received
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    Link* configureSelfLink(const std::string& name, Event::HandlerBase* handler = nullptr);
 
    /**
       Configure a SelfLink (Loopback link). This version builds the Event::Handler internally, so only funcT needs
       to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param name Name of the self-link port
 
       @param timebase Timebase of the link.  Timebase can be a std::string, SST::UnitAlgebra or SST::TimeConverter
 
       @param obj Pointer to object that the handler function should be called on
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureSelfLink(const std::string& name, TimeConverter timebase, objT* obj)
    {
        addSelfLink(name);
        return configureLink<funcT>(name, timebase, obj);
    }
 
    /**
       Configure a SelfLink (Loopback link) with metadata. This version builds the Event::Handler internally, so
       only funcT and dataT need to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param name Name of the self-link port
 
       @param timebase Timebase of the link.  Timebase can be a std::string, SST::UnitAlgebra or SST::TimeConverter
 
       @param obj Pointer to object that the handler function should be called on
 
       @param data Metadata to associate with the handler
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureSelfLink(const std::string& name, TimeConverter timebase, objT* obj, dataT data)
    {
        addSelfLink(name);
        return configureLink<funcT, dataT>(name, timebase, obj, data);
    }
 
    /**
       Configure a SelfLink (Loopback link) that uses the (Sub)Component's defaultTimeBase. This version builds the
       Event::Handler internally, so only funcT needs to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param name Name of the self-link port
 
       @param obj Pointer to object that the handler function should be called on
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureSelfLink(const std::string& name, objT* obj)
    {
        addSelfLink(name);
        return configureLink<funcT>(name, obj);
    }
 
    /**
       Configure a SelfLink (Loopback link) with metadata, that uses the (Sub)Component's defaultTimeBase. This
       version builds the Event::Handler internally, so only funcT and dataT need to be specified explicitly.
 
       @tparam funcT Function that should be called by the Event::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param name Name of the self-link port
 
       @param obj Pointer to object that the handler function should be called on
 
       @param data Metadata to associate with the handler
 
       @return A pointer to the configured link, or nullptr if an error occurred.
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Link* configureSelfLink(const std::string& name, objT* obj, dataT data)
    {
        addSelfLink(name);
        return configureLink<funcT, dataT>(name, obj, data);
    }
 
 
    /**
       Registers a clock for this component.
 
       @param tc TimeConverter object specifying the clock frequency.  May be specified as a TimeConverter, std::string
       or UnitAlgebra
 
       @param handler Pointer to Clock::HandlerBase which is to be invoked at the specified interval
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @return The TimeConverter object representing the clock frequency
    */
    TimeConverter registerClock(TimeConverter tc, Clock::HandlerBase* handler, bool reg_all = true);
 
    /**
       Removes a clock handler from the component
 
       NOTE: This operation needs to search the list until it finds the specified handler, which can be a slow operation
       for long lists.  Consider using the return value from the clock handler to control whether a handler is removed
       from the list or not.
 
       @param tc TimeConverter representing the period of the clock
 
       @param handler Handler to remove from the list
    */
    void unregisterClock(TimeConverter tc, Clock::HandlerBase* handler);
 
    /**
       Reactivates an existing Clock and Handler
 
       @return Time of next time clock handler will fire
 
       Note: If called after the simulation run loop (e.g., in finish() or complete()), will return the next time of the
       clock past when the simulation ended. There can be a small lag between simulation end and detection of simulation
       end during which clocks can run a few extra cycles. As a result, the return value just prior to simulation end
       may be greater than the value returned after simulation end.
    */
    Cycle_t reregisterClock(TimeConverter freq, Clock::HandlerBase* handler);
 
 
    /**
       Registers a clock handler for this component.
 
       @tparam funcT Function that should be called by the Clock::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param tc TimeConverter object specifying the clock frequency.  May be specified as a TimeConverter, std::string
       or UnitAlgebra
 
       @param obj Pointer to object that the handler function should be called on
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @return The Clock::Handler object that encapsulates the function and object pointer
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Clock::HandlerBase* registerClock(TimeConverter tc, objT* obj, bool reg_all = true)
    {
        auto* handler = new Clock::Handler<pvt::member_function_class_t<funcT>, funcT, void>(obj);
        registerClock_impl(tc, handler, reg_all, false);
        return handler;
    }
 
    /**
       Registers a clock handler with metadata for this component.
 
       @tparam funcT Function that should be called by the Clock::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param tc TimeConverter object specifying the clock frequency.  May be specified as a TimeConverter, std::string
       or UnitAlgebra
 
       @param obj Pointer to object that the handler function should be called on
 
       @param metadata Metadata to associate with the handler
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @return The Clock::Handler object that encapsulates the function and object pointer
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Clock::HandlerBase* registerClock(TimeConverter tc, objT* obj, dataT metadata, bool reg_all = true)
    {
        auto* handler = new Clock::Handler<pvt::member_function_class_t<funcT>, funcT, dataT>(obj, metadata);
        registerClock_impl(tc, handler, reg_all, false);
        return handler;
    }
 
 
    /**
       Registers an ordered clock handler for this component. Active handlers registered with this function are
       guaranteed to always fire in the order they were registered, for a given clock frequency.
 
       @tparam funcT Function that should be called by the Clock::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @param tc TimeConverter object specifying the clock frequency.  May be specified as a TimeConverter, std::string
       or UnitAlgebra
 
       @param order Order clock should fire in relative to other clocks in the Component tree.  Lower orders fire before
       higher orders. Handlers with the same order will fire in the order they were registered,
 
       @param obj Pointer to object that the handler function should be called on
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @return The Clock::Handler object that encapsulates the function and object pointer
    */
    template <auto funcT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Clock::HandlerBase* registerOrderedClock(TimeConverter tc, uint16_t order, objT* obj, bool reg_all = true)
    {
        auto* handler = new Clock::Handler<pvt::member_function_class_t<funcT>, funcT, void>(obj);
        registerClock_impl(tc, handler, reg_all, true, order);
        return handler;
    }
 
    /**
       Registers an ordered clock handler with metadata for this component. Active handlers registered with this
       function are guaranteed to always fire in the order they were registered, for a given clock frequency.
 
       @tparam funcT Function that should be called by the Clock::Handler. Must be a member of classT (automatically
       inferred) and specified as &<classT>::<name_of_function>.
 
       @tparam dataT Type of metadata to be passed to the handler function
 
       @param tc TimeConverter object specifying the clock frequency.  May be specified as a TimeConverter, std::string
       or UnitAlgebra
 
       @param order Order clock should fire in relative to other clocks in the Component tree.  Lower orders fire before
       higher orders. Handlers with the same order will fire in the order they were registered,
 
       @param obj Pointer to object that the handler function should be called on
 
       @param metadata Metadata to associate with the handler
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @return The Clock::Handler object that encapsulates the function and object pointer
    */
    template <auto funcT, typename dataT, typename objT, pvt::enable_if_handler_obj_t<funcT, objT> = 0>
    Clock::HandlerBase* registerOrderedClock(
        TimeConverter tc, uint16_t order, objT* obj, dataT metadata, bool reg_all = true)
    {
        auto* handler = new Clock::Handler<pvt::member_function_class_t<funcT>, funcT, dataT>(obj, metadata);
        registerClock_impl(tc, handler, reg_all, true, order);
        return handler;
    }
 
 
    /**
       Returns the next Cycle that the TimeConverter would fire. If called prior to the simulation run loop, next Cycle
       is 0.  If called after the simulation run loop completes (e.g., during complete() or finish()), next Cycle is one
       past the end time of the simulation. See Note in reregisterClock() for additional guidance when calling this
       function after simulation ends.
 
       @param freq Frequency of the clock
 
       @return Cycle count that will be passed into the next call to this clock's handler functions
    */
    Cycle_t getNextClockCycle(TimeConverter freq);
 
    /**
       Registers a default timebase for the component and optionally
       sets the the component's links to that timebase. Useful for
       components which do not have a clock, but would like a default
       timebase.
 
       @param base Frequency for the clock in SI units
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
    */
    TimeConverter registerTimeBase(const std::string& base, bool reg_all = true);
 
    TimeConverter getTimeConverter(const std::string& base) const;
    TimeConverter getTimeConverter(const UnitAlgebra& base) const;
 
    bool isStatisticShared(const std::string& stat_name, bool include_me = false)
    {
        if ( include_me ) {
            if ( getStatisticValidityAndLevel(stat_name) != 255 ) {
                return true;
            }
        }
        if ( my_info_->sharesStatistics() ) {
            return my_info_->parent_info->component->isStatisticShared(stat_name, true);
        }
        else {
            return false;
        }
    }
 
    /**
       Tell the simulation object to initiate interactive mode (if currently turned on)
 
       @param msg Message to print when interactive mode is entered
    */
    void initiateInteractive(const std::string& msg);
 
private:
    ImplementSerializable(SST::BaseComponent)
    void serialize_order(SST::Core::Serialization::serializer& ser) override;
 
 
    /**
       Handles the profile points, default timebase, handler tracking and checkpointing.
 
       @param tc TimeConverter representing the period of the clock
 
       @param handler Handler to add to the list
 
       @param reg_all Should this clock period be used as the default timebase for all of the links connected to this
       component
 
       @param group Whether or not this clock is being registered with a group (i.e. is an ordered clock)
    */
    void registerClock_impl(
        TimeConverter tc, Clock::HandlerBase* handler, bool reg_all, bool group = false, uint16_t order = 0);
 
    /**
        Handles default timebase setup
 
        @param name Name of the port on which to configure the link
 
        @param timebase Default timebase for the Link
 
        @param handler Handler to call on event delivery.  If no handler is provided, this will be a polling link
    */
    Link* configureLink_impl(const std::string& name, SimTime_t timebase, Event::HandlerBase* handler = nullptr);
 
    /**
       Helper function used to create an enabled statistic. For explicitly-enabled statistics, this must be called on
       the parent component. For enable-all, it can be called on the enabling component.
 
       @param cpp_params Any parameters given in C++ specific to this statistic
 
       @param name The name (different from type) for this statistic
 
       @param stat_sub_id An optional sub ID for this statistic to differentiate instances of the same stat
 
       @return The statistic created
     */
    template <typename T>
    Statistics::Statistic<T>* createStatistic(
        SST::Params& params, StatisticId_t id, const std::string& name, const std::string& stat_sub_id)
    {
        /* I would prefer to avoid this std::function with dynamic cast,
         * but the code is just a lot cleaner and avoids many unnecessary template instantiations
         * doing it this way. At some point in the future, we would need to clean up
         * the rule around enabling all statistics to make this better
         *
         * Even if we moved the logic around, we'd still have to dyncast anything coming out of
         * the stat data structures.
         */
        StatCreateFunction create = [=](BaseComponent* comp, Statistics::StatisticProcessingEngine* engine,
                                        const std::string& name, const std::string& sub_id,
                                        SST::Params& params) -> Statistics::StatisticBase* {
            return engine->createStatistic<T>(comp, name, sub_id, params);
        };
 
        // We follow two distinct paths depending on if it is enable all, versus explicitly enabled
        // Enable all is "scoped" to the (sub)component
        // Explicitly enabled stats are assigned component-unique IDs and can be shared across subcomponents
        // so creation and management happens in the parent component
        Statistics::StatisticBase* base_stat =
            id == STATALL_ID ? createEnabledAllStatistic(params, name, stat_sub_id, std::move(create))
                             : getParentComponent()->createExplicitlyEnabledStatistic(
                                   params, id, name, stat_sub_id, std::move(create));
 
        // Ugh, dynamic casts hurt my eyes, but I must do this
        auto* statistic = dynamic_cast<Statistics::Statistic<T>*>(base_stat);
        if ( statistic ) {
            return statistic;
        }
        else {
            fatal(__LINE__, __FILE__, "createStatistic", 1, "failed to cast created statistic '%s' to expected type",
                name.c_str());
        }
    }
 
    /**
       Internal registration function for statistics. Determines if a statistic is enabled or not.
       It first locates the component that should "own" the stat based on both ELI and statistic enable parameters.
       If enabled, it calls createStatistic<T> on the owning component.
       If disabled, it returns a disabled statistic from the statistic engine.
    */
    template <typename T>
    Statistics::Statistic<T>* registerStatistic_impl(
        SST::Params& params, const std::string& stat_name, const std::string& stat_sub_id, uint8_t level = 255)
    {
        if ( level == 255 ) { // Stat has not yet been found in ELI, search this component's ELI
            level = getStatisticValidityAndLevel(stat_name);
        }
 
        if ( level == 255 ) {
            // If level is still 255, stat has not been found in any ELI yet, need to check if parent shares their ELI
            if ( my_info_->parent_info && my_info_->sharesStatistics() ) {
                return my_info_->parent_info->component->registerStatistic_impl<T>(params, stat_name, stat_sub_id);
            }
            else {
                // not a valid stat and I won't be able to share my parent's statistic
                fatal(__LINE__, __FILE__, "registerStatistic", 1,
                    "attempting to register a statistic '%s' that is not found in ELI", stat_name.c_str());
            }
        }
 
        // Path 1: Explicitly enabled statistic
        if ( my_info_->enabled_stat_names_ ) {
            auto iter = my_info_->enabled_stat_names_->find(stat_name);
            if ( iter != my_info_->enabled_stat_names_->end() ) {
                // valid, enabled statistic
                // During initialization, the component should have assigned a mapping between
                // the local name and globally unique stat ID
                StatisticId_t id = iter->second;
                return getParentComponent()->createStatistic<T>(params, id, stat_name, stat_sub_id);
            }
        }
 
        // Path 2: Enabled all statistic
        if ( my_info_->enabled_all_stats_ ) { // I enabled this stat and it is valid
            if ( level > getStatisticLoadLevel() ) {
                return getStatEngine()->createDisabledStatistic<T>();
            }
            return createStatistic<T>(params, STATALL_ID, stat_name, stat_sub_id);
        }
        else if ( my_info_->parent_info && my_info_->canInsertStatistics() ) {
            // I did not enable all but my parent may have and will accept my statistics
            return my_info_->parent_info->component->registerStatistic_impl<T>(params, stat_name, stat_sub_id, level);
        }
        else {
            // Not enabled
            return getStatEngine()->createDisabledStatistic<T>();
        }
    }
 
protected:
    /**
       Registers a statistic.
 
       If Statistic is allowed to run (controlled by Python runtime parameters), then a statistic will be created and
       returned. If not allowed to run, then a NullStatistic will be returned.  In either case, the returned value
       should be used for all future Statistic calls.  The type of Statistic and the Collection Rate is set by Python
       runtime parameters.  If no type is defined, then an Accumulator Statistic will be provided by default.  If rate
       set to 0 or not provided, then the statistic will output results only at end of sim (if output is enabled).
 
       @param params Parameter set to be passed to the statistic constructor.
 
       @param stat_name Primary name of the statistic.  This name must match the defined ElementInfoStatistic in the
       component, and must also be enabled in the Python input file.
 
       @param stat_sub_id An additional sub name for the statistic
 
       @return Either a created statistic of desired type or a NullStatistic depending upon runtime settings.
    */
    template <typename T>
    Statistics::Statistic<T>* registerStatistic(
        SST::Params& params, const std::string& stat_name, const std::string& stat_sub_id = "")
    {
        return registerStatistic_impl<T>(params, stat_name, stat_sub_id);
    }
 
    template <typename T>
    Statistics::Statistic<T>* registerStatistic(const std::string& stat_name, const std::string& stat_sub_id = "")
    {
        SST::Params empty {};
        return registerStatistic_impl<T>(empty, stat_name, stat_sub_id);
    }
 
    template <typename... Args>
    Statistics::Statistic<std::tuple<Args...>>* registerMultiStatistic(
        const std::string& stat_name, const std::string& stat_sub_id = "")
    {
        SST::Params empty {};
        return registerStatistic_impl<std::tuple<Args...>>(empty, stat_name, stat_sub_id);
    }
 
    template <typename... Args>
    Statistics::Statistic<std::tuple<Args...>>* registerMultiStatistic(
        SST::Params& params, const std::string& stat_name, const std::string& stat_sub_id = "")
    {
        return registerStatistic_impl<std::tuple<Args...>>(params, stat_name, stat_sub_id);
    }
 
    template <typename T>
    Statistics::Statistic<T>* registerStatistic(const char* stat_name, const char* stat_sub_id = "")
    {
        return registerStatistic<T>(std::string(stat_name), std::string(stat_sub_id));
    }
 
    /**
       Called by the Components and Subcomponent to perform a statistic Output.
 
       @param stat Pointer to the statistic.
    */
    void performStatisticOutput(Statistics::StatisticBase* stat);
 
    /**
       Performs a global statistic Output.
 
       This routine will force ALL Components and Subcomponents to output their statistic information.  This may lead to
       unexpected results if the statistic counts or data is reset on output.
 
       NOTE: Currently, this function will only output statistics that are on the same rank.
     */
    void performGlobalStatisticOutput();
 
    /**
       Registers a profiling point.
 
       This function will register a profiling point.
 
       @param point_name Name of point to register
 
       @return Either a pointer to a created T::ProfilePoint or nullptr if not enabled.
    */
    template <typename T>
    typename T::ProfilePoint* registerProfilePoint(const std::string& point_name)
    {
        std::string full_point_name = getType() + "." + point_name;
        auto        tools           = getComponentProfileTools(full_point_name);
        if ( tools.size() == 0 ) return nullptr;
 
        typename T::ProfilePoint* ret = new typename T::ProfilePoint();
        for ( auto* x : tools ) {
            T* tool = dynamic_cast<T*>(x);
            if ( nullptr == tool ) {
                //  Not the right type, fatal
                fatal(CALL_INFO_LONG, 1, "ERROR: wrong type of profiling tool for profiling point %s)\n",
                    point_name.c_str());
            }
            ret->registerProfilePoint(tool, point_name, getId(), getName(), getType());
        }
        return ret;
    }
 
    /**
       Loads a module from an element Library
 
       @param type Fully Qualified library.moduleName
 
       @param params Parameters the module should use for configuration
 
       @return Handle to new instance of module, or nullptr on failure.
    */
    template <class T, class... ARGS>
    T* loadModule(const std::string& type, Params& params, ARGS... args)
    {
        // Check to see if this can be loaded with new API or if we have to fallback to old
        return Factory::getFactory()->CreateWithParams<T>(type, params, params, args...);
    }
 
protected:
    // When you direct load, the ComponentExtension does not need any
    // ELI information and if it has any, it will be ignored.  The
    // extension will be loaded as if it were part of the parent
    // BaseComponent and will share all that components ELI
    // information.
    template <class T, class... ARGS>
    T* loadComponentExtension(ARGS... args)
    {
        ComponentExtension* ret = new T(my_info_->id_, args...);
        return static_cast<T*>(ret);
    }
 
    /**
       Check to see if a given element type is loadable with a particular API
 
       @param name Name of element to check in lib.name format
 
       @return True if loadable as the API specified as the template parameter
    */
    template <class T>
    bool isSubComponentLoadableUsingAPI(const std::string& type)
    {
        return Factory::getFactory()->isSubComponentLoadableUsingAPI<T>(type);
    }
 
    /**
       Check to see if the element type loaded by the user into the.
       specified slot is loadable with a particular API.  This will
       only check slot index 0.  If you need to check other slots,
       please use the SubComponentSlotInfo.
 
       @param slot_name Name of slot to check
 
       @return True if loadable as the API specified as the template parameter
    */
    template <class T>
    bool isUserSubComponentLoadableUsingAPI(const std::string& slot_name)
    {
        // Get list of ComponentInfo objects and make sure that there is
        // only one SubComponent put into this slot
        // const std::vector<ComponentInfo>& subcomps = my_info_->getSubComponents();
        const std::map<ComponentId_t, ComponentInfo>& subcomps  = my_info_->getSubComponents();
        int                                           sub_count = 0;
        int                                           index     = -1;
        for ( auto& ci : subcomps ) {
            if ( ci.second.getSlotName() == slot_name ) {
                index = ci.second.getSlotNum();
                sub_count++;
            }
        }
 
        if ( sub_count > 1 ) {
            SST::Output outXX("SubComponentSlotWarning: ", 0, 0, Output::STDERR);
            outXX.fatal(CALL_INFO, 1,
                "Error: ComponentSlot \"%s\" in component \"%s\" only allows for one SubComponent, %d provided.\n",
                slot_name.c_str(), my_info_->getType().c_str(), sub_count);
        }
 
        return isUserSubComponentLoadableUsingAPIByIndex<T>(slot_name, index);
    }
 
    /**
       Loads an anonymous subcomponent (not defined in input file to SST run).
 
       @param type type of subcomponent to load in lib.name format
 
       @param slot_name name of the slot to load subcomponent into
 
       @param slot_num  index of the slot to load subcomponent into
 
       @param share_flags Share flags to be used by subcomponent
 
       @param params Params object to be passed to subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <class T, class... ARGS>
    T* loadAnonymousSubComponent(const std::string& type, const std::string& slot_name, int slot_num,
        uint64_t share_flags, Params& params, ARGS... args)
    {
 
        share_flags             = share_flags & ComponentInfo::USER_FLAGS;
        ComponentId_t  cid      = my_info_->addAnonymousSubComponent(my_info_, type, slot_name, slot_num, share_flags);
        ComponentInfo* sub_info = my_info_->findSubComponent(cid);
 
        // This shouldn't happen since we just put it in, but just in case
        if ( sub_info == nullptr ) return nullptr;
 
        // Check to see if this can be loaded with new API or if we have to fallback to old
        if ( isSubComponentLoadableUsingAPI<T>(type) ) {
            auto ret = Factory::getFactory()->CreateWithParams<T>(type, params, sub_info->id_, params, args...);
            return ret;
        }
        return nullptr;
    }
 
    /**
       Loads a user defined subcomponent (defined in input file to SST run).  This version does not allow share flags
       (set to SHARE_NONE) or constructor arguments.
 
       @param slot_name name of the slot to load subcomponent into
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <class T>
    T* loadUserSubComponent(const std::string& slot_name)
    {
        return loadUserSubComponent<T>(slot_name, ComponentInfo::SHARE_NONE);
    }
 
    /**
       Loads a user defined subcomponent (defined in input file to SST
       run).
 
       @param slot_name name of the slot to load subcomponent into
 
       @param share_flags Share flags to be used by subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <class T, class... ARGS>
    T* loadUserSubComponent(const std::string& slot_name, uint64_t share_flags, ARGS... args)
    {
 
        // Get list of ComponentInfo objects and make sure that there is
        // only one SubComponent put into this slot
        // const std::vector<ComponentInfo>& subcomps = my_info_->getSubComponents();
        const std::map<ComponentId_t, ComponentInfo>& subcomps  = my_info_->getSubComponents();
        int                                           sub_count = 0;
        int                                           index     = -1;
        for ( auto& ci : subcomps ) {
            if ( ci.second.getSlotName() == slot_name ) {
                index = ci.second.getSlotNum();
                sub_count++;
            }
        }
 
        if ( sub_count > 1 ) {
            SST::Output outXX("SubComponentSlotWarning: ", 0, 0, Output::STDERR);
            outXX.fatal(CALL_INFO, 1,
                "Error: ComponentSlot \"%s\" in component \"%s\" only allows for one SubComponent, %d provided.\n",
                slot_name.c_str(), my_info_->getType().c_str(), sub_count);
        }
 
        return loadUserSubComponentByIndex<T, ARGS...>(slot_name, index, share_flags, args...);
    }
 
    /**
       Convenience function for reporting fatal conditions.  The function will create a new Output object and call
       fatal() using the supplied parameters.  Before calling Output::fatal(), the function will also print other
       information about the (sub)component that called fatal and about the simulation state.
 
       From Output::fatal: Message will be sent to the output location and to stderr.  The output will be prepended with
       the expanded prefix set in the object.
 
       NOTE: fatal() will call MPI_Abort(exit_code) to terminate simulation.
 
       @param line Line number of calling function (use CALL_INFO macro)
 
       @param file File name calling function (use CALL_INFO macro)
 
       @param func Function name calling function (use CALL_INFO macro)
 
       @param exit_code The exit code used for termination of simulation.  will be passed to MPI_Abort()
 
       @param format Format string.  All valid formats for printf are available.
 
       @param ... Arguments for format.
    */
    [[noreturn]]
    void fatal(uint32_t line, const char* file, const char* func, int exit_code, const char* format, ...) const
        __attribute__((format(printf, 6, 7)));
 
    /**
       Convenience function for testing for and reporting fatal conditions.  If the condition holds, fatal() will be
       called, otherwise, the function will return.  The function will create a new Output object and call fatal() using
       the supplied parameters.  Before calling Output::fatal(), the function will also print other information about
       the (sub)component that called fatal and about the simulation state.
 
       From Output::fatal: Message will be sent to the output location and to stderr.  The output will be prepended with
       the expanded prefix set in the object.  NOTE: fatal() will call MPI_Abort(exit_code) to terminate simulation.
 
 
       @param condition on which to call fatal(); fatal() is called if the bool is false.
 
       @param line Line number of calling function (use CALL_INFO macro)
 
       @param file File name calling function (use CALL_INFO macro)
 
       @param func Function name calling function (use CALL_INFO macro)
 
       @param exit_code The exit code used for termination of simulation.  will be passed to MPI_Abort()
 
       @param format Format string.  All valid formats for printf are available.
 
       @param ... Arguments for format.
    */
    void sst_assert(bool condition, uint32_t line, const char* file, const char* func, int exit_code,
        const char* format, ...) const __attribute__((format(printf, 7, 8)));
 
private:
    SimTime_t processCurrentTimeWithUnderflowedBase(const std::string& base) const;
 
    /**
       findExplicitlyEnabledStatistic
 
       @param params
 
       @param id
 
       @param name
 
       @param stat_sub_id
 
       @return That matching stat if the stat already was created for the given ID, otherwise nullptr
    */
    Statistics::StatisticBase* createExplicitlyEnabledStatistic(SST::Params& params, StatisticId_t id,
        const std::string& name, const std::string& stat_sub_id, StatCreateFunction create);
 
    Statistics::StatisticBase* createEnabledAllStatistic(
        SST::Params& params, const std::string& name, const std::string& stat_sub_id, StatCreateFunction create);
 
    void setDefaultTimeBaseForLinks(TimeConverter tc);
 
    void pushValidParams(Params& params, const std::string& type);
 
    template <class T, class... ARGS>
    T* loadUserSubComponentByIndex(const std::string& slot_name, int slot_num, int share_flags, ARGS... args)
    {
 
        share_flags = share_flags & ComponentInfo::USER_FLAGS;
 
        // Check to see if the slot exists
        ComponentInfo* sub_info = my_info_->findSubComponent(slot_name, slot_num);
        if ( sub_info == nullptr ) return nullptr;
        sub_info->share_flags = share_flags;
        sub_info->parent_info = my_info_;
 
        if ( isSubComponentLoadableUsingAPI<T>(sub_info->type) ) {
            auto ret = Factory::getFactory()->CreateWithParams<T>(
                sub_info->type, *sub_info->params, sub_info->id_, *sub_info->params, args...);
            return ret;
        }
        return nullptr;
    }
 
    template <class T>
    bool isUserSubComponentLoadableUsingAPIByIndex(const std::string& slot_name, int slot_num)
    {
        // Check to see if the slot exists
        ComponentInfo* sub_info = my_info_->findSubComponent(slot_name, slot_num);
        if ( sub_info == nullptr ) return false;
 
        return isSubComponentLoadableUsingAPI<T>(sub_info->type);
    }
 
    // Utility function used by fatal and sst_assert
    [[noreturn]]
    void vfatal(uint32_t line, const char* file, const char* func, int exit_code, const char* format, va_list arg) const
        __attribute__((format(printf, 6, 0)));
 
    // Get the statengine from Simulation
    StatisticProcessingEngine* getStatEngine();
 
public:
    SubComponentSlotInfo* getSubComponentSlotInfo(const std::string& name, bool fatalOnEmptyIndex = false);
 
    /**
       Retrieve the X,Y,Z coordinates of this component
    */
    const std::vector<double>& getCoordinates() const { return my_info_->coordinates; }
 
protected:
    friend class SST::Statistics::StatisticProcessingEngine;
    friend class SST::Statistics::StatisticBase;
 
    bool isAnonymous() { return my_info_->isAnonymous(); }
 
    bool isUser() { return my_info_->isUser(); }
 
    /**
       Manually set the default defaultTimeBase
    */
    void setDefaultTimeBase(TimeConverter tc) { my_info_->defaultTimeBase = tc; }
 
    TimeConverter       getDefaultTimeBase() { return my_info_->defaultTimeBase; }
    const TimeConverter getDefaultTimeBase() const { return my_info_->defaultTimeBase; }
 
    bool doesSubComponentExist(const std::string& type);
 
    // Does the statisticName exist in the ElementInfoStatistic and if so, what is its enable level
    uint8_t getStatisticValidityAndLevel(const std::string& statisticName) const;
 
    std::vector<Profile::ComponentProfileTool*> getComponentProfileTools(const std::string& point);
 
    /**** Primary Component API ****/
 
    /**
       Register as a primary component, which allows the component to specify when it is and is not OK to end
       simulation.  The simulator will not end simulation through use of the Exit object while any primary component has
       specified primaryComponentDoNotEndSim().  However, it is still possible for Actions other than Exit to end
       simulation.  Once all primary components have specified primaryComponentOKToEndSim(), the Exit object will
       trigger and end simulation.
 
       This must be called during simulation wireup (i.e during the constructor for the component), or a fatal error
       will occur.
 
       If no component registers as a primary component, then the Exit object will not be used for that simulation and
       simulation termination must be accomplished through some other mechanism (e.g. --stopAt flag, or some other
       Action object).
 
       @sa BaseComponent::primaryComponentDoNotEndSim()
       @sa BaseComponent::primaryComponentOKToEndSim()
    */
    void registerAsPrimaryComponent();
 
    /**
       Tells the simulation that it should not exit.  The component will remain in this state until a call to
       primaryComponentOKToEndSim(). A component may reenter the DoNotEndSime state by calling this function after
       calling primaryComponentOKToEndSim(), in which case, another call to primaryComponentOKToEndSim() will need to be
       called to end the simulation.
 
       Calls to this function when already in the DoNotEndSime state, will be functionally ignored, but will generate a
       warning if verbose is turned on.
 
       Calls to this function on non-primary components will be ignored and will generate a warning if verbose is turned
       on.
 
       @sa BaseComponent::registerAsPrimaryComponent()
       @sa BaseComponent::primaryComponentOKToEndSim()
    */
    void primaryComponentDoNotEndSim();
 
    /**
       Tells the simulation that it is now OK to end simulation.  Simulation will not end until all primary components
       that have called primaryComponentDoNotEndSim() have called this function.
 
       Calls to this function when already in the OKToEndSim state, will be functionally ignored, but will generate a
       warning if verbose is turned on.
 
       Calls to this function on non-primary components will be ignored and will generate a warning if verbose is turned
       on.
 
       @sa BaseComponent::registerAsPrimaryComponent()
       @sa BaseComponent::primaryComponentDoNotEndSim()
    */
    void primaryComponentOKToEndSim();
 
 
private:
    enum class ComponentState : uint8_t {
        // Primary States
        None        = 0,
        Primary     = 1 << 0,
        DoNotEndSim = 1 << 1,
        OKToEndSim  = 1 << 2,
 
        // Whether this is an extension
        Extension = 1 << 3,
    };
 
    /**
       Check for Primary state
 
       @return True if component_state_ includes Primary, false otherwise
    */
    bool isStatePrimary()
    {
        return static_cast<uint8_t>(component_state_) & static_cast<uint8_t>(ComponentState::Primary);
    }
 
    /**
       Check for DoNotEndSim state. This state is mutually exclusive with OKToEndSim
 
       @return True if component_state_ includes DoNotEndSim, false otherwise
    */
    bool isStateDoNotEndSim()
    {
        return static_cast<uint8_t>(component_state_) & static_cast<uint8_t>(ComponentState::DoNotEndSim);
    }
 
    /**
       Check for OKToEndSim state. This state is mutually exclusive with DoNotEndSim
 
       @return True if component_state_ includes OKToEndSim
    */
    bool isStateOKToEndSim()
    {
        return static_cast<uint8_t>(component_state_) & static_cast<uint8_t>(ComponentState::OKToEndSim);
    }
 
    /**
       Check for Extension state
 
       @return True if component_state_ includes Extension, false otherwise
    */
    bool isExtension()
    {
        return static_cast<uint8_t>(component_state_) & static_cast<uint8_t>(ComponentState::Extension);
    }
 
 
    /**
       Adds Primary to the component_state_
 
       NOTE: This function does not check to see if the component is in the proper stage of simulation, that check
       should be done before calling this function.
    */
    void setStateAsPrimary()
    {
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) | static_cast<uint8_t>(ComponentState::Primary));
    }
 
    /**
       Adds DoNotEndSim and removes OKToEndSim to/from the component_state_
 
       NOTE: This function does not check to see if registerAsPrimaryComponent() has been properly called, that check
       should be done before calling this function.
    */
    void setStateDoNotEndSim()
    {
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) | static_cast<uint8_t>(ComponentState::DoNotEndSim));
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) & ~static_cast<uint8_t>(ComponentState::OKToEndSim));
    }
 
    /**
       Adds OKToEndSim and removes DoNotEndSim to/from the component_state_
 
       NOTE: This function does not check to see if registerAsPrimaryComponent() has been properly called, that check
       should be done before calling this function.
    */
    void setStateOKToEndSim()
    {
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) | static_cast<uint8_t>(ComponentState::OKToEndSim));
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) & ~static_cast<uint8_t>(ComponentState::DoNotEndSim));
    }
 
    /**
       Adds Extension to the component_state_
    */
    void setAsExtension()
    {
        component_state_ = static_cast<ComponentState>(
            static_cast<uint8_t>(component_state_) | static_cast<uint8_t>(ComponentState::Extension));
    }
 
 
    friend class Core::Serialization::pvt::SerializeBaseComponentHelper;
 
 
    ComponentInfo* my_info_ = nullptr;
    Simulation*    sim_     = nullptr;
 
    // component_state_ is initialized as NotPrimary and !Extension
    ComponentState component_state_ = ComponentState::None;
    // bool             isExtension = false;
 
    // 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_;
 
    void  addSelfLink(const std::string& name);
    Link* getLinkFromParentSharedPort(const std::string& port, std::vector<ConfigPortModule>& port_modules);
 
    using StatNameMap = std::map<std::string, std::map<std::string, Statistics::StatisticBase*>>;
 
    ConfigPortModule& getPortModuleConfig(PortModuleId_t);
 
    static thread_local std::pair<ComponentId_t, PortModuleId_t> port_module_id_;
 
    std::vector<PortModule*> port_modules_;
 
    std::map<StatisticId_t, Statistics::StatisticBase*>
        explicitly_enabled_shared_stats_; // Lookup structure to determine if an explicitly enabled shared stat has
                                          // already been registered. In this context, a shared stat is one that has
                                          // been piped to a different user-defined name in the config.
    std::map<StatisticId_t, StatNameMap>
        explicitly_enabled_unique_stats_; // Lookup structure to determine if an explicitly enabled non-shared stat has
                                          // been registered.
    StatNameMap enabled_all_stats_;
 
    /**
       Get the ultimate parent Component for this BaseComponent.  Will return this is caller is a Component
    */
    BaseComponent* getParentComponent()
    {
        ComponentInfo* base_info = my_info_;
        while ( base_info->parent_info ) {
            base_info = base_info->parent_info;
        }
        return base_info->component;
    }
 
    virtual Clock::Group* getClockGroup(TimeConverter tc) { return getParentComponent()->getClockGroup(tc); }
};
 
/**
   Used to load SubComponents when multiple SubComponents are loaded into a single slot (will also also work when a
   single SubComponent is loaded).
 */
class SubComponentSlotInfo
{
 
    BaseComponent* comp;
    std::string    slot_name;
    int            max_slot_index;
 
public:
    ~SubComponentSlotInfo() {}
 
    SubComponentSlotInfo(BaseComponent* comp, const std::string& slot_name) :
        comp(comp),
        slot_name(slot_name)
    {
        const std::map<ComponentId_t, ComponentInfo>& subcomps = comp->my_info_->getSubComponents();
 
        // Look for all subcomponents with the right slot name
        max_slot_index = -1;
        for ( auto& ci : subcomps ) {
            if ( ci.second.getSlotName() == slot_name ) {
                if ( ci.second.getSlotNum() > static_cast<int>(max_slot_index) ) {
                    max_slot_index = ci.second.getSlotNum();
                }
            }
        }
    }
 
    const std::string& getSlotName() const { return slot_name; };
 
    bool isPopulated(int slot_num) const
    {
        if ( slot_num > max_slot_index ) return false;
        if ( comp->my_info_->findSubComponent(slot_name, slot_num) == nullptr ) return false;
        return true;
    }
 
    bool isAllPopulated() const
    {
        for ( int i = 0; i < max_slot_index; ++i ) {
            if ( comp->my_info_->findSubComponent(slot_name, i) == nullptr ) return false;
        }
        return true;
    }
 
    int getMaxPopulatedSlotNumber() const { return max_slot_index; }
 
    /**
       Check to see if the element type loaded by the user into the specified slot index is loadable with a particular
       API.
 
       @param slot_num Slot index to check
 
       @return True if loadable as the API specified as the template parameter
    */
    template <class T>
    bool isLoadableUsingAPI(int slot_num)
    {
        return comp->isUserSubComponentLoadableUsingAPIByIndex<T>(slot_name, slot_num);
    }
 
    // Create functions that support the new API
 
    /**
       Create a user defined subcomponent (defined in input file to SST run).  This call will pass SHARE_NONE to the new
       subcomponent and will not take constructor arguments.  If constructor arguments are needed for the API that is
       being loaded, the full call to create will need to be used create(slot_num, share_flags, args...).
 
       @param slot_num Slot index from which to load subcomponent
 
       This function supports the new API, but is identical to an existing API call.  It will try to load using new API
       and will fallback to old if unsuccessful.
    */
    template <typename T>
    T* create(int slot_num) const
    {
        Params empty;
        return comp->loadUserSubComponentByIndex<T>(slot_name, slot_num, ComponentInfo::SHARE_NONE);
    }
 
    /**
       Create a user defined subcomponent (defined in input file to SST run).
 
       @param slot_num Slot index from which to load subcomponent
 
       @param share_flags Share flags to be used by subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <class T, class... ARGS>
    T* create(int slot_num, uint64_t share_flags, ARGS... args) const
    {
        return comp->loadUserSubComponentByIndex<T, ARGS...>(slot_name, slot_num, share_flags, args...);
    }
 
    /**
       Create all user defined subcomponents (defined in input file to SST run) for the slot.
 
       @param vec Vector of T* that will hold the pointers to the new subcomponents.  If an index is not occupied, a
       nullptr will be put in its place.  All components will be added to the end of the vector, so index N will be at
       vec.length() + N, where vec.length() is the length of the vector when it is passed to the call.
 
       @param share_flags Share flags to be used by subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <typename T, class... ARGS>
    void createAll(std::vector<T*>& vec, uint64_t share_flags, ARGS... args) const
    {
        for ( int i = 0; i <= getMaxPopulatedSlotNumber(); ++i ) {
            T* sub = create<T>(i, share_flags, args...);
            vec.push_back(sub);
        }
    }
 
    /**
       Create all user defined subcomponents (defined in input file to SST
       run) for the slot.
 
       @param vec Vector of pair<int,T*> that will hold the pointers to the new subcomponents.  The int will hold the
       index from which the subcomponent was loaded.  Unoccupied indexes will be skipped.  All components will be added
       to the end of the vector.
 
       @param share_flags Share flags to be used by subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <typename T, class... ARGS>
    void createAllSparse(std::vector<std::pair<int, T*>>& vec, uint64_t share_flags, ARGS... args) const
    {
        for ( int i = 0; i <= getMaxPopulatedSlotNumber(); ++i ) {
            T* sub = create<T>(i, share_flags, args...);
            if ( sub != nullptr ) vec.push_back(i, sub);
        }
    }
 
    /**
       Create all user defined subcomponents (defined in input file to SST run) for the slot.
 
       @param vec Vector of T* that will hold the pointers to the new subcomponents.  Unoccupied indexes will be
       skipped.  All components will be added to the end of the vector.
 
       @param share_flags Share flags to be used by subcomponent
 
       @param args Arguments to be passed to constructor.  This signature is defined in the API definition
 
       For ease in backward compatibility to old API, this call will try to load using new API and will fallback to old
       if unsuccessful.
    */
    template <typename T, class... ARGS>
    void createAllSparse(std::vector<T*>& vec, uint64_t share_flags, ARGS... args) const
    {
        for ( int i = 0; i <= getMaxPopulatedSlotNumber(); ++i ) {
            T* sub = create<T>(i, share_flags, args...);
            if ( sub != nullptr ) vec.push_back(sub);
        }
    }
};
 
namespace Core::Serialization {
 
namespace pvt {
class SerializeBaseComponentHelper
{
public:
    static void size_basecomponent(serializable_base* s, serializer& ser);
 
    static void pack_basecomponent(serializable_base* s, serializer& ser);
 
    static void unpack_basecomponent(serializable_base*& s, serializer& ser);
 
    static void map_basecomponent(serializable_base*& s, serializer& ser, const std::string& name);
};
 
} // namespace pvt
 
 
template <class T>
class serialize_impl<T*, std::enable_if_t<std::is_base_of_v<SST::BaseComponent, T>>>
{
    void operator()(T*& s, serializer& ser, ser_opt_t UNUSED(options))
    {
        serializable_base* sp = static_cast<serializable_base*>(s);
        switch ( ser.mode() ) {
        case serializer::SIZER:
            pvt::SerializeBaseComponentHelper::size_basecomponent(sp, ser);
            break;
        case serializer::PACK:
            pvt::SerializeBaseComponentHelper::pack_basecomponent(sp, ser);
            break;
        case serializer::UNPACK:
            pvt::SerializeBaseComponentHelper::unpack_basecomponent(sp, ser);
            break;
        case serializer::MAP:
            pvt::SerializeBaseComponentHelper::map_basecomponent(sp, ser, ser.getMapName());
            break;
        }
        s = static_cast<T*>(sp);
    }
 
    SST_FRIEND_SERIALIZE();
};
 
} // namespace Core::Serialization
 
} // namespace SST
 
#endif // SST_CORE_BASECOMPONENT_H