statoutputhdf5.h

// Copyright 2009-2024 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2024, 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_STATAPI_STATOUTPUTHDF5_H
#define SST_CORE_STATAPI_STATOUTPUTHDF5_H

#include "sst/core/sst_types.h"
#include "sst/core/statapi/statoutput.h"
#include "sst/core/warnmacros.h"

DISABLE_WARN_MISSING_OVERRIDE
#include "H5Cpp.h"
REENABLE_WARNING

#include <map>
#include <string>

namespace SST {
namespace Statistics {

/**
    \class StatisticOutputHDF5

    The class for statistics output to a comma separated file.
*/
class StatisticOutputHDF5 : public StatisticFieldsOutput
{
public:
    SST_ELI_REGISTER_DERIVED(
      StatisticOutput,
      StatisticOutputHDF5,
      "sst",
      "statoutputhdf5",
      SST_ELI_ELEMENT_VERSION(1,0,0),
      "Output to an HDF5 file")

    /** Construct a StatOutputHDF5
     * @param outputParameters - Parameters used for this Statistic Output
     */
    StatisticOutputHDF5(Params& outputParameters);

    bool acceptsGroups() const override { return true; }

    void serialize_order(SST::Core::Serialization::serializer& ser) override;

    ImplementSerializable(SST::Statistics::StatisticOutputHDF5)

private:
    /** Perform a check of provided parameters
     * @return True if all required parameters and options are acceptable
     */
    bool checkOutputParameters() override;

    /** Print out usage for this Statistic Output */
    void printUsage() override;

    void startRegisterFields(StatisticBase* stat) override;
    void implRegisteredField(fieldHandle_t fieldHandle) override;
    void stopRegisterFields() override;

    void startRegisterGroup(StatisticGroup* group) override;
    void stopRegisterGroup() override;

    /** Indicate to Statistic Output that simulation started.
     *  Statistic output may perform any startup code here as necessary.
     */
    void startOfSimulation() override;

    /** Indicate to Statistic Output that simulation ended.
     *  Statistic output may perform any shutdown code here as necessary.
     */
    void endOfSimulation() override;

    /** Implementation function for the start of output.
     * This will be called by the Statistic Processing Engine to indicate that
     * a Statistic is about to send data to the Statistic Output for processing.
     * @param statistic - Pointer to the statistic object than the output can
     * retrieve data from.
     */
    void implStartOutputEntries(StatisticBase* statistic) override;

    /** Implementation function for the end of output.
     * This will be called by the Statistic Processing Engine to indicate that
     * a Statistic is finished sending data to the Statistic Output for processing.
     * The Statistic Output can perform any output related functions here.
     */
    void implStopOutputEntries() override;

    void startOutputGroup(StatisticGroup* group) override;
    void stopOutputGroup() override;

    /** Implementation functions for output.
     * These will be called by the statistic to provide Statistic defined
     * data to be output.
     * @param fieldHandle - The handle to the registered statistic field.
     * @param data - The data related to the registered field to be output.
     */
    void outputField(fieldHandle_t fieldHandle, int32_t data) override;
    void outputField(fieldHandle_t fieldHandle, uint32_t data) override;
    void outputField(fieldHandle_t fieldHandle, int64_t data) override;
    void outputField(fieldHandle_t fieldHandle, uint64_t data) override;
    void outputField(fieldHandle_t fieldHandle, float data) override;
    void outputField(fieldHandle_t fieldHandle, double data) override;

protected:
    StatisticOutputHDF5(); // For serialization

private:
    typedef union {
        int32_t  i32;
        uint32_t u32;
        int64_t  i64;
        uint64_t u64;
        float    f;
        double   d;
    } StatData_u;

    class DataSet
    {
    public:
        DataSet(H5::H5File* file) : file(file) {}
        virtual ~DataSet() {}
        H5::H5File*  getFile() { return file; }
        virtual bool isGroup() const = 0;

        virtual void setCurrentStatistic(StatisticBase* UNUSED(stat)) {}
        virtual void registerField(StatisticFieldInfo* fi) = 0;
        virtual void finalizeCurrentStatistic()            = 0;

        virtual void beginGroupRegistration(StatisticGroup* UNUSED(group)) {}
        virtual void finalizeGroupRegistration() {}

