recorder.h

Go to the documentation of this file.

#pragma once
 
#include <sdfg/analysis/analysis.h>
#include <sdfg/analysis/loop_analysis.h>
#include <sdfg/structured_control_flow/control_flow_node.h>
#include <sdfg/structured_sdfg.h>
#include <sdfg/transformations/transformation.h>
#include <sdfg/transformations/transformation_schema.h>
 
#include <concepts>
#include <nlohmann/json.hpp>
#include "sdfg/optimization_report/optimization_report.h"
 
namespace sdfg {
namespace transformations {

template<typename T>
concept transformation_concept = std::derived_from<T, sdfg::transformations::Transformation>;

class Recorder {
private:
    nlohmann::json history_;
 
protected:
    virtual void
    enrich(nlohmann::json& desc, builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {
        auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();
        for (auto& [key, value] : desc["subgraph"].items()) {
            if (!value.contains("element_id")) {
                continue;
            }
            auto element_id = value["element_id"].template get<size_t>();
            auto* elem = builder.find_element_by_id(element_id);
            if (dyn_cast<structured_control_flow::StructuredLoop*>(elem) == nullptr) {
                continue;
            }
            auto* loop = static_cast<structured_control_flow::ControlFlowNode*>(elem);
            auto loop_info = loop_analysis.loop_info(loop);
            value["loop_info"] = loop_info_to_json(loop_info);
        }
    }
 
public:
    Recorder();
 
    virtual ~Recorder() = default;

    bool record(
        Transformation& transformation,
        builder::StructuredSDFGBuilder& builder,
        analysis::AnalysisManager& analysis_manager,
        bool skip_if_not_applicable = false
    ) {
        if (!transformation.can_be_applied(builder, analysis_manager)) {
            if (!skip_if_not_applicable) {
                throw transformations::
                    InvalidTransformationException("Transformation " + transformation.name() + " cannot be applied.");
            }
            return false;
        }
 
        nlohmann::json desc;
        transformation.to_json(desc);
 
#ifndef NDEBUG
        std::string schema_error;
        if (!validate_transformation_schema(desc, schema_error)) {
            throw InvalidTransformationDescriptionException(
                "Transformation '" + transformation.name() + "' produced an invalid description: " + schema_error
            );
        }
#endif
 
        this->enrich(desc, builder, analysis_manager);
        history_.push_back(desc);
        transformation.apply(builder, analysis_manager);
        return true;
    }

    template<typename T, typename... Args>
        requires transformation_concept<T>
    void apply(
        builder::StructuredSDFGBuilder& builder,
        analysis::AnalysisManager& analysis_manager,
        bool skip_if_not_applicable,
        Args&&... args
    ) {
        T transformation(std::forward<Args>(args)...);
        this->record(transformation, builder, analysis_manager, skip_if_not_applicable);
    };

    void save(std::filesystem::path path) const;

    nlohmann::json get_history() const {
        return history_;
    }

    nlohmann::json& history() {
        return history_;
    }
};
 
} // namespace transformations
} // namespace sdfg