15133758385

Committed 20 May 2025 09:19AM UTC coverage: 60.543% (-3.0%) from 63.542%

Build # 15133758385

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #22 from daisytuner/normalization

Removes normalization passes

Run Details

7922 of 13085 relevant lines covered (60.54%)

104.24 hits per line

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

67.21

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

daisytuner / sdfglib / 15133758385

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