15829336677

Committed 23 Jun 2025 04:06PM UTC coverage: 64.191% (-0.002%) from 64.193%

Build # 15829336677

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #101 from daisytuner/auto-parallelization

Auto parallelization

Run Details

18 of 42 new or added lines in 3 files covered. (42.86%)

8219 of 12804 relevant lines covered (64.19%)

135.84 hits per line

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

64.71

/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,
                                  PrettyPrinter& library_stream) {
    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_stream);
    } 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,
                                            PrettyPrinter& library_stream) {
    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_stream);
    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,
                                             PrettyPrinter& library_stream) {
    // 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_stream);
};

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

daisytuner / sdfglib / 15829336677

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