15049376628

Committed 15 May 2025 03:33PM UTC coverage: 62.241% (+4.7%) from 57.525%

Build # 15049376628

Build Type

Pull #9

github

Committed by

web-flow

Commit Message

Merge b96e33e0e into 9d3b1a2b3

Pull Request Pull Request #9: Graphviz DOT Visualizer for SDFGs

Run Details

520 of 542 new or added lines in 3 files covered. (95.94%)

782 existing lines in 68 files now uncovered.

8049 of 12932 relevant lines covered (62.24%)

506.14 hits per line

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

95.45

/src/transformations/loop_interchange.cpp

#include "sdfg/transformations/loop_interchange.h"

namespace sdfg {
namespace transformations {

LoopInterchange::LoopInterchange(structured_control_flow::Sequence& parent,
                                 structured_control_flow::For& outer_loop,
                                 structured_control_flow::For& inner_loop)
    : outer_loop_(outer_loop), inner_loop_(inner_loop) {

      };

std::string LoopInterchange::name() { return "LoopInterchange"; };

bool LoopInterchange::can_be_applied(Schedule& schedule) {
    auto& builder = schedule.builder();
    auto& sdfg = builder.subject();

    auto& outer_indvar = this->outer_loop_.indvar();
    auto& inner_indvar = this->inner_loop_.indvar();

    // Criterion: Inner loop must not depend on outer loop
    auto& inner_loop_init = this->inner_loop_.init();
    auto& inner_loop_condition = this->inner_loop_.condition();
    auto& inner_loop_update = this->inner_loop_.update();
    if (symbolic::uses(inner_loop_init, outer_indvar->get_name()) ||
        symbolic::uses(inner_loop_condition, outer_indvar->get_name()) ||
        symbolic::uses(inner_loop_update, outer_indvar->get_name())) {
        return false;
    }

    // Criterion: Outer loop must not have any outer blocks
    if (outer_loop_.root().size() > 1) {
        return false;
    }
    if (outer_loop_.root().at(0).second.assignments().size() > 0) {
        return false;
    }
    if (&outer_loop_.root().at(0).first != &inner_loop_) {
        return false;
    }
    // Criterion: Any of both loops is a map
    auto& analysis_manager = schedule.analysis_manager();
    auto& analysis = analysis_manager.get<analysis::DataParallelismAnalysis>();

    auto& outer_dependencies = analysis.get(this->outer_loop_);
    if (outer_dependencies.size() > 0) {
        bool is_map = true;
        for (auto& dep : outer_dependencies) {
            auto& container = dep.first;
            auto& dep_type = dep.second;
            if (dep_type < analysis::Parallelism::PARALLEL) {
                is_map = false;
                break;
            }
        }
        if (is_map) {
            return true;
        }
    }
    auto& inner_dependencies = analysis.get(this->inner_loop_);
    if (inner_dependencies.size() > 0) {
        bool is_map = true;
        for (auto& dep : inner_dependencies) {
            auto& container = dep.first;
            auto& dep_type = dep.second;
            if (dep_type < analysis::Parallelism::PARALLEL) {
                is_map = false;
                break;
            }
        }
        if (is_map) {
            return true;
        }
    }

    return false;
};

void LoopInterchange::apply(Schedule& schedule) {
    // Swap loop definitions
    auto outer_indvar = this->outer_loop_.indvar();
    auto outer_init = this->outer_loop_.init();
    auto outer_condition = this->outer_loop_.condition();
    auto outer_update = this->outer_loop_.update();

    this->outer_loop_.indvar() = this->inner_loop_.indvar();
    this->outer_loop_.init() = this->inner_loop_.init();
    this->outer_loop_.condition() = this->inner_loop_.condition();
    this->outer_loop_.update() = this->inner_loop_.update();

    this->inner_loop_.indvar() = outer_indvar;
    this->inner_loop_.init() = outer_init;
    this->inner_loop_.condition() = outer_condition;
    this->inner_loop_.update() = outer_update;

    auto& analysis_manager = schedule.analysis_manager();
    analysis_manager.invalidate_all();
};

}  // namespace transformations
}  // namespace sdfg

