15044057891

Committed 15 May 2025 11:42AM UTC coverage: 59.37% (+1.8%) from 57.525%

Build # 15044057891

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14 from daisytuner/sanitizers

enables sanitizer on unit tests

Run Details

63 of 67 new or added lines in 47 files covered. (94.03%)

570 existing lines in 62 files now uncovered.

7356 of 12390 relevant lines covered (59.37%)

505.93 hits per line

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

85.07

/src/builder/sdfg_builder.cpp

#include "sdfg/builder/sdfg_builder.h"

namespace sdfg {
namespace builder {

Function& SDFGBuilder::function() const { return static_cast<Function&>(*this->sdfg_); };

SDFGBuilder::SDFGBuilder(std::unique_ptr<SDFG>& sdfg)
    : FunctionBuilder(), sdfg_(std::move(sdfg)) {

      };

SDFGBuilder::SDFGBuilder(const std::string& name)
    : FunctionBuilder(), sdfg_(new SDFG(name)) {

      };

SDFG& SDFGBuilder::subject() const { return *this->sdfg_; };

std::unique_ptr<SDFG> SDFGBuilder::move() { return std::move(this->sdfg_); };

/***** Section: Control-Flow Graph *****/

control_flow::State& SDFGBuilder::add_state(bool is_start_state, const DebugInfo& debug_info) {
    auto vertex = boost::add_vertex(this->sdfg_->graph_);
    auto res = this->sdfg_->states_.insert(
        {vertex, std::unique_ptr<control_flow::State>(
                     new control_flow::State(this->element_counter_, debug_info, vertex))});
    this->element_counter_++;
    assert(res.second);

    if (is_start_state) {
        this->sdfg_->start_state_ = (*res.first).second.get();
    }

    return *(*res.first).second;
};

control_flow::State& SDFGBuilder::add_state_before(const control_flow::State& state,
                                                   bool is_start_state,
                                                   const DebugInfo& debug_info) {
    auto& new_state = this->add_state(false, debug_info);

    // Redirect control-flow
    std::list<graph::Edge> descriptors_to_remove;
    for (auto& edge : this->sdfg_->in_edges(state)) {
        this->add_edge(edge.src(), new_state, edge.condition());

        auto desc = edge.edge();
        descriptors_to_remove.push_back(desc);
        this->sdfg_->edges_.erase(desc);
    }
    for (auto desc : descriptors_to_remove) {
        boost::remove_edge(desc, this->sdfg_->graph_);
    }
    this->add_edge(new_state, state);

    if (is_start_state) {
        this->sdfg_->start_state_ = &new_state;
    }

    return new_state;
};

control_flow::State& SDFGBuilder::add_state_after(const control_flow::State& state,
                                                  bool connect_states,
                                                  const DebugInfo& debug_info) {
    auto& new_state = this->add_state(false, debug_info);

    // Redirect control-flow
    std::list<graph::Edge> descriptors_to_remove;
    for (auto& edge : this->sdfg_->out_edges(state)) {
        this->add_edge(new_state, edge.dst(), edge.condition());

        auto desc = edge.edge();
        descriptors_to_remove.push_back(desc);
        this->sdfg_->edges_.erase(desc);
    }
    for (auto desc : descriptors_to_remove) {
        boost::remove_edge(desc, this->sdfg_->graph_);
    }
    if (connect_states) {
        this->add_edge(state, new_state);
    }

    return new_state;
};

control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,
                                                    const control_flow::State& dst,
                                                    const DebugInfo& debug_info) {
    return this->add_edge(src, dst, symbolic::Assignments{}, SymEngine::boolTrue, debug_info);
};

control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,
                                                    const control_flow::State& dst,
                                                    const symbolic::Condition condition,
                                                    const DebugInfo& debug_info) {
    return this->add_edge(src, dst, symbolic::Assignments{}, condition, debug_info);
};

control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,
                                                    const control_flow::State& dst,
                                                    const symbolic::Assignments& assignments,
                                                    const DebugInfo& debug_info) {
    return this->add_edge(src, dst, assignments, SymEngine::boolTrue, debug_info);
};

