componentInfo.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_COMPONENTINFO_H
#define SST_CORE_COMPONENTINFO_H
 
#include "sst/core/params.h"
#include "sst/core/serialization/serializer_fwd.h"
#include "sst/core/sst_types.h"
#include "sst/core/timeConverter.h"
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace SST {
 
class BaseComponent;
class ComponentInfoMap;
class LinkMap;
 
class ConfigPortModule;
class ConfigComponent;
class ConfigStatistic;
 
class Simulation;
 
namespace Core::Serialization::pvt {
class SerializeBaseComponentHelper;
} // namespace Core::Serialization::pvt
 
class ComponentInfo
{
 
public:
    using statEnableList_t = std::vector<ConfigStatistic>; /*!< List of Enabled Statistics */
 
    // Share Flags for SubComponent loading
    static const uint64_t SHARE_PORTS  = 0x1;
    static const uint64_t SHARE_STATS  = 0x2;
    static const uint64_t INSERT_STATS = 0x4;
    static const uint64_t SHARE_NONE   = 0x0;
 
private:
    // Mask to make sure users are only setting the flags that are
    // available to them
    static const uint64_t USER_FLAGS = 0x7;
 
    // Friend classes
    friend class Simulation;
    friend class BaseComponent;
    friend class ComponentInfoMap;
    friend class Core::Serialization::pvt::SerializeBaseComponentHelper;
 
    /**
       Component ID.
 
       SubComponents share the lower bits (defined by macros in
       sst_types.h) with their Component parent.  However, every
       SubComponent has a unique ID.
    */
    const ComponentId_t id_;
 
    ComponentInfo*    parent_info;
    /**
       Name of the Component/SubComponent.
     */
    const std::string name;
 
    /**
       Type of the Component/SubComponent.
     */
    const std::string type;
 
    /**
       LinkMap containing the links assigned to this
       Component/SubComponent in the python file.
 
       This field is not used for SubComponents loaded with
       loadAnonymousSubComponent().
     */
    LinkMap* link_map;
 
    /**
       Pointer to the Component created using this ComponentInfo.
     */
    BaseComponent* component;
 
    /**
       SubComponents loaded into the Component/SubComponent.
     */
    std::map<ComponentId_t, ComponentInfo> subComponents;
 
    /**
       Parameters defined in the python file for the (Sub)Component.
 
       This field is used for only a short time while loading
       SubComponents via loadUserSubComponent().
 
       This pointer is invalid after simulation wire-up.
    */
    Params* params;
 
    TimeConverter defaultTimeBase;
 
    std::map<std::string, std::vector<ConfigPortModule>>* port_modules_       = nullptr;
    std::map<StatisticId_t, ConfigStatistic>*             stat_configs_       = nullptr;
    std::map<std::string, StatisticId_t>*                 enabled_stat_names_ = nullptr;
    bool                                                  enabled_all_stats_  = false;
    ConfigStatistic*                                      all_stat_config_    = nullptr;
 
    uint8_t statLoadLevel;
 
    std::vector<double> coordinates;
 
    uint64_t subIDIndex;
 
    // Variables only used by SubComponents
 
    /**
       Name of the slot this SubComponent was loaded into.  This field
       is not used for Components.
     */
    const std::string slot_name;
 
    /**
       Index in the slot this SubComponent was loaded into.  This field
       is not used for Components.
     */
    int slot_num;
 
    /**
       Sharing flags.
 
       Determines whether various data is shared from parent to child.
     */
    uint64_t share_flags;
 
    bool sharesPorts() { return (share_flags & SHARE_PORTS) != 0; }
 
    bool sharesStatistics() { return (share_flags & SHARE_STATS) != 0; }
 
    bool canInsertStatistics() { return (share_flags & INSERT_STATS) != 0; }
 
    inline void setComponent(BaseComponent* comp) { component = comp; }
    // inline void setParent(BaseComponent* comp) { parent = comp; }
 
    /* Lookup Key style constructor */
    ComponentInfo(ComponentId_t id, const std::string& name);
    void finalizeLinkConfiguration() const;
    void prepareForComplete() const;
 
    ComponentId_t addAnonymousSubComponent(ComponentInfo* parent_info, const std::string& type,
        const std::string& slot_name, int slot_num, uint64_t share_flags);
 
public:
    /**
       Constructor used only for serialization
     */
    ComponentInfo();
 
    /**
       Function used to serialize the class
     */
    void serialize_order(SST::Core::Serialization::serializer& ser);
    void serialize_comp(SST::Core::Serialization::serializer& ser);
 
    /* Old ELI Style subcomponent constructor */
    ComponentInfo(const std::string& type, const Params* params, const ComponentInfo* parent_info);
 
    /* Anonymous SubComponent */
    ComponentInfo(ComponentId_t id, ComponentInfo* parent_info, const std::string& type, const std::string& slot_name,
        int slot_num, uint64_t share_flags /*, const Params& params_in*/);
 
    /* New ELI Style */
    ComponentInfo(ConfigComponent* ccomp, const std::string& name, ComponentInfo* parent_info, LinkMap* link_map);
    ComponentInfo(ComponentInfo&& o);
    ~ComponentInfo();
 
    bool isAnonymous() { return COMPDEFINED_SUBCOMPONENT_ID_MASK(id_); }
 
    bool isUser() { return !COMPDEFINED_SUBCOMPONENT_ID_MASK(id_); }
 
    inline ComponentId_t getID() const { return id_; }
 
    inline const std::string& getName() const
    {
        if ( name.empty() && parent_info ) return parent_info->getName();
        return name;
    }
 
    inline const std::string& getParentComponentName() const
    {
        // First, get the actual component (parent pointer will be
        // nullptr).
        const ComponentInfo* real_comp = this;
        while ( real_comp->parent_info != nullptr )
            real_comp = real_comp->parent_info;
        return real_comp->getName();
    }
 
    /**
       Get the short name for this SubComponent (name not including
       any parents, so just slot_name[index])
     */
    inline std::string getShortName() const { return name.substr(name.find_last_of(':') + 1); }
 
    inline const std::string& getSlotName() const { return slot_name; }
 
    inline int getSlotNum() const { return slot_num; }
 
    inline const std::string& getType() const { return type; }
 
    inline BaseComponent* getComponent() const { return component; }
 
    LinkMap* getLinkMap();
 
    inline const Params* getParams() const { return params; }
 
    // inline std::map<std::string, ComponentInfo>& getSubComponents() { return subComponents; }
    inline std::map<ComponentId_t, ComponentInfo>& getSubComponents() { return subComponents; }
 
    ComponentInfo* findSubComponent(const std::string& slot, int slot_num);
    ComponentInfo* findSubComponent(ComponentId_t id);
    bool           hasLinks() const;
 
    uint8_t getStatisticLoadLevel() { return statLoadLevel; }
 
    struct HashName
    {
        size_t operator()(const ComponentInfo* info) const
        {
            std::hash<std::string> hash;
            return hash(info->name);
        }
    };
 
    struct EqualsName
    {
        bool operator()(const ComponentInfo* lhs, const ComponentInfo* rhs) const { return lhs->name == rhs->name; }
    };
 
    struct HashID
    {
        size_t operator()(const ComponentInfo* info) const
        {
            std::hash<ComponentId_t> hash;
            return hash(info->id_);
        }
    };
 
    struct EqualsID
    {
        bool operator()(const ComponentInfo* lhs, const ComponentInfo* rhs) const { return lhs->id_ == rhs->id_; }
    };
 
    //// Functions used only for testing, they will not create valid
    //// ComponentInfos for simulation
 
    /**
       (DO NOT USE) Constructor used only for serialization testing
     */
    ComponentInfo(
        ComponentId_t id, const std::string& name, const std::string& slot_name, TimeConverter tv = TimeConverter());
 
    ComponentInfo* test_addSubComponentInfo(
        const std::string& name, const std::string& slot_name, TimeConverter tv = TimeConverter());
 
    void test_printComponentInfoHierarchy(int index = 0);
};
 
class ComponentInfoMap
{
private:
    std::unordered_set<ComponentInfo*, ComponentInfo::HashID, ComponentInfo::EqualsID> dataByID;
 
public:
    using const_iterator =
        std::unordered_set<ComponentInfo*, ComponentInfo::HashID, ComponentInfo::EqualsID>::const_iterator;
 
    const_iterator begin() const { return dataByID.begin(); }
 
    const_iterator end() const { return dataByID.end(); }
 
    ComponentInfoMap() {}
 
    void insert(ComponentInfo* info) { dataByID.insert(info); }
 
    ComponentInfo* getByID(const ComponentId_t key) const
    {
        ComponentInfo infoKey(COMPONENT_ID_MASK(key), "");
        auto          value = dataByID.find(&infoKey);
        if ( value == dataByID.end() ) return nullptr;
        if ( SUBCOMPONENT_ID_MASK(key) != 0 ) {
            // Looking for a subcomponent
            return (*value)->findSubComponent(key);
        }
        return *value;
    }
 
    bool empty() { return dataByID.empty(); }
 
    void clear()
    {
        for ( auto i : dataByID ) {
            delete i;
        }
        dataByID.clear();
    }
 
    size_t size() { return dataByID.size(); }
};
 
} // namespace SST
 
#endif // SST_CORE_COMPONENTINFO_H