pymodel.h

// -*- c++ -*-

// 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_MODEL_PYTHON_PYMODEL_H
#define SST_CORE_MODEL_PYTHON_PYMODEL_H

// This only works if we have Python defined from configure, otherwise this is
// a compile time error.
// #ifdef SST_CONFIG_HAVE_PYTHON

#include "sst/core/config.h"
#include "sst/core/configGraph.h"
#include "sst/core/model/sstmodel.h"
#include "sst/core/output.h"
#include "sst/core/rankInfo.h"
#include "sst/core/warnmacros.h"

DISABLE_WARN_DEPRECATED_REGISTER
#include <Python.h>
#include <cstddef>
REENABLE_WARNING

#include <map>
#include <string>
#include <vector>

using namespace SST;

namespace SST::Core {

class SSTPythonModelDefinition : public SSTModelDescription
{
public:
    SST_ELI_REGISTER_MODEL_DESCRIPTION(
        SST::Core::SSTPythonModelDefinition,
        "sst",
        "model.python",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "Python model for building SST simulation graphs",
        true)

    SST_ELI_DOCUMENT_MODEL_SUPPORTED_EXTENSIONS(".py")


    // SSTPythonModelDefinition(
    //     const std::string& script_file, int verbosity, Config* config, double start_time, int argc, char** argv);
    SSTPythonModelDefinition(const std::string& script_file, int verbosity, Config* config, double start_time);
    virtual ~SSTPythonModelDefinition();

    ConfigGraph* createConfigGraph() override;

protected:
    void                initModel(const std::string& script_file, int verbosity, Config* config, int argc, char** argv);
    std::string         scriptName;
    Output*             output;
    Config*             config;
    ConfigGraph*        graph;
    char*               namePrefix;
    size_t              namePrefixLen;
    std::vector<size_t> nameStack;
    std::map<std::string, ComponentId_t> compNameMap;
    ComponentId_t                        nextComponentId;
    double                               start_time;
    bool                                 callPythonFinalize;
#if PY_MINOR_VERSION >= 9
    bool enablePythonCoverage = false;
#endif

public: /* Public, but private.  Called only from Python functions */
    Config* getConfig() const { return config; }

    bool setConfigEntryFromModel(const std::string& entryName, const std::string& value)
    {
        return setOptionFromModel(entryName, value);
    }

    ConfigGraph* getGraph() const { return graph; }

    Output* getOutput() const { return output; }

    ComponentId_t getNextComponentId() { return nextComponentId++; }

    ComponentId_t addComponent(const char* name, const char* type)
    {
        auto id = graph->addComponent(name, type);
        return id;
    }

    ConfigComponent* findComponentByName(const char* name) const
    {
        return graph->findComponentByName(std::string(name));
    }

    ConfigComponentMap_t& components() { return graph->getComponentMap(); }

    LinkId_t createLink(const char* link_name, const char* latency) { return graph->createLink(link_name, latency); }

    void addLink(ComponentId_t id, LinkId_t link_id, const char* port, const char* latency) const
    {
        graph->addLink(id, link_id, port, latency);
    }

    void addNonLocalLink(LinkId_t link_id, int rank, int thread) const
    {
        graph->addNonLocalLink(link_id, rank, thread);
    }

    void setLinkNoCut(LinkId_t link_id) const { graph->setLinkNoCut(link_id); }

    void  pushNamePrefix(const char* name);
    void  popNamePrefix();
    char* addNamePrefix(const char* name) const;

    void setStatisticOutput(const char* Name) { graph->setStatisticOutput(Name); }
    void addStatisticOutputParameter(const std::string& param, const std::string& value)
    {
        graph->addStatisticOutputParameter(param, value);
    }
    void setStatisticLoadLevel(uint8_t loadLevel) { graph->setStatisticLoadLevel(loadLevel); }

    void addGlobalParameter(const char* set, const char* key, const char* value, bool overwrite)
    {
        insertGlobalParameter(set, key, value, overwrite);
    }

    UnitAlgebra getElapsedExecutionTime() const;
    UnitAlgebra getLocalMemoryUsage() const;

    void setCallPythonFinalize(bool state) { callPythonFinalize = state; }
};

// For xml inputs (.xml or .sdl), we just use a python script to parse
// the xml.  So, this model definition just uses the python model with
// a few tweaked inputs to the constructor.
class SSTXmlModelDefinition : public SSTModelDescription
{
public:
    SST_ELI_REGISTER_MODEL_DESCRIPTION(
        SST::Core::SSTXmlModelDefinition,
        "sst",
        "model.xml",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "XML model for building SST simulation graphs",
        false)

    SST_ELI_DOCUMENT_MODEL_SUPPORTED_EXTENSIONS(".xml",".sdl")


    SSTXmlModelDefinition(const std::string& script_file, int verbosity, Config* config, double start_time) :
        SSTModelDescription(config)
    {
        // Overwrite model_options.  XML input doesn't allow model
        // options and we need to set it to the script_file to use as
        // input to the xmlToPython.py file.
        setModelOptions(script_file);

        actual_model_ =
            new SSTPythonModelDefinition(SST_INSTALL_PREFIX "/libexec/xmlToPython.py", verbosity, config, start_time);
    }

    ConfigGraph* createConfigGraph() override { return actual_model_->createConfigGraph(); }

    virtual ~SSTXmlModelDefinition() {}

private:
    SSTPythonModelDefinition* actual_model_;
};

std::map<std::string, std::string> generateStatisticParameters(PyObject* statParamDict);
SST::Params                        pythonToCppParams(PyObject* statParamDict);
PyObject*                          buildStatisticObject(StatisticId_t id);
PyObject*                          buildEnabledStatistic(
                             ConfigComponent* cc, const char* statName, PyObject* statParamDict, bool apply_to_children);
PyObject* buildEnabledStatistics(ConfigComponent* cc, PyObject* statList, PyObject* paramDict, bool apply_to_children);

} // namespace SST::Core

#endif // SST_CORE_MODEL_PYTHON_PYMODEL_H