21098439361

Committed 17 Jan 2026 05:47PM UTC coverage: 64.664% (-0.06%) from 64.728%

Build # 21098439361

Build Type

Pull #459

github

Committed by

web-flow

Commit Message

Merge 2723168ea into b09ddf4fd

Pull Request Pull Request #459: Adds OMPScheduler and PollyScheduler

Run Details

220 of 375 new or added lines in 13 files covered. (58.67%)

44 existing lines in 2 files now uncovered.

19129 of 29582 relevant lines covered (64.66%)

394.2 hits per line

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

50.0

/opt/src/targets/omp/codegen/omp_map_dispatcher.cpp

#include "sdfg/targets/omp/codegen/omp_map_dispatcher.h"

#include "sdfg/targets/omp/schedule.h"

#include <sdfg/analysis/loop_analysis.h>
#include <sdfg/analysis/users.h>
#include <sdfg/codegen/dispatchers/node_dispatcher_registry.h>
#include <sdfg/codegen/dispatchers/sequence_dispatcher.h>
#include <sdfg/codegen/instrumentation/instrumentation_info.h>
#include <sdfg/structured_control_flow/map.h>

namespace sdfg {
namespace omp {

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

      };

void OMPMapDispatcher::dispatch_node(
    codegen::PrettyPrinter& main_stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::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 || users_view.moves(entry).size() > 0) {
            locals.push_back(entry);
        }
    }

    // Generate code
    main_stream << "// Map" << std::endl;
    main_stream << "#pragma omp parallel for";

    main_stream << " schedule(";
    if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Static) {
        main_stream << "static)";
    } else if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Dynamic) {
        main_stream << "dynamic)";
    } else if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Guided) {
        main_stream << "guided)";
    } else {
        throw std::runtime_error("Unsupported OpenMP schedule type");
    }

    if (!ScheduleType_OMP::num_threads(node_.schedule_type()).is_null()) {
        main_stream << " num_threads(";
        main_stream << language_extension_.expression(ScheduleType_OMP::num_threads(node_.schedule_type()));
        main_stream << ")";
    }

    if (locals.size() > 0) {
        main_stream << " private(" << helpers::join(locals, ", ") << ")";
    }
    main_stream << 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;

    for (auto& local : locals) {
        auto& type = sdfg_.type(local);
        if (type.storage_type().allocation() == types::StorageType::AllocationType::Managed) {
            if (type.storage_type().is_cpu_stack()) {
                main_stream << local << " = ";
                main_stream << "alloca(" << language_extension_.expression(type.storage_type().allocation_size())
                            << ")";
                main_stream << ";" << std::endl;
            } else if (type.storage_type().is_cpu_heap()) {
                main_stream << local << " = ";
                main_stream << language_extension_.external_prefix() << "malloc("
                            << language_extension_.expression(type.storage_type().allocation_size()) << ")";
                main_stream << ";" << std::endl;
            }
        }
    }

    main_stream.setIndent(main_stream.indent() + 4);
    codegen::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);

    for (auto& local : locals) {
        auto& type = sdfg_.type(local);
        if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {
            if (type.storage_type().is_cpu_heap()) {
                main_stream << language_extension_.external_prefix() << "free(" << local << ");" << std::endl;
            }
        }
    }

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

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

    // Perform FlopAnalysis
    std::unordered_map<std::string, std::string> metrics;
    auto& flop_analysis = analysis_manager_.get<analysis::FlopAnalysis>();
    auto flop = flop_analysis.get_if_available_for_codegen(&node_);
    if (!flop.is_null()) {
        std::string flop_str = language_extension_.expression(flop);
        metrics.insert({"flop", flop_str});
    }

    return codegen::InstrumentationInfo(
        node_.element_id(), codegen::ElementType_Map, codegen::TargetType_CPU_PARALLEL, loop_info, metrics
    );
};

} // namespace omp
} // namespace sdfg

