18715914051

Committed 22 Oct 2025 12:19PM UTC coverage: 62.358% (+0.7%) from 61.619%

Build # 18715914051

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #292 from daisytuner/flop-analysis-extension

Extension for the FlopAnalysis

Run Details

357 of 423 new or added lines in 10 files covered. (84.4%)

9 existing lines in 3 files now uncovered.

9711 of 15573 relevant lines covered (62.36%)

104.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.21

/src/codegen/instrumentation/instrumentation_plan.cpp

#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
#include <memory>
#include <string>

#include "sdfg/analysis/analysis.h"
#include "sdfg/analysis/loop_analysis.h"
#include "sdfg/codegen/language_extension.h"
#include "sdfg/symbolic/symbolic.h"

namespace sdfg {
namespace codegen {

void InstrumentationPlan::update(const structured_control_flow::ControlFlowNode& node, InstrumentationEventType event_type) {
    this->nodes_[&node] = event_type;
}

bool InstrumentationPlan::should_instrument(const structured_control_flow::ControlFlowNode& node) const {
    return this->nodes_.count(&node);
}

void InstrumentationPlan::begin_instrumentation(
    const structured_control_flow::ControlFlowNode& node, PrettyPrinter& stream, LanguageExtension& language_extension
) const {
    auto& metadata = sdfg_.metadata();
    std::string sdfg_name = sdfg_.name();
    std::string sdfg_file = metadata.at("sdfg_file");
    std::string arg_capture_path = metadata.at("arg_capture_path");
    std::string features_file = metadata.at("features_file");
    std::string opt_report_file = metadata.at("opt_report_file");

    std::string region_uuid = sdfg_name + "_" + std::to_string(node.element_id());

    // Create region id variable
    std::string region_id_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_id";

    // Create metadata variable
    std::string metadata_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_md";
    stream << "__daisy_metadata_t " << metadata_var << ";" << std::endl;

    // Source metadata
    auto& dbg_info = node.debug_info();
    stream << metadata_var << ".file_name = \"" << dbg_info.filename() << "\";" << std::endl;
    stream << metadata_var << ".function_name = \"" << dbg_info.function() << "\";" << std::endl;
    stream << metadata_var << ".line_begin = " << dbg_info.start_line() << ";" << std::endl;
    stream << metadata_var << ".line_end = " << dbg_info.end_line() << ";" << std::endl;
    stream << metadata_var << ".column_begin = " << dbg_info.start_column() << ";" << std::endl;
    stream << metadata_var << ".column_end = " << dbg_info.end_column() << ";" << std::endl;

    // Docc metadata
    stream << metadata_var << ".sdfg_name = \"" << sdfg_name << "\";" << std::endl;
    stream << metadata_var << ".sdfg_file = \"" << sdfg_file << "\";" << std::endl;
    stream << metadata_var << ".arg_capture_path = \"" << arg_capture_path << "\";" << std::endl;
    stream << metadata_var << ".features_file = \"" << features_file << "\";" << std::endl;
    stream << metadata_var << ".opt_report_file = \"" << opt_report_file << "\";" << std::endl;
    stream << metadata_var << ".element_id = " << node.element_id() << ";" << std::endl;
    if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(&node)) {
        stream << metadata_var << ".element_type = \"map\";" << std::endl;
        stream << metadata_var << ".target_type = \"" << map_node->schedule_type().value() << "\";" << std::endl;
    } else if (dynamic_cast<const structured_control_flow::For*>(&node)) {
        stream << metadata_var << ".element_type = \"for\";" << std::endl;
        stream << metadata_var << ".target_type = \"SEQUENTIAL\";" << std::endl;
    } else if (dynamic_cast<const structured_control_flow::While*>(&node)) {
        stream << metadata_var << ".element_type = \"while\";" << std::endl;
        stream << metadata_var << ".target_type = \"SEQUENTIAL\";" << std::endl;
    } else {
        stream << metadata_var << ".element_type = \"\";" << std::endl;
        stream << metadata_var << ".target_type = \"\";" << std::endl;
    }
    if (!this->loopnest_indices_.empty()) {
        stream << metadata_var << ".loopnest_index = " << this->loopnest_indices_.at(&node) << ";" << std::endl;
    } else {
        stream << metadata_var << ".loopnest_index = -1;" << std::endl;
    }
    stream << metadata_var << ".region_uuid = \"" << region_uuid << "\";" << std::endl;

    // Initialize region
    if (this->nodes_.at(&node) == InstrumentationEventType::CPU) {
        stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var
               << ", __DAISY_EVENT_SET_CPU);" << std::endl;
    } else {
        stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var
               << ", __DAISY_EVENT_SET_CUDA);" << std::endl;
    }

