19265216942

Committed 11 Nov 2025 12:12PM UTC coverage: 61.767%. Remained the same

Build # 19265216942

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #341 from daisytuner/reenable-feature-dump

Make feature file optional in instrumentation

Run Details

3 of 8 new or added lines in 2 files covered. (37.5%)

1 existing line in 1 file now uncovered.

10538 of 17061 relevant lines covered (61.77%)

107.11 hits per line

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

3.13

/src/codegen/instrumentation/instrumentation_plan.cpp

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

#include "sdfg/analysis/analysis.h"
#include "sdfg/analysis/loop_analysis.h"
#include "sdfg/codegen/language_extension.h"
#include "sdfg/element.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 Element& node) const { return this->nodes_.count(&node); }

void InstrumentationPlan::begin_instrumentation(
    const Element& node, PrettyPrinter& stream, LanguageExtension& language_extension, const InstrumentationInfo& info
) 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;
    if (auto it = metadata.find("features_file"); it != metadata.end()) {
        features_file = it->second;
    } else {
        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 = " << info.element_id() << ";" << std::endl;
    stream << metadata_var << ".element_type = \"" << info.element_type().value() << "\";" << std::endl;
    stream << metadata_var << ".target_type = \"" << info.target_type().value() << "\";" << std::endl;
    stream << metadata_var << ".loopnest_index = " << info.loopnest_index() << ";" << std::endl;
    stream << metadata_var << ".region_uuid = \"" << region_uuid << "\";" << std::endl;

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

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

void InstrumentationPlan::end_instrumentation(
    const Element& node, PrettyPrinter& stream, LanguageExtension& language_extension, const InstrumentationInfo& info
) 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;
    }

    for (auto entry : info.metrics()) {
        stream << "__daisy_instrumentation_increment(" << region_id_var << ", \"" << entry.first << "\", "
               << entry.second << ");" << 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 Element*, 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 Element*, InstrumentationEventType> nodes;
    for (size_t i = 0; i < ols.size(); i++) {
        auto& loop = ols[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
    }

    LibNodeFinder lib_node_finder(sdfg, analysis_manager);
    lib_node_finder.visit();
    for (auto& lib_node : lib_node_finder.get_lib_nodes_D2H()) {
        nodes.insert({lib_node, InstrumentationEventType::NONE});
    }
    for (auto& lib_node : lib_node_finder.get_lib_nodes_H2D()) {
        nodes.insert({lib_node, InstrumentationEventType::NONE});
    }

    std::cout << "Created instrumentation plan for " << nodes.size() << " nodes." << std::endl;

    return std::make_unique<InstrumentationPlan>(sdfg, nodes);
}

bool LibNodeFinder::accept(structured_control_flow::Block& node) {
    for (auto libnode : node.dataflow().library_nodes()) {
        if (libnode->code().value() == "CUDAD2HTransfer" || libnode->code().value() == "TTEnqueueRead") {
            lib_nodes_D2H.push_back(libnode);
        }
        if (libnode->code().value() == "CUDAH2DTransfer" || libnode->code().value() == "TTEnqueueWrite") {
            lib_nodes_H2D.push_back(libnode);
        }
    }
    return false;
}

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
2	#include <iostream>
3	#include <memory>
4	#include <string>
5	#include <utility>
6
7	#include "sdfg/analysis/analysis.h"
8	#include "sdfg/analysis/loop_analysis.h"
9	#include "sdfg/codegen/language_extension.h"
10	#include "sdfg/element.h"
11	#include "sdfg/symbolic/symbolic.h"
12
13	namespace sdfg {
14	namespace codegen {
15
16	void InstrumentationPlan::update(const structured_control_flow::ControlFlowNode& node, InstrumentationEventType event_type) {	×
17	this->nodes_[&node] = event_type;	×
18	}	×
19
20	bool InstrumentationPlan::should_instrument(const Element& node) const { return this->nodes_.count(&node); }	62✔
21
22	void InstrumentationPlan::begin_instrumentation(	×
23	const Element& node, PrettyPrinter& stream, LanguageExtension& language_extension, const InstrumentationInfo& info
24	) const {
25	auto& metadata = sdfg_.metadata();	×
26	std::string sdfg_name = sdfg_.name();	×
27	std::string sdfg_file = metadata.at("sdfg_file");	×
28	std::string arg_capture_path = metadata.at("arg_capture_path");	×
NEW 29	std::string features_file;	×
NEW 30	if (auto it = metadata.find("features_file"); it != metadata.end()) {	×
NEW 31	features_file = it->second;	×
NEW 32	} else {	×
NEW 33	features_file = "";	×
34	}
35
UNCOV 36	std::string opt_report_file = metadata.at("opt_report_file");	×
37
38	std::string region_uuid = sdfg_name + "_" + std::to_string(node.element_id());	×
39
40	// Create region id variable
41	std::string region_id_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_id";	×
42
43	// Create metadata variable
44	std::string metadata_var = sdfg_name + "_" + std::to_string(node.element_id()) + "_md";	×
45	stream << "__daisy_metadata_t " << metadata_var << ";" << std::endl;	×
46
47	// Source metadata
48	auto& dbg_info = node.debug_info();	×
49	stream << metadata_var << ".file_name = \"" << dbg_info.filename() << "\";" << std::endl;	×
50	stream << metadata_var << ".function_name = \"" << dbg_info.function() << "\";" << std::endl;	×
51	stream << metadata_var << ".line_begin = " << dbg_info.start_line() << ";" << std::endl;	×
52	stream << metadata_var << ".line_end = " << dbg_info.end_line() << ";" << std::endl;	×
53	stream << metadata_var << ".column_begin = " << dbg_info.start_column() << ";" << std::endl;	×
54	stream << metadata_var << ".column_end = " << dbg_info.end_column() << ";" << std::endl;	×
55
56	// Docc metadata
57	stream << metadata_var << ".sdfg_name = \"" << sdfg_name << "\";" << std::endl;	×
58	stream << metadata_var << ".sdfg_file = \"" << sdfg_file << "\";" << std::endl;	×
59	stream << metadata_var << ".arg_capture_path = \"" << arg_capture_path << "\";" << std::endl;	×
60	stream << metadata_var << ".features_file = \"" << features_file << "\";" << std::endl;	×
61	stream << metadata_var << ".opt_report_file = \"" << opt_report_file << "\";" << std::endl;	×
62	stream << metadata_var << ".element_id = " << info.element_id() << ";" << std::endl;	×
63	stream << metadata_var << ".element_type = \"" << info.element_type().value() << "\";" << std::endl;	×
64	stream << metadata_var << ".target_type = \"" << info.target_type().value() << "\";" << std::endl;	×
65	stream << metadata_var << ".loopnest_index = " << info.loopnest_index() << ";" << std::endl;	×
66	stream << metadata_var << ".region_uuid = \"" << region_uuid << "\";" << std::endl;	×
67
68	// Initialize region
69	switch (this->nodes_.at(&node)) {	×
70	case InstrumentationEventType::CPU: {
71	stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var	×
72	<< ", __DAISY_EVENT_SET_CPU);" << std::endl;	×
73	break;	×
74	}
75	case InstrumentationEventType::CUDA: {
76	stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var	×
77	<< ", __DAISY_EVENT_SET_CUDA);" << std::endl;	×
78	break;	×
79	}
80	case InstrumentationEventType::NONE: {
81	stream << "long long " << region_id_var << " = __daisy_instrumentation_init(&" << metadata_var	×
82	<< ", __DAISY_EVENT_SET_NONE);" << std::endl;	×
83	break;	×
84	}
85	}
86
87	// Enter region
88	stream << "__daisy_instrumentation_enter(" << region_id_var << ");" << std::endl;	×
89	}	×
90
91	void InstrumentationPlan::end_instrumentation(	×
92	const Element& node, PrettyPrinter& stream, LanguageExtension& language_extension, const InstrumentationInfo& info
93	) const {
94	std::string region_id_var = sdfg_.name() + "_" + std::to_string(node.element_id()) + "_id";	×
95
96	// Exit region
97	if (this->nodes_.at(&node) == InstrumentationEventType::CPU) {	×
98	stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;	×
99	} else {	×
100	stream << "__daisy_instrumentation_exit(" << region_id_var << ");" << std::endl;	×
101	}
102
103	for (auto entry : info.metrics()) {	×
104	stream << "__daisy_instrumentation_increment(" << region_id_var << ", \"" << entry.first << "\", "	×
105	<< entry.second << ");" << std::endl;	×
106	}	×
107
108	// Finalize region
109	stream << "__daisy_instrumentation_finalize(" << region_id_var << ");" << std::endl;	×
110	}	×
111
112	std::unique_ptr<InstrumentationPlan> InstrumentationPlan::none(StructuredSDFG& sdfg) {	53✔
113	return std::make_unique<InstrumentationPlan>(sdfg, std::unordered_map<const Element*, InstrumentationEventType>{});	53✔
114	}	×
115
116	std::unique_ptr<InstrumentationPlan> InstrumentationPlan::outermost_loops_plan(StructuredSDFG& sdfg) {	×
117	analysis::AnalysisManager analysis_manager(sdfg);	×
118	auto& loop_tree_analysis = analysis_manager.get<analysis::LoopAnalysis>();	×
119	auto ols = loop_tree_analysis.outermost_loops();	×
120
121	std::unordered_map<const Element*, InstrumentationEventType> nodes;	×
122	for (size_t i = 0; i < ols.size(); i++) {	×
123	auto& loop = ols[i];	×
124	if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(loop)) {	×
125	if (map_node->schedule_type().value() == "CUDA") {	×
126	nodes.insert({loop, InstrumentationEventType::CUDA});	×
127	continue;	×
128	}
129	}	×
130	nodes.insert({loop, InstrumentationEventType::CPU}); // Default to CPU if not CUDA	×
131	}	×
132
133	LibNodeFinder lib_node_finder(sdfg, analysis_manager);	×
134	lib_node_finder.visit();	×
135	for (auto& lib_node : lib_node_finder.get_lib_nodes_D2H()) {	×
136	nodes.insert({lib_node, InstrumentationEventType::NONE});	×
137	}
138	for (auto& lib_node : lib_node_finder.get_lib_nodes_H2D()) {	×
139	nodes.insert({lib_node, InstrumentationEventType::NONE});	×
140	}
141
142	std::cout << "Created instrumentation plan for " << nodes.size() << " nodes." << std::endl;	×
143
144	return std::make_unique<InstrumentationPlan>(sdfg, nodes);	×
145	}	×
146
147	bool LibNodeFinder::accept(structured_control_flow::Block& node) {	×
148	for (auto libnode : node.dataflow().library_nodes()) {	×
149	if (libnode->code().value() == "CUDAD2HTransfer" \|\| libnode->code().value() == "TTEnqueueRead") {	×
150	lib_nodes_D2H.push_back(libnode);	×
151	}	×
152	if (libnode->code().value() == "CUDAH2DTransfer" \|\| libnode->code().value() == "TTEnqueueWrite") {	×
153	lib_nodes_H2D.push_back(libnode);	×
154	}	×
155	}
156	return false;	×
157	}	×
158
159	} // namespace codegen
160	} // namespace sdfg

daisytuner / sdfglib / 19265216942

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