19233097446

Committed 10 Nov 2025 01:22PM UTC coverage: 61.551% (+0.02%) from 61.533%

Build # 19233097446

Build Type

Pull #331

github

Committed by

web-flow

Commit Message

Merge bee958fc7 into 6b22fe1a8

Pull Request Pull Request #331: allow interpretation of pointers as ints in symbolic expressions

Run Details

54 of 95 new or added lines in 19 files covered. (56.84%)

3 existing lines in 3 files now uncovered.

10391 of 16882 relevant lines covered (61.55%)

107.15 hits per line

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

65.0

/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;
};

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
34	BreakDispatcher::BreakDispatcher(	2✔
35	LanguageExtension& language_extension,
36	StructuredSDFG& sdfg,
37	analysis::AnalysisManager& analysis_manager,
38	structured_control_flow::Break& node,
39	InstrumentationPlan& instrumentation_plan,
40	ArgCapturePlan& arg_capture_plan
41	)
42	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
43	node_(node) {	2✔
44
45	};	2✔
46
47	void BreakDispatcher::dispatch_node(	1✔
48	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
49	) {
50	main_stream << "break;" << std::endl;	1✔
51	};	1✔
52
53	ContinueDispatcher::ContinueDispatcher(	2✔
54	LanguageExtension& language_extension,
55	StructuredSDFG& sdfg,
56	analysis::AnalysisManager& analysis_manager,
57	structured_control_flow::Continue& node,
58	InstrumentationPlan& instrumentation_plan,
59	ArgCapturePlan& arg_capture_plan
60	)
61	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
62	node_(node) {	2✔
63
64	};	2✔
65
66	void ContinueDispatcher::dispatch_node(	1✔
67	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
68	) {
69	main_stream << "continue;" << std::endl;	1✔
70	};	1✔
71
72	ReturnDispatcher::ReturnDispatcher(	2✔
73	LanguageExtension& language_extension,
74	StructuredSDFG& sdfg,
75	analysis::AnalysisManager& analysis_manager,
76	structured_control_flow::Return& node,
77	InstrumentationPlan& instrumentation_plan,
78	ArgCapturePlan& arg_capture_plan
79	)
80	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	2✔
81	node_(node) {	2✔
82
83	};	2✔
84
85	void ReturnDispatcher::dispatch_node(	1✔
86	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
87	) {
88	// Free heap allocations
89	for (auto& container : sdfg_.containers()) {	1✔
90	if (sdfg_.is_external(container)) {	×
91	continue;	×
92	}
93	auto& type = sdfg_.type(container);	×
94
95	// Free if needed
96	if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {	×
97	if (type.storage_type().is_cpu_heap()) {	×
98	main_stream << language_extension_.external_prefix() << "free(" << container << ");" << std::endl;	×
99	} else if (type.storage_type().is_nv_generic()) {	×
100	main_stream << "cudaSetDevice(0);" << std::endl;	×
101	main_stream << "cudaFree(" << container << ");" << std::endl;	×
102	}	×
103	}	×
104	}
105
106	if (node_.is_data()) {	1✔
107	std::string return_str = node_.data();	1✔
108	if (sdfg_.is_external(node_.data())) {	1✔
109	return_str = "&" + this->language_extension_.external_prefix() + return_str;	×
110	}	×
111	main_stream << "return " << return_str << ";" << std::endl;	1✔
112	} else if (node_.is_constant()) {	1✔
113	if (symbolic::is_nullptr(symbolic::symbol(node_.data()))) {	×
NEW 114	if (this->language_extension_.language() == "C") {	×
NEW 115	main_stream << "return NULL;" << std::endl;	×
NEW 116	} else {	×
NEW 117	main_stream << "return nullptr;" << std::endl;	×
118	}
119	} else {	×
120	main_stream << "return " << node_.data() << ";" << std::endl;	×
121	}
122	}	×
123	};	1✔
124
125	} // namespace codegen
126	} // namespace sdfg

daisytuner / sdfglib / 19233097446

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