18896739436

Committed 28 Oct 2025 03:45PM UTC coverage: 62.202% (-0.1%) from 62.303%

Build # 18896739436

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #311 from daisytuner/storage-types

Storage types improvements

Run Details

15 of 48 new or added lines in 3 files covered. (31.25%)

11 existing lines in 2 files now uncovered.

10119 of 16268 relevant lines covered (62.2%)

101.66 hits per line

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

64.29

/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
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_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_);
    dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);
    main_stream.setIndent(main_stream.indent() - 4);

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

BreakDispatcher::BreakDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::Break& node,
    InstrumentationPlan& instrumentation_plan
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_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
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_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
)
    : NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_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_.unreachable()) {
        main_stream << "/* unreachable return */" << std::endl;
    } else 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()))) {
            main_stream << "return " << this->language_extension_.expression(symbolic::symbol(node_.data())) << ";"
                        << 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	)
13	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan), node_(node) {	2✔
14
15	};	2✔
16
17	void WhileDispatcher::dispatch_node(	1✔
18	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
19	) {
20	main_stream << "while (1)" << std::endl;	1✔
21	main_stream << "{" << std::endl;	1✔
22
23	main_stream.setIndent(main_stream.indent() + 4);	1✔
24	SequenceDispatcher dispatcher(language_extension_, sdfg_, analysis_manager_, node_.root(), instrumentation_plan_);	1✔
25	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	1✔
26	main_stream.setIndent(main_stream.indent() - 4);	1✔
27
28	main_stream << "}" << std::endl;	1✔
29	};	1✔
30
31	BreakDispatcher::BreakDispatcher(	2✔
32	LanguageExtension& language_extension,
33	StructuredSDFG& sdfg,
34	analysis::AnalysisManager& analysis_manager,
35	structured_control_flow::Break& node,
36	InstrumentationPlan& instrumentation_plan
37	)
38	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan), node_(node) {	2✔
39
40	};	2✔
41
42	void BreakDispatcher::dispatch_node(	1✔
43	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
44	) {
45	main_stream << "break;" << std::endl;	1✔
46	};	1✔
47
48	ContinueDispatcher::ContinueDispatcher(	2✔
49	LanguageExtension& language_extension,
50	StructuredSDFG& sdfg,
51	analysis::AnalysisManager& analysis_manager,
52	structured_control_flow::Continue& node,
53	InstrumentationPlan& instrumentation_plan
54	)
55	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan), node_(node) {	2✔
56
57	};	2✔
58
59	void ContinueDispatcher::dispatch_node(	1✔
60	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
61	) {
62	main_stream << "continue;" << std::endl;	1✔
63	};	1✔
64
65	ReturnDispatcher::ReturnDispatcher(	2✔
66	LanguageExtension& language_extension,
67	StructuredSDFG& sdfg,
68	analysis::AnalysisManager& analysis_manager,
69	structured_control_flow::Return& node,
70	InstrumentationPlan& instrumentation_plan
71	)
72	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan), node_(node) {	2✔
73
74	};	2✔
75
76	void ReturnDispatcher::dispatch_node(	1✔
77	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
78	) {
79	// Free heap allocations
80	for (auto& container : sdfg_.containers()) {	1✔
NEW 81	if (sdfg_.is_external(container)) {	×
NEW 82	continue;	×
83	}
NEW 84	auto& type = sdfg_.type(container);	×
85
86	// Free if needed
NEW 87	if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {	×
NEW 88	if (type.storage_type().is_cpu_heap()) {	×
NEW 89	main_stream << language_extension_.external_prefix() << "free(" << container << ");" << std::endl;	×
NEW 90	} else if (type.storage_type().is_nv_generic()) {	×
NEW 91	main_stream << "cudaSetDevice(0);" << std::endl;	×
NEW 92	main_stream << "cudaFree(" << container << ");" << std::endl;	×
NEW 93	}	×
NEW 94	}	×
95	}
96
97	if (node_.unreachable()) {	1✔
98	main_stream << "/* unreachable return */" << std::endl;	×
99	} else if (node_.is_data()) {	1✔
100	std::string return_str = node_.data();	1✔
101	if (sdfg_.is_external(node_.data())) {	1✔
102	return_str = "&" + this->language_extension_.external_prefix() + return_str;	×
103	}	×
104	main_stream << "return " << return_str << ";" << std::endl;	1✔
105	} else if (node_.is_constant()) {	1✔
106	if (symbolic::is_nullptr(symbolic::symbol(node_.data()))) {	×
107	main_stream << "return " << this->language_extension_.expression(symbolic::symbol(node_.data())) << ";"	×
108	<< std::endl;	×
109	} else {	×
110	main_stream << "return " << node_.data() << ";" << std::endl;	×
111	}
112	}	×
113	};	1✔
114
115	} // namespace codegen
116	} // namespace sdfg

daisytuner / sdfglib / 18896739436

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