control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,
                                                    const control_flow::State& dst,
                                                    const symbolic::Assignments& assignments,
                                                    const symbolic::Condition condition,
                                                    const DebugInfo& debug_info) {
    auto edge = boost::add_edge(src.vertex_, dst.vertex_, this->sdfg_->graph_);
    assert(edge.second);

    auto res = this->sdfg_->edges_.insert(
        {edge.first,
         std::unique_ptr<control_flow::InterstateEdge>(new control_flow::InterstateEdge(
             this->element_counter_, debug_info, edge.first, src, dst, condition, assignments))});
    this->element_counter_++;
    assert(res.second);

    return *(*res.first).second;
};

void SDFGBuilder::remove_edge(const control_flow::InterstateEdge& edge) {
    size_t erased = this->sdfg_->edges_.erase(edge.edge());
    assert(erased == 1);

    boost::remove_edge(edge.src().vertex_, edge.dst().vertex_, this->sdfg_->graph_);
};

std::tuple<control_flow::State&, control_flow::State&, control_flow::State&> SDFGBuilder::add_loop(
    const control_flow::State& state, sdfg::symbolic::Symbol iterator,
    sdfg::symbolic::Expression init, sdfg::symbolic::Condition cond,
    sdfg::symbolic::Expression update, const DebugInfo& debug_info) {
    // Init: iterator = init
    auto& init_state = this->add_state_after(state, true, debug_info);
    const graph::Edge init_edge_desc = (*this->sdfg_->in_edges(init_state).begin()).edge_;
    auto& init_edge = this->sdfg_->edges_[init_edge_desc];
    init_edge->assignments_.insert({iterator, init});

    // Final state
    auto& final_state = this->add_state_after(init_state, false, debug_info);

    // Init -> early_exit -> final
    auto& early_exit_state = this->add_state(false, debug_info);
    this->add_edge(init_state, early_exit_state, symbolic::Not(cond));
    this->add_edge(early_exit_state, final_state);

    // Init -> header -> body
    auto& header_state = this->add_state(false, debug_info);
    this->add_edge(init_state, header_state, cond);

    auto& body_state = this->add_state(false, debug_info);
    this->add_edge(header_state, body_state);

    auto& update_state = this->add_state(false, debug_info);
    this->add_edge(body_state, update_state, {{iterator, update}});

    // Back edge and exit edge
    this->add_edge(update_state, header_state, cond);
    this->add_edge(update_state, final_state, symbolic::Not(cond));

    return {init_state, body_state, final_state};
};

/***** Section: Dataflow Graph *****/

data_flow::AccessNode& SDFGBuilder::add_access(control_flow::State& state, const std::string& data,
                                               const DebugInfo& debug_info) {
    auto& dataflow = state.dataflow();

    auto vertex = boost::add_vertex(dataflow.graph_);
    auto res = dataflow.nodes_.insert(
        {vertex, std::unique_ptr<data_flow::AccessNode>(new data_flow::AccessNode(
                     this->element_counter_, debug_info, vertex, dataflow, data))});
    this->element_counter_++;
    return dynamic_cast<data_flow::AccessNode&>(*(res.first->second));
};

data_flow::Tasklet& SDFGBuilder::add_tasklet(
    control_flow::State& state, const data_flow::TaskletCode code,
    const std::pair<std::string, sdfg::types::Scalar>& output,
    const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
    const DebugInfo& debug_info) {
    auto& dataflow = state.dataflow();

    auto vertex = boost::add_vertex(dataflow.graph_);
    auto res =
        dataflow.nodes_.insert({vertex, std::unique_ptr<data_flow::Tasklet>(new data_flow::Tasklet(
                                            this->element_counter_, debug_info, vertex, dataflow,
                                            code, output, inputs, symbolic::__true__()))});
    this->element_counter_++;
    return dynamic_cast<data_flow::Tasklet&>(*(res.first->second));
};

