28158800507

Committed 25 Jun 2026 08:57AM UTC coverage: 61.644% (+0.06%) from 61.582%

Build # 28158800507

Build Type

push

github

Committed by

web-flow

Commit Message

MapFusionByDomain (#771)

 + New Map fusion caches data about iteration domain and map candidates
 + only matches up iteration domain exactly, per loop level.
 + Can support fusing non-leaf stacks of loops (stack ends where the shallower stack stops being perfectly nested & parallel)
 + new Element::replace for bulk replacements
 + New PatternMatcher visitor supports descending into replaced or modified nodes to allow for single-pass nested loop fusings
 + LoopAnalysis can now be kept up-to-date with changes done by Map-fusion
 + unit tests for the updating of LoopAnalysis
 * updated LoopAnalysis to be easier to keep up-to-date with changes. LoopTree is no longer ordered, if you want to iterate in pre-order, use the specific method for that
 + convenience StructuredSDFGBuilder.remove_from_parent()
 + RedundantLoadElim pass to skip reading from memory locations that have just been written (same block). Fusing no longer needs to do this
     RedundantLoadElimination does a simple check for other writes to the same structure. Can skip writes if redundant or not modify, if their are writes to different indices
* Updated verifiers to match new fusion
~ moved verifier checks behind correctness checks in npbench harness. Its more critical if we do not even get the expected results
* Added MapFusionByDomain also to loop-norm stage (currently inactive, causes more kernels that currently cannot be safely offloaded to CUDA.
---------

Co-authored-by: Lukas Truemper <lukas.truemper@outlook.de>

Coverage Stats

771 of 1186 new or added lines in 55 files covered. (65.01%)

6 existing lines in 6 files now uncovered.

38302 of 62134 relevant lines covered (61.64%)

987.24 hits per line

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

57.89

/sdfg/src/structured_control_flow/while.cpp

#include "sdfg/structured_control_flow/while.h"

namespace sdfg {
namespace structured_control_flow {

While::While(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
    : ControlFlowNode(element_id, debug_info, parent) {
    this->root_ = std::unique_ptr<Sequence>(new Sequence(++element_id, debug_info, this));
};

void While::validate(const Function& function) const { this->root_->validate(function); };

const Sequence& While::root() const { return *this->root_; };

Sequence& While::root() { return *this->root_; };

void While::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    this->root_->replace(old_expression, new_expression);
}

void While::replace(const symbolic::ExpressionMapping& replacements) { this->root_->replace(replacements); }

Break::Break(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
    : ControlFlowNode(element_id, debug_info, parent) {

      };

void Break::validate(const Function& function) const {};

void Break::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}

void Break::replace(const symbolic::ExpressionMapping& replacements) {}

Continue::Continue(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
    : ControlFlowNode(element_id, debug_info, parent) {};

void Continue::validate(const Function& function) const {};

void Continue::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}

void Continue::replace(const symbolic::ExpressionMapping& replacements) {}

} // namespace structured_control_flow
} // namespace sdfg

1	#include "sdfg/structured_control_flow/while.h"
2
3	namespace sdfg {
4	namespace structured_control_flow {
5
6	While::While(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
7	: ControlFlowNode(element_id, debug_info, parent) {	53✔
8	this->root_ = std::unique_ptr<Sequence>(new Sequence(++element_id, debug_info, this));	53✔
9	};	53✔
10
11	void While::validate(const Function& function) const { this->root_->validate(function); };	74✔
12
13	const Sequence& While::root() const { return *this->root_; };	16✔
14
15	Sequence& While::root() { return *this->root_; };	176✔
16
17	void While::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
18	this->root_->replace(old_expression, new_expression);	×
NEW 19	}	×
20
NEW 21	void While::replace(const symbolic::ExpressionMapping& replacements) { this->root_->replace(replacements); }	×
22
23	Break::Break(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
24	: ControlFlowNode(element_id, debug_info, parent) {	28✔
25
26	};	28✔
27
28	void Break::validate(const Function& function) const {};	27✔
29
NEW 30	void Break::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}	×
31
NEW 32	void Break::replace(const symbolic::ExpressionMapping& replacements) {}	×
33
34	Continue::Continue(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent)
35	: ControlFlowNode(element_id, debug_info, parent) {};	27✔
36
37	void Continue::validate(const Function& function) const {};	28✔
38
NEW 39	void Continue::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {}	×
40
NEW 41	void Continue::replace(const symbolic::ExpressionMapping& replacements) {}	×
42
43	} // namespace structured_control_flow
44	} // namespace sdfg

daisytuner / docc / 28158800507

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