25250124826

Committed 02 May 2026 10:42AM UTC coverage: 64.498% (-0.1%) from 64.643%

Build # 25250124826

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #696 from daisytuner/vectorize-transform

Adds VectorizeTransform and sets as default over highway

Coverage Stats

17 of 135 new or added lines in 8 files covered. (12.59%)

31346 of 48600 relevant lines covered (64.5%)

1391.61 hits per line

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

0.0

/opt/src/targets/vectorize/codegen/vectorize_map_dispatcher.cpp

#include "sdfg/targets/vectorize/codegen/vectorize_map_dispatcher.h"

#include "sdfg/targets/vectorize/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 vectorize {

VectorizeMapDispatcher::VectorizeMapDispatcher(
    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 VectorizeMapDispatcher::dispatch_node(
    codegen::PrettyPrinter& main_stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::CodeSnippetFactory& library_snippet_factory
) {
    // Generate code
    main_stream << "// Map" << std::endl;
    main_stream << "#pragma clang loop vectorize(enable) interleave(enable)" << 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);
    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);

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

codegen::InstrumentationInfo VectorizeMapDispatcher::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 vectorize
} // namespace sdfg

1	#include "sdfg/targets/vectorize/codegen/vectorize_map_dispatcher.h"
2
3	#include "sdfg/targets/vectorize/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 vectorize {
14
15	VectorizeMapDispatcher::VectorizeMapDispatcher(
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	)
NEW 23	: NodeDispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan),	×
NEW 24	node_(node) {	×
25
NEW 26	};	×
27
28	void VectorizeMapDispatcher::dispatch_node(
29	codegen::PrettyPrinter& main_stream,
30	codegen::PrettyPrinter& globals_stream,
31	codegen::CodeSnippetFactory& library_snippet_factory
NEW 32	) {	×
33	// Generate code
NEW 34	main_stream << "// Map" << std::endl;	×
NEW 35	main_stream << "#pragma clang loop vectorize(enable) interleave(enable)" << std::endl;	×
36
NEW 37	main_stream << "for";	×
NEW 38	main_stream << "(";	×
NEW 39	main_stream << node_.indvar()->get_name();	×
NEW 40	main_stream << " = ";	×
NEW 41	main_stream << language_extension_.expression(node_.init());	×
NEW 42	main_stream << ";";	×
NEW 43	main_stream << language_extension_.expression(node_.condition());	×
NEW 44	main_stream << ";";	×
NEW 45	main_stream << node_.indvar()->get_name();	×
NEW 46	main_stream << " = ";	×
NEW 47	main_stream << language_extension_.expression(node_.update());	×
NEW 48	main_stream << ")" << std::endl;	×
NEW 49	main_stream << "{" << std::endl;	×
50
NEW 51	main_stream.setIndent(main_stream.indent() + 4);	×
NEW 52	codegen::SequenceDispatcher	×
NEW 53	dispatcher(language_extension_, sdfg_, analysis_manager_, node_.root(), instrumentation_plan_, arg_capture_plan_);	×
NEW 54	dispatcher.dispatch(main_stream, globals_stream, library_snippet_factory);	×
NEW 55	main_stream.setIndent(main_stream.indent() - 4);	×
56
NEW 57	main_stream << "}" << std::endl;	×
NEW 58	};	×
59
NEW 60	codegen::InstrumentationInfo VectorizeMapDispatcher::instrumentation_info() const {	×
NEW 61	auto& loop_analysis = analysis_manager_.get<analysis::LoopAnalysis>();	×
NEW 62	analysis::LoopInfo loop_info = loop_analysis.loop_info(&node_);	×
63
64	// Perform FlopAnalysis
NEW 65	std::unordered_map<std::string, std::string> metrics;	×
NEW 66	auto& flop_analysis = analysis_manager_.get<analysis::FlopAnalysis>();	×
NEW 67	auto flop = flop_analysis.get_if_available_for_codegen(&node_);	×
NEW 68	if (!flop.is_null()) {	×
NEW 69	std::string flop_str = language_extension_.expression(flop);	×
NEW 70	metrics.insert({"flop", flop_str});	×
NEW 71	}	×
72
NEW 73	return codegen::InstrumentationInfo(	×
NEW 74	node_.element_id(), codegen::ElementType_Map, codegen::TargetType_CPU_PARALLEL, loop_info, metrics	×
NEW 75	);	×
NEW 76	};	×
77
78	} // namespace vectorize
79	} // namespace sdfg

daisytuner / docc / 25250124826

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