1	#include "sdfg/transformations/loop_interchange.h"
2
3	namespace sdfg {
4	namespace transformations {
5
6	LoopInterchange::LoopInterchange(structured_control_flow::Sequence& parent,	95✔
7	structured_control_flow::For& outer_loop,
8	structured_control_flow::For& inner_loop)
9	: outer_loop_(outer_loop), inner_loop_(inner_loop) {	95✔
10
11	};	95✔
12
UNCOV 13	std::string LoopInterchange::name() { return "LoopInterchange"; };	×
14
15	bool LoopInterchange::can_be_applied(Schedule& schedule) {	95✔
16	auto& builder = schedule.builder();	95✔
17	auto& sdfg = builder.subject();	95✔
18
19	auto& outer_indvar = this->outer_loop_.indvar();	95✔
20	auto& inner_indvar = this->inner_loop_.indvar();	95✔
21
22	// Criterion: Inner loop must not depend on outer loop
23	auto& inner_loop_init = this->inner_loop_.init();	95✔
24	auto& inner_loop_condition = this->inner_loop_.condition();	95✔
25	auto& inner_loop_update = this->inner_loop_.update();	95✔
26	if (symbolic::uses(inner_loop_init, outer_indvar->get_name()) \|\|	179✔
27	symbolic::uses(inner_loop_condition, outer_indvar->get_name()) \|\|	158✔
28	symbolic::uses(inner_loop_update, outer_indvar->get_name())) {	74✔
29	return false;	21✔
30	}
31
32	// Criterion: Outer loop must not have any outer blocks
33	if (outer_loop_.root().size() > 1) {	74✔
34	return false;	15✔
35	}
36	if (outer_loop_.root().at(0).second.assignments().size() > 0) {	59✔
UNCOV 37	return false;	×
38	}
39	if (&outer_loop_.root().at(0).first != &inner_loop_) {	59✔
UNCOV 40	return false;	×
41	}
42	// Criterion: Any of both loops is a map
43	auto& analysis_manager = schedule.analysis_manager();	59✔
44	auto& analysis = analysis_manager.get<analysis::DataParallelismAnalysis>();	59✔
45
46	auto& outer_dependencies = analysis.get(this->outer_loop_);	59✔
47	if (outer_dependencies.size() > 0) {	59✔
48	bool is_map = true;	59✔
49	for (auto& dep : outer_dependencies) {	343✔
50	auto& container = dep.first;	302✔
51	auto& dep_type = dep.second;	302✔
52	if (dep_type < analysis::Parallelism::PARALLEL) {	302✔
53	is_map = false;	18✔
54	break;	18✔
55	}
56	}
57	if (is_map) {	59✔
58	return true;	41✔
59	}
60	}	18✔
61	auto& inner_dependencies = analysis.get(this->inner_loop_);	18✔
62	if (inner_dependencies.size() > 0) {	18✔
63	bool is_map = true;	18✔
64	for (auto& dep : inner_dependencies) {	86✔
65	auto& container = dep.first;	74✔
66	auto& dep_type = dep.second;	74✔
67	if (dep_type < analysis::Parallelism::PARALLEL) {	74✔
68	is_map = false;	6✔
69	break;	6✔
70	}
71	}
72	if (is_map) {	18✔
73	return true;	12✔
74	}
75	}	6✔
76
77	return false;	6✔
78	};	95✔
79
80	void LoopInterchange::apply(Schedule& schedule) {	13✔
81	// Swap loop definitions
82	auto outer_indvar = this->outer_loop_.indvar();	13✔
83	auto outer_init = this->outer_loop_.init();	13✔
84	auto outer_condition = this->outer_loop_.condition();	13✔
85	auto outer_update = this->outer_loop_.update();	13✔
86
87	this->outer_loop_.indvar() = this->inner_loop_.indvar();	13✔
88	this->outer_loop_.init() = this->inner_loop_.init();	13✔
89	this->outer_loop_.condition() = this->inner_loop_.condition();	13✔
90	this->outer_loop_.update() = this->inner_loop_.update();	13✔
91
92	this->inner_loop_.indvar() = outer_indvar;	13✔
93	this->inner_loop_.init() = outer_init;	13✔
94	this->inner_loop_.condition() = outer_condition;	13✔
95	this->inner_loop_.update() = outer_update;	13✔
96
97	auto& analysis_manager = schedule.analysis_manager();	13✔
98	analysis_manager.invalidate_all();	13✔
99	};	13✔
100
101	} // namespace transformations
102	} // namespace sdfg

daisytuner / sdfglib / 15049376628

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