16188914472

Committed 10 Jul 2025 07:30AM UTC coverage: 64.808% (+0.1%) from 64.705%

Build # 16188914472

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #138 from daisytuner/tenstorrent/trivial

lib_stream -> lib_snippet_factory in code generation

Run Details

131 of 243 new or added lines in 18 files covered. (53.91%)

3 existing lines in 3 files now uncovered.

8545 of 13185 relevant lines covered (64.81%)

179.13 hits per line

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

66.15

/src/codegen/dispatchers/map_dispatcher.cpp

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

#include "sdfg/analysis/users.h"
#include "sdfg/codegen/dispatchers/sequence_dispatcher.h"

namespace sdfg {
namespace codegen {

MapDispatcher::MapDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    structured_control_flow::Map& node,
    Instrumentation& instrumentation
)
    : NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {

      };

void MapDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    auto dispatcher = MapDispatcherRegistry::instance().get_map_dispatcher(node_.schedule_type().value());
    if (dispatcher) {
        auto dispatcher_ptr = dispatcher(language_extension_, sdfg_, node_, instrumentation_);
        dispatcher_ptr->dispatch_node(main_stream, globals_stream, library_snippet_factory);
    } else {
        throw std::runtime_error("Unsupported map schedule type: " + std::string(node_.schedule_type().value()));
    }
};

SequentialMapDispatcher::SequentialMapDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    structured_control_flow::Map& node,
    Instrumentation& instrumentation
)
    : NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {

      };

void SequentialMapDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    main_stream << "// Map" << std::endl;
    main_stream << "for";
    main_stream << "(";
    main_stream << node_.indvar()->get_name();
    main_stream << " = ";
    main_stream << language_extension_.expression(node_.init());
    main_stream << ";";
    main_stream << language_extension_.expression(node_.condition());
    main_stream << ";";
    main_stream << node_.indvar()->get_name();
    main_stream << " = ";
    main_stream << language_extension_.expression(node_.update());
    main_stream << ")" << std::endl;
    main_stream << "{" << std::endl;

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

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

CPUParallelMapDispatcher::CPUParallelMapDispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    structured_control_flow::Map& node,
    Instrumentation& instrumentation
)
    : NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {

      };

void CPUParallelMapDispatcher::dispatch_node(
    PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
) {
    // Mark written locals as private
    analysis::AnalysisManager analysis_manager(sdfg_);
    auto& users = analysis_manager.get<analysis::Users>();
    analysis::UsersView users_view(users, node_.root());

    std::vector<std::string> locals;
    for (auto& entry : users.locals(node_.root())) {
        if (users_view.writes(entry).size() > 0) {
            locals.push_back(entry);
        }
    }

    // Generate code
    main_stream << "#pragma omp parallel for";
    if (locals.size() > 0) {
        main_stream << " private(" << helpers::join(locals, ", ") << ")";
    }
    main_stream << std::endl;

    SequentialMapDispatcher dispatcher(language_extension_, sdfg_, node_, instrumentation_);
    dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);
};

