20263852258

Committed 16 Dec 2025 09:58AM UTC coverage: 40.086% (-0.2%) from 40.252%

Build # 20263852258

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #392 from daisytuner/for2map-performance

refactors passes to improve performance

Run Details

13621 of 43972 branches covered (30.98%)

Branch coverage included in aggregate %.

126 of 173 new or added lines in 14 files covered. (72.83%)

55 existing lines in 8 files now uncovered.

11633 of 19027 relevant lines covered (61.14%)

90.79 hits per line

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

2.63

/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>();
    p.register_pass<SequenceFusion>();

    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>();	×
NEW 81	p.register_pass<SequenceFusion>();	×
82
NEW 83	return p;	×
NEW 84	};	×
85
UNCOV 86	Pipeline Pipeline::expression_combine() {	×
UNCOV 87	Pipeline p("ExpressionCombine");	×
88
UNCOV 89	p.register_pass<SymbolPropagation>();	×
UNCOV 90	p.register_pass<ConstantPropagation>();	×
UNCOV 91	p.register_pass<DeadDataElimination>();	×
UNCOV 92	p.register_pass<SymbolEvolution>();	×
UNCOV 93	p.register_pass<TaskletFusionPass>();	×
94
UNCOV 95	return p;	×
UNCOV 96	};	×
97
UNCOV 98	Pipeline Pipeline::memlet_combine() {	×
UNCOV 99	Pipeline p("MemletCombine");	×
100
UNCOV 101	p.register_pass<ReferencePropagation>();	×
UNCOV 102	p.register_pass<DeadReferenceElimination>();	×
UNCOV 103	p.register_pass<ByteReferenceElimination>();	×
UNCOV 104	p.register_pass<TrivialReferenceConversionPass>();	×
105
UNCOV 106	return p;	×
UNCOV 107	};	×
108
UNCOV 109	Pipeline Pipeline::controlflow_simplification() {	×
UNCOV 110	Pipeline p("ControlFlowSimplification");	×
111
UNCOV 112	p.register_pass<DeadCFGElimination>();	×
UNCOV 113	p.register_pass<BlockFusionPass>();	×
UNCOV 114	p.register_pass<SequenceFusion>();	×
UNCOV 115	p.register_pass<ConditionEliminationPass>();	×
116
UNCOV 117	return p;	×
UNCOV 118	};	×
119
120	Pipeline Pipeline::code_motion() {	×
121	Pipeline p("CodeMotion");	×
122
123	p.register_pass<BlockHoistingPass>();	×
124	p.register_pass<BlockSortingPass>();	×
125
126	return p;	×
127	};	×
128
UNCOV 129	Pipeline Pipeline::data_parallelism() {	×
UNCOV 130	Pipeline p("DataParallelism");	×
131
UNCOV 132	p.register_pass<For2MapPass>();	×
UNCOV 133	p.register_pass<SymbolPropagation>();	×
UNCOV 134	p.register_pass<DeadDataElimination>();	×
135
UNCOV 136	return p;	×
UNCOV 137	};	×
138
139	Pipeline Pipeline::memory() {	×
140	Pipeline p("Memory");	×
141
142	p.register_pass<AllocationManagementPass>();	×
143
144	return p;	×
145	};	×
146
UNCOV 147	Pipeline Pipeline::expansion() {	×
UNCOV 148	Pipeline p("Expansion");	×
149
UNCOV 150	p.register_pass<ExpansionPass>();	×
151
UNCOV 152	return p;	×
UNCOV 153	};	×
154
155	} // namespace passes
156	} // namespace sdfg

daisytuner / sdfglib / 20263852258

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