    // Enter region
    stream << "__daisy_instrumentation_enter(" << region_id_var << ");" << std::endl;
}

void InstrumentationPlan::end_instrumentation(
    const structured_control_flow::ControlFlowNode& node, PrettyPrinter& stream, LanguageExtension& language_extension
) const {
    std::string region_id_var = sdfg_.name() + "_" + std::to_string(node.element_id()) + "_id";

    // Exit region
    if (this->nodes_.at(&node) == InstrumentationEventType::CPU) {
        stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;
    } else {
        stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;
    }

    // Perform FlopAnalysis
    if (this->flops_.contains(&node)) {
        auto flop = this->flops_.at(&node);
        if (!flop.is_null()) {
            if (symbolic::contains_dynamic_sizeof(flop)) {
                stream << "// Could not generate \"flop\": " << flop->__str__() << std::endl;
            } else {
                std::string flop_str = language_extension.expression(flop);
                stream << "__daisy_instrumentation_increment(" << region_id_var << ", \"flop\", " << flop_str << ");"
                       << std::endl;
            }
        }
    }

    // Finalize region
    stream << "__daisy_instrumentation_finalize(" << region_id_var << ");" << std::endl;
}

std::unique_ptr<InstrumentationPlan> InstrumentationPlan::none(StructuredSDFG& sdfg) {
    return std::make_unique<InstrumentationPlan>(
        sdfg, std::unordered_map<const structured_control_flow::ControlFlowNode*, InstrumentationEventType>{}
    );
}

std::unique_ptr<InstrumentationPlan> InstrumentationPlan::outermost_loops_plan(StructuredSDFG& sdfg) {
    analysis::AnalysisManager analysis_manager(sdfg);
    auto& loop_tree_analysis = analysis_manager.get<analysis::LoopAnalysis>();
    auto ols = loop_tree_analysis.outermost_loops();

    std::unordered_map<const structured_control_flow::ControlFlowNode*, InstrumentationEventType> nodes;
    std::unordered_map<const structured_control_flow::ControlFlowNode*, size_t> loopnest_indices;
    for (size_t i = 0; i < ols.size(); i++) {
        auto& loop = ols[i];
        loopnest_indices[loop] = i;
        if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(loop)) {
            if (map_node->schedule_type().value() == "CUDA") {
                nodes.insert({loop, InstrumentationEventType::CUDA});
                continue;
            }
        }
        nodes.insert({loop, InstrumentationEventType::CPU}); // Default to CPU if not CUDA
    }
    return std::make_unique<InstrumentationPlan>(sdfg, nodes, loopnest_indices);
}

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
2	#include <memory>
3	#include <string>
4
5	#include "sdfg/analysis/analysis.h"
6	#include "sdfg/analysis/loop_analysis.h"
7	#include "sdfg/codegen/language_extension.h"
8	#include "sdfg/symbolic/symbolic.h"
9
10	namespace sdfg {
11	namespace codegen {
12
13	void InstrumentationPlan::update(const structured_control_flow::ControlFlowNode& node, InstrumentationEventType event_type) {	×
14	this->nodes_[&node] = event_type;	×
15	}	×
16
17	bool InstrumentationPlan::should_instrument(const structured_control_flow::ControlFlowNode& node) const {	60✔
18	return this->nodes_.count(&node);	60✔
19	}
20
21	void InstrumentationPlan::begin_instrumentation(	×
22	const structured_control_flow::ControlFlowNode& node, PrettyPrinter& stream, LanguageExtension& language_extension
23	) const {
24	auto& metadata = sdfg_.metadata();	×
25	std::string sdfg_name = sdfg_.name();	×
26	std::string sdfg_file = metadata.at("sdfg_file");	×
27	std::string arg_capture_path = metadata.at("arg_capture_path");	×
28	std::string features_file = metadata.at("features_file");	×
29	std::string opt_report_file = metadata.at("opt_report_file");	×
30
31	std::string region_uuid = sdfg_name + "_" + std::to_string(node.element_id());	×
32
33	// Create region id variable
34	std::string region_id_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_id";	×
35
36	// Create metadata variable
37	std::string metadata_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_md";	×
38	stream << "__daisy_metadata_t " << metadata_var << ";" << std::endl;	×
39
40	// Source metadata
41	auto& dbg_info = node.debug_info();	×
42	stream << metadata_var << ".file_name = \"" << dbg_info.filename() << "\";" << std::endl;	×
43	stream << metadata_var << ".function_name = \"" << dbg_info.function() << "\";" << std::endl;	×
44	stream << metadata_var << ".line_begin = " << dbg_info.start_line() << ";" << std::endl;	×
45	stream << metadata_var << ".line_end = " << dbg_info.end_line() << ";" << std::endl;	×
46	stream << metadata_var << ".column_begin = " << dbg_info.start_column() << ";" << std::endl;	×
47	stream << metadata_var << ".column_end = " << dbg_info.end_column() << ";" << std::endl;	×
48
49	// Docc metadata
50	stream << metadata_var << ".sdfg_name = \"" << sdfg_name << "\";" << std::endl;	×
51	stream << metadata_var << ".sdfg_file = \"" << sdfg_file << "\";" << std::endl;	×
52	stream << metadata_var << ".arg_capture_path = \"" << arg_capture_path << "\";" << std::endl;	×
53	stream << metadata_var << ".features_file = \"" << features_file << "\";" << std::endl;	×
54	stream << metadata_var << ".opt_report_file = \"" << opt_report_file << "\";" << std::endl;	×
55	stream << metadata_var << ".element_id = " << node.element_id() << ";" << std::endl;	×
56	if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(&node)) {	×
57	stream << metadata_var << ".element_type = \"map\";" << std::endl;	×
58	stream << metadata_var << ".target_type = \"" << map_node->schedule_type().value() << "\";" << std::endl;	×
59	} else if (dynamic_cast<const structured_control_flow::For*>(&node)) {	×
60	stream << metadata_var << ".element_type = \"for\";" << std::endl;	×
61	stream << metadata_var << ".target_type = \"SEQUENTIAL\";" << std::endl;	×
62	} else if (dynamic_cast<const structured_control_flow::While*>(&node)) {	×
63	stream << metadata_var << ".element_type = \"while\";" << std::endl;	×
64	stream << metadata_var << ".target_type = \"SEQUENTIAL\";" << std::endl;	×
65	} else {	×
66	stream << metadata_var << ".element_type = \"\";" << std::endl;	×
67	stream << metadata_var << ".target_type = \"\";" << std::endl;	×
68	}
69	if (!this->loopnest_indices_.empty()) {	×
70	stream << metadata_var << ".loopnest_index = " << this->loopnest_indices_.at(&node) << ";" << std::endl;	×
71	} else {	×
72	stream << metadata_var << ".loopnest_index = -1;" << std::endl;	×
73	}
74	stream << metadata_var << ".region_uuid = \"" << region_uuid << "\";" << std::endl;	×
75
76	// Initialize region
77	if (this->nodes_.at(&node) == InstrumentationEventType::CPU) {	×
78	stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var	×
79	<< ", __DAISY_EVENT_SET_CPU);" << std::endl;	×
80	} else {	×
81	stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var	×
82	<< ", __DAISY_EVENT_SET_CUDA);" << std::endl;	×
83	}
84
85	// Enter region
86	stream << "__daisy_instrumentation_enter(" << region_id_var << ");" << std::endl;	×
87	}	×
88
89	void InstrumentationPlan::end_instrumentation(	×
90	const structured_control_flow::ControlFlowNode& node, PrettyPrinter& stream, LanguageExtension& language_extension
91	) const {
92	std::string region_id_var = sdfg_.name() + "_" + std::to_string(node.element_id()) + "_id";	×
93
94	// Exit region
95	if (this->nodes_.at(&node) == InstrumentationEventType::CPU) {	×
96	stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;	×
97	} else {	×
98	stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;	×
99	}
100
101	// Perform FlopAnalysis
102	if (this->flops_.contains(&node)) {	×
103	auto flop = this->flops_.at(&node);	×
104	if (!flop.is_null()) {	×
NEW 105	if (symbolic::contains_dynamic_sizeof(flop)) {	×
NEW 106	stream << "// Could not generate \"flop\": " << flop->__str__() << std::endl;	×
NEW 107	} else {	×
NEW 108	std::string flop_str = language_extension.expression(flop);	×
NEW 109	stream << "__daisy_instrumentation_increment(" << region_id_var << ", \"flop\", " << flop_str << ");"	×
NEW 110	<< std::endl;	×
NEW 111	}	×
112	}	×
113	}	×
114
115	// Finalize region
116	stream << "__daisy_instrumentation_finalize(" << region_id_var << ");" << std::endl;	×
117	}	×
118
119	std::unique_ptr<InstrumentationPlan> InstrumentationPlan::none(StructuredSDFG& sdfg) {	49✔
120	return std::make_unique<InstrumentationPlan>(	49✔
121	sdfg, std::unordered_map<const structured_control_flow::ControlFlowNode*, InstrumentationEventType>{}	49✔
122	);
123	}	×
124
125	std::unique_ptr<InstrumentationPlan> InstrumentationPlan::outermost_loops_plan(StructuredSDFG& sdfg) {	×
126	analysis::AnalysisManager analysis_manager(sdfg);	×
127	auto& loop_tree_analysis = analysis_manager.get<analysis::LoopAnalysis>();	×
128	auto ols = loop_tree_analysis.outermost_loops();	×
129
130	std::unordered_map<const structured_control_flow::ControlFlowNode*, InstrumentationEventType> nodes;	×
131	std::unordered_map<const structured_control_flow::ControlFlowNode*, size_t> loopnest_indices;	×
132	for (size_t i = 0; i < ols.size(); i++) {	×
133	auto& loop = ols[i];	×
134	loopnest_indices[loop] = i;	×
135	if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(loop)) {	×
136	if (map_node->schedule_type().value() == "CUDA") {	×
137	nodes.insert({loop, InstrumentationEventType::CUDA});	×
138	continue;	×
139	}
140	}	×
141	nodes.insert({loop, InstrumentationEventType::CPU}); // Default to CPU if not CUDA	×
142	}	×
143	return std::make_unique<InstrumentationPlan>(sdfg, nodes, loopnest_indices);	×
144	}	×
145
146	} // namespace codegen
147	} // namespace sdfg

daisytuner / sdfglib / 18715914051

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous