14009064270

Committed 22 Mar 2025 01:32PM UTC coverage: 82.886%. Remained the same

Build # 14009064270

Build Type

push

github

Committed by

web-flow

Commit Message

Perform convergent transformation within CascadeTransform (#197)

By default, `Transform` will be run once for each operation it supports
(optionally with recursion if `recurse` method returns true). To perform
convergent transformations (e.g. canonicalization), `CascadeTransform`
will be used.

Run Details

124 of 136 new or added lines in 6 files covered. (91.18%)

4756 of 5738 relevant lines covered (82.89%)

269.1 hits per line

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

87.5

/compiler/lib/backend/optree/optimizer/optimizer.cpp

#include "optimizer/optimizer.hpp"

#include "compiler/optree/operation.hpp"
#include "compiler/optree/program.hpp"
#include "compiler/utils/debug.hpp"
#include "compiler/utils/helpers.hpp"

#include "optimizer/opt_builder.hpp"
#include "optimizer/transform.hpp"

using namespace optree;
using namespace optree::optimizer;

using dbg = utils::DebugPrinter;

namespace {

void runTransform(const BaseTransform::Ptr &transform, const OptBuilder::Notifier &notifier, const Operation::Ptr &op) {
    bool canRun = transform->canRun(op);
    if (transform->recurse() || (!canRun && !transform->recurse())) {
        for (const auto &childOp : utils::advanceEarly(op->body)) {
            runTransform(transform, notifier, childOp);
        }
    }
    if (!canRun)
        return;
    OptBuilder builder(notifier);
    builder.setInsertPointBefore(op);
    COMPILER_DEBUG(dbg::get() << "Run " << transform->name() << " on " << op->dump() << "{\n");
    transform->run(op, builder);
    COMPILER_DEBUG(dbg::get() << "}\n\n");
}

} // namespace

Optimizer &Optimizer::add(const BaseTransform::Ptr &transform) {
    transforms.emplace_back(transform);
    return *this;
}

void Optimizer::process(const Operation::Ptr &op) const {
    OptBuilder::Notifier empty;
    for (const auto &transform : transforms)
        runTransform(transform, empty, op);
}

void Optimizer::process(Program &program) const {
    process(program.root);
}

1	#include "optimizer/optimizer.hpp"
2
3	#include "compiler/optree/operation.hpp"
4	#include "compiler/optree/program.hpp"
5	#include "compiler/utils/debug.hpp"
6	#include "compiler/utils/helpers.hpp"
7
8	#include "optimizer/opt_builder.hpp"
9	#include "optimizer/transform.hpp"
10
11	using namespace optree;
12	using namespace optree::optimizer;
13
14	using dbg = utils::DebugPrinter;
15
16	namespace {
17
18	void runTransform(const BaseTransform::Ptr &transform, const OptBuilder::Notifier &notifier, const Operation::Ptr &op) {	25✔
19	bool canRun = transform->canRun(op);	25✔
20	if (transform->recurse() \|\| (!canRun && !transform->recurse())) {	25✔
NEW 21	for (const auto &childOp : utils::advanceEarly(op->body)) {	×
NEW 22	runTransform(transform, notifier, childOp);	×
23	}
24	}
25	if (!canRun)	25✔
NEW 26	return;	×
27	OptBuilder builder(notifier);	25✔
28	builder.setInsertPointBefore(op);	25✔
29	COMPILER_DEBUG(dbg::get() << "Run " << transform->name() << " on " << op->dump() << "{\n");	25✔
30	transform->run(op, builder);	25✔
31	COMPILER_DEBUG(dbg::get() << "}\n\n");	25✔
32	}	25✔
33
34	} // namespace
35
36	Optimizer &Optimizer::add(const BaseTransform::Ptr &transform) {	25✔
37	transforms.emplace_back(transform);	25✔
38	return *this;	25✔
39	}
40
41	void Optimizer::process(const Operation::Ptr &op) const {	25✔
42	OptBuilder::Notifier empty;	25✔
43	for (const auto &transform : transforms)	50✔
44	runTransform(transform, empty, op);	25✔
45	}	25✔
46
47	void Optimizer::process(Program &program) const {	25✔
48	process(program.root);	25✔
49	}	25✔

vla5924-practice / compiler-project / 14009064270

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