componentProfileTool.h

// Copyright 2009-2025 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2025, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.

#ifndef SST_CORE_PROFILE_COMPONENTPROFILETOOL_H
#define SST_CORE_PROFILE_COMPONENTPROFILETOOL_H

#include "sst/core/eli/elementinfo.h"
#include "sst/core/profile/profiletool.h"
#include "sst/core/sst_types.h"
#include "sst/core/warnmacros.h"

#include <chrono>
#include <cstdint>
#include <map>
#include <string>
#include <utility>
#include <vector>

namespace SST {
class BaseComponent;
}

namespace SST::Profile {

// Base class for profiling tools designed to profile in Components
// and SubComponents. For these types of profiling tools, you can
// trace at various levels:

// 1 - Global: all profiling will be consolidated into one global
// profile

// 2 - Type: all profiling will be consolidated into one profile per
// (Sub)Component type.

// 3 - Component: profiling will be consolidated at the Component
// level and all SubComponent data will be consolidated with its
// parent component

// 4 - SubComponent: profiling will be consolidated at the
// SubComponent level
class ComponentProfileTool : public ProfileTool
{
public:
    SST_ELI_REGISTER_PROFILETOOL_DERIVED_API(SST::Profile::ComponentProfileTool, SST::Profile::ProfileTool, Params&)

    SST_ELI_DOCUMENT_PARAMS(
        { "level", "Level at which to track profile (global, type, component, subcomponent)", "type" },
        { "track_points", "Determines whether independent profiling points are tracked", "true" },
    )

    enum class Profile_Level { Global, Type, Component, Subcomponent };

    ComponentProfileTool(const std::string& name, Params& params);


    virtual uintptr_t registerProfilePoint(
        const std::string& point, ComponentId_t id, const std::string& name, const std::string& type) = 0;
    std::string getKeyForCodeSegment(
        const std::string& point, ComponentId_t id, const std::string& name, const std::string& type);

protected:
    Profile_Level profile_level_;

private:
    bool track_points_;
};


// Profiler API designed to profile code segments in Components and
// SubComponents
class ComponentCodeSegmentProfileTool : public ComponentProfileTool
{
    friend class BaseComponent;

public:
    SST_ELI_REGISTER_PROFILETOOL_DERIVED_API(SST::Profile::ComponentCodeSegmentProfileTool, SST::Profile::ComponentProfileTool, Params&)

    ComponentCodeSegmentProfileTool(const std::string& name, Params& params);

    virtual void codeSegmentStart(uintptr_t UNUSED(key)) {}
    virtual void codeSegmentEnd(uintptr_t UNUSED(key)) {}

    class ProfilePoint
    {
    public:
        ProfilePoint() {}
        ~ProfilePoint() {}

        inline void codeSegmentStart()
        {
            for ( auto& x : tools ) {
                x.first->codeSegmentStart(x.second);
            }
        }
        inline void codeSegmentEnd()
        {
            for ( auto& x : tools ) {
                x.first->codeSegmentEnd(x.second);
            }
        }

        void registerProfilePoint(ComponentCodeSegmentProfileTool* tool, const std::string& point, ComponentId_t id,
            const std::string& name, const std::string& type)
        {
            uintptr_t key = tool->registerProfilePoint(point, id, name, type);
            tools.push_back(std::make_pair(tool, key));
        }

    private:
        std::vector<std::pair<ComponentCodeSegmentProfileTool*, uintptr_t>> tools;
    };
};

/**
   Profile tool that will count the number of times a handler is
   called
 */
class ComponentCodeSegmentProfileToolCount : public ComponentCodeSegmentProfileTool
{

public:
    SST_ELI_REGISTER_PROFILETOOL(
        ComponentCodeSegmentProfileToolCount,
        SST::Profile::ComponentCodeSegmentProfileTool,
        "sst",
        "profile.component.codesegment.count",
        SST_ELI_ELEMENT_VERSION(0, 1, 0),
        "Profiler that will count times through a marked code segment"
    )

    ComponentCodeSegmentProfileToolCount(const std::string& name, Params& params);

    virtual ~ComponentCodeSegmentProfileToolCount() {}

    uintptr_t registerProfilePoint(
        const std::string& point, ComponentId_t id, const std::string& name, const std::string& type) override;

    void codeSegmentStart(uintptr_t key) override;

    void outputData(FILE* fp) override;

private:
    std::map<std::string, uint64_t> counts_;
};

/**
   Profile tool that will count the number of times a handler is
   called
 */
template <typename T>
class ComponentCodeSegmentProfileToolTime : public ComponentCodeSegmentProfileTool
{
    struct segment_data_t
    {
        uint64_t time;
        uint64_t count;

        segment_data_t() :
            time(0),
            count(0)
        {}
    };

public:
    ComponentCodeSegmentProfileToolTime(const std::string& name, Params& params);

    virtual ~ComponentCodeSegmentProfileToolTime() {}

    uintptr_t registerProfilePoint(
        const std::string& point, ComponentId_t id, const std::string& name, const std::string& type) override;

    void codeSegmentStart(uintptr_t UNUSED(key)) override { start_time_ = T::now(); }

    void codeSegmentEnd(uintptr_t key) override
    {
        auto            total_time = T::now() - start_time_;
        segment_data_t* entry      = reinterpret_cast<segment_data_t*>(key);
        entry->time += std::chrono::duration_cast<std::chrono::nanoseconds>(total_time).count();
        entry->count++;
    }

    void outputData(FILE* fp) override;

private:
    typename T::time_point                start_time_;
    std::map<std::string, segment_data_t> times_;
};

} // namespace SST::Profile

#endif // SST_CORE_PROFILE_COMPONENTPROFILETOOL_H