20498791379

Committed 24 Dec 2025 12:27PM UTC coverage: 39.109% (+0.05%) from 39.061%

Build # 20498791379

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #406 from daisytuner/loop-info-inst

move loopnest index into loop info

Run Details

13537 of 44946 branches covered (30.12%)

Branch coverage included in aggregate %.

15 of 46 new or added lines in 9 files covered. (32.61%)

1 existing line in 1 file now uncovered.

11669 of 19504 relevant lines covered (59.83%)

84.09 hits per line

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

41.74

/src/codegen/dispatchers/while_dispatcher.cpp

#include "sdfg/codegen/dispatchers/while_dispatcher.h"

namespace sdfg {
namespace codegen {

WhileDispatcher::WhileDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::While& node,
    InstrumentationPlan& instrumentation_plan,
    ArgCapturePlan& arg_capture_plan
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),
      node_(node) {

      };

void WhileDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    main_stream << "while (1)" << std::endl;
    main_stream << "{" << std::endl;

    main_stream.setIndent(main_stream.indent() + 4);
    SequenceDispatcher
        dispatcher(language_extension_, sdfg_, analysis_manager_, node_.root(), instrumentation_plan_, arg_capture_plan_);
    dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);
    main_stream.setIndent(main_stream.indent() - 4);

    main_stream << "}" << std::endl;
};

InstrumentationInfo WhileDispatcher::instrumentation_info() const {
    auto& loop_analysis = analysis_manager_.get<analysis::LoopAnalysis>();
    analysis::LoopInfo loop_info = loop_analysis.loop_info(&node_);

    return InstrumentationInfo(node_.element_id(), ElementType_While, TargetType_SEQUENTIAL, loop_info);
};

BreakDispatcher::BreakDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::Break& node,
    InstrumentationPlan& instrumentation_plan,
    ArgCapturePlan& arg_capture_plan
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),
      node_(node) {

      };

void BreakDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    main_stream << "break;" << std::endl;
};

ContinueDispatcher::ContinueDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::Continue& node,
    InstrumentationPlan& instrumentation_plan,
    ArgCapturePlan& arg_capture_plan
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),
      node_(node) {

      };

void ContinueDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    main_stream << "continue;" << std::endl;
};

ReturnDispatcher::ReturnDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::Return& node,
    InstrumentationPlan& instrumentation_plan,
    ArgCapturePlan& arg_capture_plan
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),
      node_(node) {

      };

void ReturnDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    // Free heap allocations
    for (auto& container : sdfg_.containers()) {
        if (sdfg_.is_external(container)) {
            continue;
        }
        auto& type = sdfg_.type(container);

        // Free if needed
        if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {
            if (type.storage_type().is_cpu_heap()) {
                main_stream << language_extension_.external_prefix() << "free(" << container << ");" << std::endl;
            } else if (type.storage_type().is_nv_generic()) {
                main_stream << "cudaSetDevice(0);" << std::endl;
                main_stream << "cudaFree(" << container << ");" << std::endl;
            }
        }
    }

    if (node_.is_data()) {
        std::string return_str = node_.data();
        if (sdfg_.is_external(node_.data())) {
            return_str = "&" + this->language_extension_.external_prefix() + return_str;
        }
        main_stream << "return " << return_str << ";" << std::endl;
    } else if (node_.is_constant()) {
        if (symbolic::is_nullptr(symbolic::symbol(node_.data()))) {
            if (this->language_extension_.language() == "C") {
                main_stream << "return NULL;" << std::endl;
            } else {
                main_stream << "return nullptr;" << std::endl;
            }
        } else {
            main_stream << "return " << node_.data() << ";" << std::endl;
        }
    }
};

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/dispatchers/while_dispatcher.h"
2
3	namespace sdfg {
4	namespace codegen {
5
6	WhileDispatcher::WhileDispatcher(	2✔
7	LanguageExtension& language_extension,
8	StructuredSDFG& sdfg,
9	analysis::AnalysisManager& analysis_manager,
10	structured_control_flow::While& node,
11	InstrumentationPlan& instrumentation_plan,
12	ArgCapturePlan& arg_capture_plan
13	)
14	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
15	node_(node) {	2✔
16
17	};	2✔
18
19	void WhileDispatcher::dispatch_node(	1✔
20	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
21	) {
22	main_stream << "while (1)" << std::endl;	1✔
23	main_stream << "{" << std::endl;	1✔
24
25	main_stream.setIndent(main_stream.indent() + 4);	1✔
26	SequenceDispatcher
27	dispatcher(language_extension_, sdfg_, analysis_manager_, node_.root(), instrumentation_plan_, arg_capture_plan_);	1✔
28	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	1✔
29	main_stream.setIndent(main_stream.indent() - 4);	1✔
30
31	main_stream << "}" << std::endl;	1✔
32	};	1✔
33
NEW 34	InstrumentationInfo WhileDispatcher::instrumentation_info() const {	×
NEW 35	auto& loop_analysis = analysis_manager_.get<analysis::LoopAnalysis>();	×
NEW 36	analysis::LoopInfo loop_info = loop_analysis.loop_info(&node_);	×
37
NEW 38	return InstrumentationInfo(node_.element_id(), ElementType_While, TargetType_SEQUENTIAL, loop_info);	×
NEW 39	};	×
40
41	BreakDispatcher::BreakDispatcher(	2✔
42	LanguageExtension& language_extension,
43	StructuredSDFG& sdfg,
44	analysis::AnalysisManager& analysis_manager,
45	structured_control_flow::Break& node,
46	InstrumentationPlan& instrumentation_plan,
47	ArgCapturePlan& arg_capture_plan
48	)
49	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
50	node_(node) {	2✔
51
52	};	2✔
53
54	void BreakDispatcher::dispatch_node(	1✔
55	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
56	) {
57	main_stream << "break;" << std::endl;	1✔
58	};	1✔
59
60	ContinueDispatcher::ContinueDispatcher(	2✔
61	LanguageExtension& language_extension,
62	StructuredSDFG& sdfg,
63	analysis::AnalysisManager& analysis_manager,
64	structured_control_flow::Continue& node,
65	InstrumentationPlan& instrumentation_plan,
66	ArgCapturePlan& arg_capture_plan
67	)
68	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
69	node_(node) {	2✔
70
71	};	2✔
72
73	void ContinueDispatcher::dispatch_node(	1✔
74	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
75	) {
76	main_stream << "continue;" << std::endl;	1✔
77	};	1✔
78
79	ReturnDispatcher::ReturnDispatcher(	2✔
80	LanguageExtension& language_extension,
81	StructuredSDFG& sdfg,
82	analysis::AnalysisManager& analysis_manager,
83	structured_control_flow::Return& node,
84	InstrumentationPlan& instrumentation_plan,
85	ArgCapturePlan& arg_capture_plan
86	)
87	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
88	node_(node) {	2✔
89
90	};	2✔
91
92	void ReturnDispatcher::dispatch_node(	1✔
93	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
94	) {
95	// Free heap allocations
96	for (auto& container : sdfg_.containers()) {	1!
97	if (sdfg_.is_external(container)) {	×
98	continue;	×
99	}
100	auto& type = sdfg_.type(container);	×
101
102	// Free if needed
103	if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {	×
104	if (type.storage_type().is_cpu_heap()) {	×
105	main_stream << language_extension_.external_prefix() << "free(" << container << ");" << std::endl;	×
106	} else if (type.storage_type().is_nv_generic()) {	×
107	main_stream << "cudaSetDevice(0);" << std::endl;	×
108	main_stream << "cudaFree(" << container << ");" << std::endl;	×
109	}	×
110	}	×
111	}
112
113	if (node_.is_data()) {	1!
114	std::string return_str = node_.data();	1✔
115	if (sdfg_.is_external(node_.data())) {	1!
116	return_str = "&" + this->language_extension_.external_prefix() + return_str;	×
117	}	×
118	main_stream << "return " << return_str << ";" << std::endl;	1!
119	} else if (node_.is_constant()) {	1!
120	if (symbolic::is_nullptr(symbolic::symbol(node_.data()))) {	×
121	if (this->language_extension_.language() == "C") {	×
122	main_stream << "return NULL;" << std::endl;	×
123	} else {	×
124	main_stream << "return nullptr;" << std::endl;	×
125	}
126	} else {	×
127	main_stream << "return " << node_.data() << ";" << std::endl;	×
128	}
129	}	×
130	};	1✔
131
132	} // namespace codegen
133	} // namespace sdfg

daisytuner / sdfglib / 20498791379

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