1	#include "sdfg/targets/omp/codegen/omp_map_dispatcher.h"
2
3	#include "sdfg/targets/omp/schedule.h"
4
5	#include <sdfg/analysis/loop_analysis.h>
6	#include <sdfg/analysis/users.h>
7	#include <sdfg/codegen/dispatchers/node_dispatcher_registry.h>
8	#include <sdfg/codegen/dispatchers/sequence_dispatcher.h>
9	#include <sdfg/codegen/instrumentation/instrumentation_info.h>
10	#include <sdfg/structured_control_flow/map.h>
11
12	namespace sdfg {
13	namespace omp {
14
15	OMPMapDispatcher::OMPMapDispatcher(
16	codegen::LanguageExtension& language_extension,
17	StructuredSDFG& sdfg,
18	analysis::AnalysisManager& analysis_manager,
19	structured_control_flow::Map& node,
20	codegen::InstrumentationPlan& instrumentation_plan,
21	codegen::ArgCapturePlan& arg_capture_plan
22	)
23	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	3✔
24	node_(node) {	3✔
25
26	};	3✔
27
28	void OMPMapDispatcher::dispatch_node(
29	codegen::PrettyPrinter& main_stream,
30	codegen::PrettyPrinter& globals_stream,
31	codegen::CodeSnippetFactory& library_snippet_factory
32	) {	3✔
33	// Mark written locals as private
34	analysis::AnalysisManager analysis_manager(sdfg_);	3✔
35	auto& users = analysis_manager.get<analysis::Users>();	3✔
36	analysis::UsersView users_view(users, node_.root());	3✔
37
38	std::vector<std::string> locals;	3✔
39	for (auto& entry : users.locals(node_.root())) {	3✔
NEW 40	if (users_view.writes(entry).size() > 0 \|\| users_view.moves(entry).size() > 0) {	×
NEW 41	locals.push_back(entry);	×
NEW 42	}	×
NEW 43	}	×
44
45	// Generate code
46	main_stream << "// Map" << std::endl;	3✔
47	main_stream << "#pragma omp parallel for";	3✔
48
49	main_stream << " schedule(";	3✔
50	if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Static) {	3✔
51	main_stream << "static)";	1✔
52	} else if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Dynamic) {	2✔
53	main_stream << "dynamic)";	2✔
54	} else if (ScheduleType_OMP::omp_schedule(node_.schedule_type()) == OpenMPSchedule::Guided) {	2✔
NEW 55	main_stream << "guided)";	×
NEW 56	} else {	×
NEW 57	throw std::runtime_error("Unsupported OpenMP schedule type");	×
NEW 58	}	×
59
60	if (!ScheduleType_OMP::num_threads(node_.schedule_type()).is_null()) {	3✔
61	main_stream << " num_threads(";	1✔
62	main_stream << language_extension_.expression(ScheduleType_OMP::num_threads(node_.schedule_type()));	1✔
63	main_stream << ")";	1✔
64	}	1✔
65
66	if (locals.size() > 0) {	3✔
NEW 67	main_stream << " private(" << helpers::join(locals, ", ") << ")";	×
NEW 68	}	×
69	main_stream << std::endl;	3✔
70	main_stream << "for";	3✔
71	main_stream << "(";	3✔
72	main_stream << node_.indvar()->get_name();	3✔
73	main_stream << " = ";	3✔
74	main_stream << language_extension_.expression(node_.init());	3✔
75	main_stream << ";";	3✔
76	main_stream << language_extension_.expression(node_.condition());	3✔
77	main_stream << ";";	3✔
78	main_stream << node_.indvar()->get_name();	3✔
79	main_stream << " = ";	3✔
80	main_stream << language_extension_.expression(node_.update());	3✔
81	main_stream << ")" << std::endl;	3✔
82	main_stream << "{" << std::endl;	3✔
83
84	for (auto& local : locals) {	3✔
NEW 85	auto& type = sdfg_.type(local);	×
NEW 86	if (type.storage_type().allocation() == types::StorageType::AllocationType::Managed) {	×
NEW 87	if (type.storage_type().is_cpu_stack()) {	×
NEW 88	main_stream << local << " = ";	×
NEW 89	main_stream << "alloca(" << language_extension_.expression(type.storage_type().allocation_size())	×
NEW 90	<< ")";	×
NEW 91	main_stream << ";" << std::endl;	×
NEW 92	} else if (type.storage_type().is_cpu_heap()) {	×
NEW 93	main_stream << local << " = ";	×
NEW 94	main_stream << language_extension_.external_prefix() << "malloc("	×
NEW 95	<< language_extension_.expression(type.storage_type().allocation_size()) << ")";	×
NEW 96	main_stream << ";" << std::endl;	×
NEW 97	}	×
NEW 98	}	×
NEW 99	}	×
100
101	main_stream.setIndent(main_stream.indent() + 4);	3✔
102	codegen::SequenceDispatcher	3✔
103	dispatcher(language_extension_, sdfg_, analysis_manager_, node_.root(), instrumentation_plan_, arg_capture_plan_);	3✔
104	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	3✔
105	main_stream.setIndent(main_stream.indent() - 4);	3✔
106
107	for (auto& local : locals) {	3✔
NEW 108	auto& type = sdfg_.type(local);	×
NEW 109	if (type.storage_type().deallocation() == types::StorageType::AllocationType::Managed) {	×
NEW 110	if (type.storage_type().is_cpu_heap()) {	×
NEW 111	main_stream << language_extension_.external_prefix() << "free(" << local << ");" << std::endl;	×
NEW 112	}	×
NEW 113	}	×
NEW 114	}	×
115
116	main_stream << "}" << std::endl;	3✔
117	};	3✔
118
NEW 119	codegen::InstrumentationInfo OMPMapDispatcher::instrumentation_info() const {	×
NEW 120	auto& loop_analysis = analysis_manager_.get<analysis::LoopAnalysis>();	×
NEW 121	analysis::LoopInfo loop_info = loop_analysis.loop_info(&node_);	×
122
123	// Perform FlopAnalysis
NEW 124	std::unordered_map<std::string, std::string> metrics;	×
NEW 125	auto& flop_analysis = analysis_manager_.get<analysis::FlopAnalysis>();	×
NEW 126	auto flop = flop_analysis.get_if_available_for_codegen(&node_);	×
NEW 127	if (!flop.is_null()) {	×
NEW 128	std::string flop_str = language_extension_.expression(flop);	×
NEW 129	metrics.insert({"flop", flop_str});	×
NEW 130	}	×
131
NEW 132	return codegen::InstrumentationInfo(	×
NEW 133	node_.element_id(), codegen::ElementType_Map, codegen::TargetType_CPU_PARALLEL, loop_info, metrics	×
NEW 134	);	×
NEW 135	};	×
136
137	} // namespace omp
138	} // namespace sdfg

daisytuner / sdfglib / 21098439361

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