20241896885

Committed 15 Dec 2025 05:44PM UTC coverage: 40.075% (-0.2%) from 40.251%

Build # 20241896885

Build Type

Pull #392

github

Committed by

web-flow

Commit Message

Merge 1719a4ffa into e5e8aa90d

Pull Request Pull Request #392: refactors passes to improve performance

Run Details

13609 of 43928 branches covered (30.98%)

Branch coverage included in aggregate %.

26 of 47 new or added lines in 3 files covered. (55.32%)

51 existing lines in 6 files now uncovered.

11621 of 19029 relevant lines covered (61.07%)

92.92 hits per line

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

2.67

/src/passes/pipeline.cpp

#include "sdfg/passes/pipeline.h"

#include "sdfg/passes/code_motion/block_hoisting.h"
#include "sdfg/passes/code_motion/block_sorting.h"
#include "sdfg/passes/dataflow/tasklet_fusion.h"
#include "sdfg/passes/dataflow/trivial_reference_conversion.h"
#include "sdfg/passes/schedules/expansion_pass.h"

namespace sdfg {
namespace passes {

Pipeline::Pipeline(const std::string& name)
    : Pass(), name_(name) {

      };

std::string Pipeline::name() { return this->name_; };

size_t Pipeline::size() const { return this->passes_.size(); };

bool Pipeline::run(builder::SDFGBuilder& builder) {
    bool applied = false;

    bool applied_pipeline;
    do {
        applied_pipeline = false;
        for (auto& pass : this->passes_) {
            bool applied_pass = false;
            do {
                applied_pass = pass->run(builder);
                applied_pipeline |= applied_pass;
            } while (applied_pass);
        }
        applied |= applied_pipeline;
    } while (applied_pipeline);

    return applied;
};

bool Pipeline::run(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {
    bool applied = false;
    bool applied_pipeline;
    do {
        applied_pipeline = false;
        for (auto& pass : this->passes_) {
            bool applied_pass = false;
            do {
                applied_pass = pass->run(builder, analysis_manager);
                applied_pipeline |= applied_pass;
            } while (applied_pass);
        }
        applied |= applied_pipeline;
    } while (applied_pipeline);

    return applied;
};

Pipeline Pipeline::dataflow_simplification() {
    Pipeline p("DataflowSimplification");

    p.register_pass<BlockFusionPass>();
    p.register_pass<TaskletFusionPass>();
    p.register_pass<SequenceFusion>();

    return p;
};

Pipeline Pipeline::symbolic_simplification() {
    Pipeline p("SymbolicSimplification");

    p.register_pass<SymbolPropagation>();

    return p;
};

Pipeline Pipeline::dead_code_elimination() {
    Pipeline p("DeadCodeElimination");

    p.register_pass<DeadCFGElimination>();
    p.register_pass<DeadDataElimination>();

    return p;
};

Pipeline Pipeline::expression_combine() {
    Pipeline p("ExpressionCombine");

    p.register_pass<SymbolPropagation>();
    p.register_pass<ConstantPropagation>();
    p.register_pass<DeadDataElimination>();
    p.register_pass<SymbolEvolution>();
    p.register_pass<TaskletFusionPass>();

    return p;
};

Pipeline Pipeline::memlet_combine() {
    Pipeline p("MemletCombine");

    p.register_pass<ReferencePropagation>();
    p.register_pass<DeadReferenceElimination>();
    p.register_pass<ByteReferenceElimination>();
    p.register_pass<TrivialReferenceConversionPass>();

    return p;
};

Pipeline Pipeline::controlflow_simplification() {
    Pipeline p("ControlFlowSimplification");

    p.register_pass<DeadCFGElimination>();
    p.register_pass<BlockFusionPass>();
    p.register_pass<SequenceFusion>();
    p.register_pass<ConditionEliminationPass>();

    return p;
};

Pipeline Pipeline::code_motion() {
    Pipeline p("CodeMotion");

    p.register_pass<BlockHoistingPass>();
    p.register_pass<BlockSortingPass>();

    return p;
};

Pipeline Pipeline::data_parallelism() {
    Pipeline p("DataParallelism");

    p.register_pass<For2MapPass>();
    p.register_pass<SymbolPropagation>();
    p.register_pass<DeadDataElimination>();

    return p;
};

Pipeline Pipeline::memory() {
    Pipeline p("Memory");

    p.register_pass<AllocationManagementPass>();

    return p;
};

Pipeline Pipeline::expansion() {
    Pipeline p("Expansion");

    p.register_pass<ExpansionPass>();

    return p;
};

} // namespace passes
} // namespace sdfg

1	#include "sdfg/passes/pipeline.h"
2
3	#include "sdfg/passes/code_motion/block_hoisting.h"
4	#include "sdfg/passes/code_motion/block_sorting.h"
5	#include "sdfg/passes/dataflow/tasklet_fusion.h"
6	#include "sdfg/passes/dataflow/trivial_reference_conversion.h"
7	#include "sdfg/passes/schedules/expansion_pass.h"
8
9	namespace sdfg {
10	namespace passes {
11
12	Pipeline::Pipeline(const std::string& name)	2✔
13	: Pass(), name_(name) {	2!
14
15	};	1✔
16
UNCOV 17	std::string Pipeline::name() { return this->name_; };	×
18
19	size_t Pipeline::size() const { return this->passes_.size(); };	1✔
20
21	bool Pipeline::run(builder::SDFGBuilder& builder) {	×
22	bool applied = false;	×
23
24	bool applied_pipeline;
25	do {	×
26	applied_pipeline = false;	×
27	for (auto& pass : this->passes_) {	×
28	bool applied_pass = false;	×
29	do {	×
30	applied_pass = pass->run(builder);	×
31	applied_pipeline \|= applied_pass;	×
32	} while (applied_pass);	×
33	}
34	applied \|= applied_pipeline;	×
35	} while (applied_pipeline);	×
36
37	return applied;	×
38	};
39
40	bool Pipeline::run(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {	×
41	bool applied = false;	×
42	bool applied_pipeline;
43	do {	×
44	applied_pipeline = false;	×
45	for (auto& pass : this->passes_) {	×
46	bool applied_pass = false;	×
47	do {	×
48	applied_pass = pass->run(builder, analysis_manager);	×
49	applied_pipeline \|= applied_pass;	×
50	} while (applied_pass);	×
51	}
52	applied \|= applied_pipeline;	×
53	} while (applied_pipeline);	×
54
55	return applied;	×
56	};
57
NEW 58	Pipeline Pipeline::dataflow_simplification() {	×
NEW 59	Pipeline p("DataflowSimplification");	×
60
NEW 61	p.register_pass<BlockFusionPass>();	×
NEW 62	p.register_pass<TaskletFusionPass>();	×
NEW 63	p.register_pass<SequenceFusion>();	×
64
NEW 65	return p;	×
NEW 66	};	×
67
NEW 68	Pipeline Pipeline::symbolic_simplification() {	×
NEW 69	Pipeline p("SymbolicSimplification");	×
70
NEW 71	p.register_pass<SymbolPropagation>();	×
72
NEW 73	return p;	×
NEW 74	};	×
75
NEW 76	Pipeline Pipeline::dead_code_elimination() {	×
NEW 77	Pipeline p("DeadCodeElimination");	×
78
NEW 79	p.register_pass<DeadCFGElimination>();	×
NEW 80	p.register_pass<DeadDataElimination>();	×
81
NEW 82	return p;	×
NEW 83	};	×
84
UNCOV 85	Pipeline Pipeline::expression_combine() {	×
UNCOV 86	Pipeline p("ExpressionCombine");	×
87
UNCOV 88	p.register_pass<SymbolPropagation>();	×
UNCOV 89	p.register_pass<ConstantPropagation>();	×
UNCOV 90	p.register_pass<DeadDataElimination>();	×
UNCOV 91	p.register_pass<SymbolEvolution>();	×
UNCOV 92	p.register_pass<TaskletFusionPass>();	×
93
UNCOV 94	return p;	×
UNCOV 95	};	×
96
UNCOV 97	Pipeline Pipeline::memlet_combine() {	×
UNCOV 98	Pipeline p("MemletCombine");	×
99
UNCOV 100	p.register_pass<ReferencePropagation>();	×
UNCOV 101	p.register_pass<DeadReferenceElimination>();	×
UNCOV 102	p.register_pass<ByteReferenceElimination>();	×
UNCOV 103	p.register_pass<TrivialReferenceConversionPass>();	×
104
UNCOV 105	return p;	×
UNCOV 106	};	×
107
UNCOV 108	Pipeline Pipeline::controlflow_simplification() {	×
UNCOV 109	Pipeline p("ControlFlowSimplification");	×
110
UNCOV 111	p.register_pass<DeadCFGElimination>();	×
UNCOV 112	p.register_pass<BlockFusionPass>();	×
UNCOV 113	p.register_pass<SequenceFusion>();	×
UNCOV 114	p.register_pass<ConditionEliminationPass>();	×
115
UNCOV 116	return p;	×
UNCOV 117	};	×
118
119	Pipeline Pipeline::code_motion() {	×
120	Pipeline p("CodeMotion");	×
121
122	p.register_pass<BlockHoistingPass>();	×
123	p.register_pass<BlockSortingPass>();	×
124
125	return p;	×
126	};	×
127
UNCOV 128	Pipeline Pipeline::data_parallelism() {	×
UNCOV 129	Pipeline p("DataParallelism");	×
130
UNCOV 131	p.register_pass<For2MapPass>();	×
UNCOV 132	p.register_pass<SymbolPropagation>();	×
UNCOV 133	p.register_pass<DeadDataElimination>();	×
134
UNCOV 135	return p;	×
UNCOV 136	};	×
137
138	Pipeline Pipeline::memory() {	×
139	Pipeline p("Memory");	×
140
141	p.register_pass<AllocationManagementPass>();	×
142
143	return p;	×
144	};	×
145
UNCOV 146	Pipeline Pipeline::expansion() {	×
UNCOV 147	Pipeline p("Expansion");	×
148
UNCOV 149	p.register_pass<ExpansionPass>();	×
150
UNCOV 151	return p;	×
UNCOV 152	};	×
153
154	} // namespace passes
155	} // namespace sdfg

daisytuner / sdfglib / 20241896885

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