        virtual void startNewGroupEntry(Cycle_t UNUSED(cycle)) {}
        virtual void finishGroupEntry() {}

        virtual void        startNewEntry(StatisticBase* stat, Cycle_t cycle) = 0;
        virtual StatData_u& getFieldLoc(fieldHandle_t fieldHandle)            = 0;
        virtual void        finishEntry()                                     = 0;

    protected:
        H5::H5File* file;
    };

    class StatisticInfo : public DataSet
    {
        StatisticBase*             statistic;
        std::vector<fieldHandle_t> indexMap;
        std::vector<StatData_u>    currentData;
        std::vector<fieldType_t>   typeList;
        std::vector<std::string>   fieldNames;

        H5::DataSet*  dataset;
        H5::CompType* memType;

        hsize_t nEntries;

    public:
        StatisticInfo(StatisticBase* stat, H5::H5File* file) : DataSet(file), statistic(stat), nEntries(0)
        {
            typeList.push_back(StatisticFieldType<uint64_t>::id());
            indexMap.push_back(-1);
            fieldNames.push_back("SimTime");
        }
        ~StatisticInfo()
        {
            if ( dataset ) delete dataset;
            if ( memType ) delete memType;
        }
        void registerField(StatisticFieldInfo* fi) override;
        void finalizeCurrentStatistic() override;

        bool        isGroup() const override { return false; }
        void        startNewEntry(StatisticBase* stat, Cycle_t cycle) override;
        StatData_u& getFieldLoc(fieldHandle_t fieldHandle) override;
        void        finishEntry() override;
    };

    class GroupInfo : public DataSet
    {
        struct GroupStat
        {
            GroupInfo*  gi;
            std::string statPath;

            H5::DataSet*  dataset;
            H5::CompType* memType;

            hsize_t nEntries;

            std::vector<std::string>        registeredFields; /* fi->uniqueName */
            std::vector<fieldType_t>        typeList;
            std::map<fieldHandle_t, size_t> handleIndexMap;

            std::vector<StatData_u> currentData;
            size_t                  currentCompOffset;

            GroupStat(GroupInfo* group, StatisticBase* stat);
            void               finalizeRegistration();
            static std::string getStatName(StatisticBase* stat);

            void startNewGroupEntry();

            void        startNewEntry(size_t componentIndex, StatisticBase* stat);
            StatData_u& getFieldLoc(fieldHandle_t fieldHandle);
            void        finishEntry();

            void finishGroupEntry();
        };

        hsize_t                          nEntries;
        std::map<std::string, GroupStat> m_statGroups;
        GroupStat*                       m_currentStat;
        StatisticGroup*                  m_statGroup;
        std::vector<BaseComponent*>      m_components;
        H5::DataSet*                     timeDataSet;

    public:
        GroupInfo(StatisticGroup* group, H5::H5File* file);
        void beginGroupRegistration(StatisticGroup* UNUSED(group)) override {}
        void setCurrentStatistic(StatisticBase* stat) override;
        void registerField(StatisticFieldInfo* fi) override;
        void finalizeCurrentStatistic() override;
        void finalizeGroupRegistration() override;

        bool        isGroup() const override { return true; }
        void        startNewEntry(StatisticBase* stat, Cycle_t cycle) override;
        StatData_u& getFieldLoc(fieldHandle_t fieldHandle) override { return m_currentStat->getFieldLoc(fieldHandle); }
        void        finishEntry() override;

        void   startNewGroupEntry(Cycle_t cycle) override;
        void   finishGroupEntry() override;
        size_t getNumComponents() const { return m_components.size(); }

        const std::string& getName() const;
    };

    H5::H5File*                              m_hFile;
    DataSet*                                 m_currentDataSet;
    std::map<StatisticBase*, StatisticInfo*> m_statistics;
    std::map<std::string, GroupInfo>         m_statGroups;

    StatisticInfo* initStatistic(StatisticBase* statistic);
    StatisticInfo* getStatisticInfo(StatisticBase* statistic);
};

} // namespace Statistics
} // namespace SST

#endif // SST_CORE_STATAPI_STATOUTPUTHDF5_H