void register_default_map_dispatchers() {
    MapDispatcherRegistry::instance().register_map_dispatcher(
        structured_control_flow::ScheduleType_Sequential.value(),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           structured_control_flow::Map& node,
           Instrumentation& instrumentation) {
            return std::make_unique<SequentialMapDispatcher>(language_extension, sdfg, node, instrumentation);
        }
    );
    MapDispatcherRegistry::instance().register_map_dispatcher(
        structured_control_flow::ScheduleType_CPU_Parallel.value(),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           structured_control_flow::Map& node,
           Instrumentation& instrumentation) {
            return std::make_unique<CPUParallelMapDispatcher>(language_extension, sdfg, node, instrumentation);
        }
    );
}

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/dispatchers/map_dispatcher.h"
2
3	#include "sdfg/analysis/users.h"
4	#include "sdfg/codegen/dispatchers/sequence_dispatcher.h"
5
6	namespace sdfg {
7	namespace codegen {
8
9	MapDispatcher::MapDispatcher(	1✔
10	LanguageExtension& language_extension,
11	StructuredSDFG& sdfg,
12	structured_control_flow::Map& node,
13	Instrumentation& instrumentation
14	)
15	: NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {	1✔
16
17	};	1✔
18
19	void MapDispatcher::dispatch_node(	1✔
20	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
21	) {
22	auto dispatcher = MapDispatcherRegistry::instance().get_map_dispatcher(node_.schedule_type().value());	1✔
23	if (dispatcher) {	1✔
24	auto dispatcher_ptr = dispatcher(language_extension_, sdfg_, node_, instrumentation_);	1✔
25	dispatcher_ptr->dispatch_node(main_stream, globals_stream, library_snippet_factory);	1✔
26	} else {	1✔
NEW 27	throw std::runtime_error("Unsupported map schedule type: " + std::string(node_.schedule_type().value()));	×
28	}
29	};	1✔
30
31	SequentialMapDispatcher::SequentialMapDispatcher(	1✔
32	LanguageExtension& language_extension,
33	StructuredSDFG& sdfg,
34	structured_control_flow::Map& node,
35	Instrumentation& instrumentation
36	)
37	: NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {	1✔
38
39	};	1✔
40
41	void SequentialMapDispatcher::dispatch_node(	1✔
42	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
43	) {
44	main_stream << "// Map" << std::endl;	1✔
45	main_stream << "for";	1✔
46	main_stream << "(";	1✔
47	main_stream << node_.indvar()->get_name();	1✔
48	main_stream << " = ";	1✔
49	main_stream << language_extension_.expression(node_.init());	1✔
50	main_stream << ";";	1✔
51	main_stream << language_extension_.expression(node_.condition());	1✔
52	main_stream << ";";	1✔
53	main_stream << node_.indvar()->get_name();	1✔
54	main_stream << " = ";	1✔
55	main_stream << language_extension_.expression(node_.update());	1✔
56	main_stream << ")" << std::endl;	1✔
57	main_stream << "{" << std::endl;	1✔
58
59	main_stream.setIndent(main_stream.indent() + 4);	1✔
60	SequenceDispatcher dispatcher(language_extension_, sdfg_, node_.root(), instrumentation_);	1✔
61	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	1✔
62	main_stream.setIndent(main_stream.indent() - 4);	1✔
63
64	main_stream << "}" << std::endl;	1✔
65	};	1✔
66
NEW 67	CPUParallelMapDispatcher::CPUParallelMapDispatcher(	×
68	LanguageExtension& language_extension,
69	StructuredSDFG& sdfg,
70	structured_control_flow::Map& node,
71	Instrumentation& instrumentation
72	)
UNCOV 73	: NodeDispatcher(language_extension, sdfg, node, instrumentation), node_(node) {	×
74
75	};	×
76
NEW 77	void CPUParallelMapDispatcher::dispatch_node(	×
78	PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
79	) {
80	// Mark written locals as private
81	analysis::AnalysisManager analysis_manager(sdfg_);	×
82	auto& users = analysis_manager.get<analysis::Users>();	×
83	analysis::UsersView users_view(users, node_.root());	×
84
85	std::vector<std::string> locals;	×
86	for (auto& entry : users.locals(node_.root())) {	×
87	if (users_view.writes(entry).size() > 0) {	×
88	locals.push_back(entry);	×
89	}	×
90	}
91
92	// Generate code
93	main_stream << "#pragma omp parallel for";	×
94	if (locals.size() > 0) {	×
95	main_stream << " private(" << helpers::join(locals, ", ") << ")";	×
96	}	×
97	main_stream << std::endl;	×
98
99	SequentialMapDispatcher dispatcher(language_extension_, sdfg_, node_, instrumentation_);	×
NEW 100	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	×
101	};	×
102
103	void register_default_map_dispatchers() {	2✔
104	MapDispatcherRegistry::instance().register_map_dispatcher(	4✔
105	structured_control_flow::ScheduleType_Sequential.value(),	2✔
106	[](LanguageExtension& language_extension,	3✔
107	StructuredSDFG& sdfg,
108	structured_control_flow::Map& node,
109	Instrumentation& instrumentation) {
110	return std::make_unique<SequentialMapDispatcher>(language_extension, sdfg, node, instrumentation);	1✔
111	}
112	);
113	MapDispatcherRegistry::instance().register_map_dispatcher(	4✔
114	structured_control_flow::ScheduleType_CPU_Parallel.value(),	2✔
115	[](LanguageExtension& language_extension,	2✔
116	StructuredSDFG& sdfg,
117	structured_control_flow::Map& node,
118	Instrumentation& instrumentation) {
NEW 119	return std::make_unique<CPUParallelMapDispatcher>(language_extension, sdfg, node, instrumentation);	×
120	}
121	);
122	}	2✔
123
124	} // namespace codegen
125	} // namespace sdfg

daisytuner / sdfglib / 16188914472

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