data_flow::Memlet& SDFGBuilder::add_memlet(control_flow::State& state, data_flow::DataFlowNode& src,
                                           const std::string& src_conn,
                                           data_flow::DataFlowNode& dst,
                                           const std::string& dst_conn,
                                           const data_flow::Subset& subset,
                                           const DebugInfo& debug_info) {
    auto& dataflow = state.dataflow();

    auto edge = boost::add_edge(src.vertex_, dst.vertex_, dataflow.graph_);
    auto res = dataflow.edges_.insert(
        {edge.first, std::unique_ptr<data_flow::Memlet>(
                         new data_flow::Memlet(this->element_counter_, debug_info, edge.first,
                                               dataflow, src, src_conn, dst, dst_conn, subset))});
    this->element_counter_++;
    return dynamic_cast<data_flow::Memlet&>(*(res.first->second));
};

data_flow::LibraryNode& SDFGBuilder::add_library_node(
    control_flow::State& state, const data_flow::LibraryNodeType& call,
    const std::vector<std::pair<std::string, sdfg::types::Scalar>>& outputs,
    const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
    const bool has_side_effect, const DebugInfo& debug_info) {
    auto& dataflow = state.dataflow();

    auto vertex = boost::add_vertex(dataflow.graph_);
    auto res = dataflow.nodes_.insert(
        {vertex, std::unique_ptr<data_flow::LibraryNode>(new data_flow::LibraryNode(
                     this->element_counter_, debug_info, vertex, dataflow, outputs, inputs, call,
                     has_side_effect))});
    this->element_counter_++;
    return dynamic_cast<data_flow::LibraryNode&>(*(res.first->second));
}

}  // namespace builder
}  // namespace sdfg

1	#include "sdfg/builder/sdfg_builder.h"
2
3	namespace sdfg {
4	namespace builder {
5
6	Function& SDFGBuilder::function() const { return static_cast<Function&>(*this->sdfg_); };	56✔
7
8	SDFGBuilder::SDFGBuilder(std::unique_ptr<SDFG>& sdfg)	×
NEW 9	: FunctionBuilder(), sdfg_(std::move(sdfg)) {	×
10
11	};	×
12
13	SDFGBuilder::SDFGBuilder(const std::string& name)	50✔
14	: FunctionBuilder(), sdfg_(new SDFG(name)) {	50✔
15
16	};	50✔
17
18	SDFG& SDFGBuilder::subject() const { return *this->sdfg_; };	14✔
19
20	std::unique_ptr<SDFG> SDFGBuilder::move() { return std::move(this->sdfg_); };	32✔
21
22	/*** Section: Control-Flow Graph ***/
23
24	control_flow::State& SDFGBuilder::add_state(bool is_start_state, const DebugInfo& debug_info) {	67✔
25	auto vertex = boost::add_vertex(this->sdfg_->graph_);	67✔
26	auto res = this->sdfg_->states_.insert(	67✔
27	{vertex, std::unique_ptr<control_flow::State>(	67✔
28	new control_flow::State(this->element_counter_, debug_info, vertex))});	67✔
29	this->element_counter_++;	67✔
30	assert(res.second);	67✔
31
32	if (is_start_state) {	67✔
33	this->sdfg_->start_state_ = (*res.first).second.get();	14✔
34	}	14✔
35
36	return (res.first).second;	67✔
UNCOV 37	};	×
38
39	control_flow::State& SDFGBuilder::add_state_before(const control_flow::State& state,	1✔
40	bool is_start_state,
41	const DebugInfo& debug_info) {
42	auto& new_state = this->add_state(false, debug_info);	1✔
43
44	// Redirect control-flow
45	std::list<graph::Edge> descriptors_to_remove;	1✔
46	for (auto& edge : this->sdfg_->in_edges(state)) {	2✔
47	this->add_edge(edge.src(), new_state, edge.condition());	1✔
48
49	auto desc = edge.edge();	1✔
50	descriptors_to_remove.push_back(desc);	1✔
51	this->sdfg_->edges_.erase(desc);	1✔
52	}
53	for (auto desc : descriptors_to_remove) {	2✔
54	boost::remove_edge(desc, this->sdfg_->graph_);	1✔
55	}
56	this->add_edge(new_state, state);	1✔
57
58	if (is_start_state) {	1✔
59	this->sdfg_->start_state_ = &new_state;	×
UNCOV 60	}	×
61
62	return new_state;	1✔
63	};	1✔
64
65	control_flow::State& SDFGBuilder::add_state_after(const control_flow::State& state,	5✔
66	bool connect_states,
67	const DebugInfo& debug_info) {
68	auto& new_state = this->add_state(false, debug_info);	5✔
69
70	// Redirect control-flow
71	std::list<graph::Edge> descriptors_to_remove;	5✔
72	for (auto& edge : this->sdfg_->out_edges(state)) {	6✔
73	this->add_edge(new_state, edge.dst(), edge.condition());	1✔
74
75	auto desc = edge.edge();	1✔
76	descriptors_to_remove.push_back(desc);	1✔
77	this->sdfg_->edges_.erase(desc);	1✔
78	}
79	for (auto desc : descriptors_to_remove) {	6✔
80	boost::remove_edge(desc, this->sdfg_->graph_);	1✔
81	}
82	if (connect_states) {	5✔
83	this->add_edge(state, new_state);	4✔
84	}	4✔
85
86	return new_state;	5✔
87	};	5✔
88
89	control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,	44✔
90	const control_flow::State& dst,
91	const DebugInfo& debug_info) {
92	return this->add_edge(src, dst, symbolic::Assignments{}, SymEngine::boolTrue, debug_info);	44✔
UNCOV 93	};	×
94
95	control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,	8✔
96	const control_flow::State& dst,
97	const symbolic::Condition condition,
98	const DebugInfo& debug_info) {
99	return this->add_edge(src, dst, symbolic::Assignments{}, condition, debug_info);	8✔
UNCOV 100	};	×
101
102	control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,	2✔
103	const control_flow::State& dst,
104	const symbolic::Assignments& assignments,
105	const DebugInfo& debug_info) {
106	return this->add_edge(src, dst, assignments, SymEngine::boolTrue, debug_info);	2✔
UNCOV 107	};	×
108
109	control_flow::InterstateEdge& SDFGBuilder::add_edge(const control_flow::State& src,	56✔
110	const control_flow::State& dst,
111	const symbolic::Assignments& assignments,
112	const symbolic::Condition condition,
113	const DebugInfo& debug_info) {
114	auto edge = boost::add_edge(src.vertex_, dst.vertex_, this->sdfg_->graph_);	56✔
115	assert(edge.second);	56✔
116
117	auto res = this->sdfg_->edges_.insert(	56✔
118	{edge.first,	56✔
119	std::unique_ptr<control_flow::InterstateEdge>(new control_flow::InterstateEdge(	112✔
120	this->element_counter_, debug_info, edge.first, src, dst, condition, assignments))});	56✔
121	this->element_counter_++;	56✔
122	assert(res.second);	56✔
123
124	return (res.first).second;	56✔
UNCOV 125	};	×
126
127	void SDFGBuilder::remove_edge(const control_flow::InterstateEdge& edge) {	×
128	size_t erased = this->sdfg_->edges_.erase(edge.edge());	×
129	assert(erased == 1);	×
130
131	boost::remove_edge(edge.src().vertex_, edge.dst().vertex_, this->sdfg_->graph_);	×
132	};	×
133
134	std::tuple<control_flow::State&, control_flow::State&, control_flow::State&> SDFGBuilder::add_loop(	1✔
135	const control_flow::State& state, sdfg::symbolic::Symbol iterator,
136	sdfg::symbolic::Expression init, sdfg::symbolic::Condition cond,
137	sdfg::symbolic::Expression update, const DebugInfo& debug_info) {
138	// Init: iterator = init
139	auto& init_state = this->add_state_after(state, true, debug_info);	1✔
140	const graph::Edge init_edge_desc = (*this->sdfg_->in_edges(init_state).begin()).edge_;	1✔
141	auto& init_edge = this->sdfg_->edges_[init_edge_desc];	1✔
142	init_edge->assignments_.insert({iterator, init});	1✔
143
144	// Final state
145	auto& final_state = this->add_state_after(init_state, false, debug_info);	1✔
146
147	// Init -> early_exit -> final
148	auto& early_exit_state = this->add_state(false, debug_info);	1✔
149	this->add_edge(init_state, early_exit_state, symbolic::Not(cond));	1✔
150	this->add_edge(early_exit_state, final_state);	1✔
151
152	// Init -> header -> body
153	auto& header_state = this->add_state(false, debug_info);	1✔
154	this->add_edge(init_state, header_state, cond);	1✔
155
156	auto& body_state = this->add_state(false, debug_info);	1✔
157	this->add_edge(header_state, body_state);	1✔
158
159	auto& update_state = this->add_state(false, debug_info);	1✔
160	this->add_edge(body_state, update_state, {{iterator, update}});	1✔
161
162	// Back edge and exit edge
163	this->add_edge(update_state, header_state, cond);	1✔
164	this->add_edge(update_state, final_state, symbolic::Not(cond));	1✔
165
166	return {init_state, body_state, final_state};	1✔
UNCOV 167	};	×
168
169	/*** Section: Dataflow Graph ***/
170
171	data_flow::AccessNode& SDFGBuilder::add_access(control_flow::State& state, const std::string& data,	6✔
172	const DebugInfo& debug_info) {
173	auto& dataflow = state.dataflow();	6✔
174
175	auto vertex = boost::add_vertex(dataflow.graph_);	6✔
176	auto res = dataflow.nodes_.insert(	6✔
177	{vertex, std::unique_ptr<data_flow::AccessNode>(new data_flow::AccessNode(	12✔
178	this->element_counter_, debug_info, vertex, dataflow, data))});	6✔
179	this->element_counter_++;	6✔
180	return dynamic_cast<data_flow::AccessNode&>(*(res.first->second));	6✔
UNCOV 181	};	×
182
183	data_flow::Tasklet& SDFGBuilder::add_tasklet(	3✔
184	control_flow::State& state, const data_flow::TaskletCode code,
185	const std::pair<std::string, sdfg::types::Scalar>& output,
186	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
187	const DebugInfo& debug_info) {
188	auto& dataflow = state.dataflow();	3✔
189
190	auto vertex = boost::add_vertex(dataflow.graph_);	3✔
191	auto res =
192	dataflow.nodes_.insert({vertex, std::unique_ptr<data_flow::Tasklet>(new data_flow::Tasklet(	3✔
193	this->element_counter_, debug_info, vertex, dataflow,	3✔
194	code, output, inputs, symbolic::__true__()))});	3✔
195	this->element_counter_++;	3✔
196	return dynamic_cast<data_flow::Tasklet&>(*(res.first->second));	3✔
UNCOV 197	};	×
198
199	data_flow::Memlet& SDFGBuilder::add_memlet(control_flow::State& state, data_flow::DataFlowNode& src,	6✔
200	const std::string& src_conn,
201	data_flow::DataFlowNode& dst,
202	const std::string& dst_conn,
203	const data_flow::Subset& subset,
204	const DebugInfo& debug_info) {
205	auto& dataflow = state.dataflow();	6✔
206
207	auto edge = boost::add_edge(src.vertex_, dst.vertex_, dataflow.graph_);	6✔
208	auto res = dataflow.edges_.insert(	6✔
209	{edge.first, std::unique_ptr<data_flow::Memlet>(	6✔
210	new data_flow::Memlet(this->element_counter_, debug_info, edge.first,	12✔
211	dataflow, src, src_conn, dst, dst_conn, subset))});	6✔
212	this->element_counter_++;	6✔
213	return dynamic_cast<data_flow::Memlet&>(*(res.first->second));	6✔
UNCOV 214	};	×
215
216	data_flow::LibraryNode& SDFGBuilder::add_library_node(	2✔
217	control_flow::State& state, const data_flow::LibraryNodeType& call,
218	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& outputs,
219	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
220	const bool has_side_effect, const DebugInfo& debug_info) {
221	auto& dataflow = state.dataflow();	2✔
222
223	auto vertex = boost::add_vertex(dataflow.graph_);	2✔
224	auto res = dataflow.nodes_.insert(	2✔
225	{vertex, std::unique_ptr<data_flow::LibraryNode>(new data_flow::LibraryNode(	4✔
226	this->element_counter_, debug_info, vertex, dataflow, outputs, inputs, call,	2✔
227	has_side_effect))});	2✔
228	this->element_counter_++;	2✔
229	return dynamic_cast<data_flow::LibraryNode&>(*(res.first->second));	2✔
UNCOV 230	}	×
231
232	} // namespace builder
233	} // namespace sdfg

daisytuner / sdfglib / 15044057891

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