16439608634

Committed 22 Jul 2025 08:57AM UTC coverage: 65.982% (+0.9%) from 65.094%

Build # 16439608634

Build Type

Pull #153

github

Committed by

web-flow

Commit Message

Merge 373570200 into abe57c083

Pull Request Pull Request #153: Restricts memlets to contiguous memory

Run Details

213 of 317 new or added lines in 30 files covered. (67.19%)

66 existing lines in 7 files now uncovered.

8321 of 12611 relevant lines covered (65.98%)

128.51 hits per line

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

68.21

/src/builder/sdfg_builder.cpp

#include "sdfg/builder/sdfg_builder.h"

#include "sdfg/types/utils.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, FunctionType type)
    : FunctionBuilder(), sdfg_(new SDFG(name, type)) {

      };

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

std::unique_ptr<SDFG> SDFGBuilder::move() {
#ifndef NDEBUG
    this->sdfg_->validate();
#endif

    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->new_element_id(), debug_info, vertex))}
    );

    assert(res.second);
    (*res.first).second->dataflow_->parent_ = (*res.first).second.get();

    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);

    std::vector<const control_flow::InterstateEdge*> to_redirect;
    for (auto& e : this->sdfg_->in_edges(state)) to_redirect.push_back(&e);

    // Redirect control-flow
    for (auto edge : to_redirect) {
        this->add_edge(edge->src(), new_state, edge->condition());

        auto desc = edge->edge();
        this->sdfg_->edges_.erase(desc);
        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);

    std::vector<const control_flow::InterstateEdge*> to_redirect;
    for (auto& e : this->sdfg_->out_edges(state)) to_redirect.push_back(&e);

    // Redirect control-flow
    for (auto& edge : to_redirect) {
        this->add_edge(new_state, edge->dst(), edge->condition());

        auto desc = edge->edge();
        this->sdfg_->edges_.erase(desc);
        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, control_flow::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, control_flow::Assignments{}, condition, debug_info);
};

control_flow::InterstateEdge& SDFGBuilder::add_edge(
    const control_flow::State& src,
    const control_flow::State& dst,
    const control_flow::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 control_flow::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->new_element_id(), debug_info, edge.first, src, dst, condition, assignments
         ))}
    );

    assert(res.second);

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

void SDFGBuilder::remove_edge(const control_flow::InterstateEdge& edge) {
    auto desc = edge.edge();
    this->sdfg_->edges_.erase(desc);

    boost::remove_edge(desc, 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->new_element_id(), debug_info, vertex, dataflow, data)
         )}
    );

    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->new_element_id(), debug_info, vertex, dataflow, code, output, inputs, symbolic::__true__()
         ))}
    );

    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->new_element_id(), debug_info, edge.first, dataflow, src, src_conn, dst, dst_conn, subset
         ))}
    );

    return dynamic_cast<data_flow::Memlet&>(*(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& begin_subset,
    const data_flow::Subset& end_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->new_element_id(), debug_info, edge.first, dataflow, src, src_conn, dst, dst_conn, begin_subset, end_subset
         ))}
    );

    return dynamic_cast<data_flow::Memlet&>(*(res.first->second));
};

data_flow::Memlet& SDFGBuilder::add_computational_memlet(
    control_flow::State& state,
    data_flow::AccessNode& src,
    data_flow::Tasklet& dst,
    const std::string& dst_conn,
    const data_flow::Subset& subset,
    const DebugInfo& debug_info
) {
    return this->add_memlet(state, src, "void", dst, dst_conn, subset, debug_info);
};

data_flow::Memlet& SDFGBuilder::add_computational_memlet(
    control_flow::State& state,
    data_flow::Tasklet& src,
    const std::string& src_conn,
    data_flow::AccessNode& dst,
    const data_flow::Subset& subset,
    const DebugInfo& debug_info
) {
    return this->add_memlet(state, src, src_conn, dst, "void", subset, debug_info);
};

data_flow::Memlet& SDFGBuilder::add_computational_memlet(
    control_flow::State& state,
    data_flow::AccessNode& src,
    data_flow::LibraryNode& dst,
    const std::string& dst_conn,
    const data_flow::Subset& begin_subset,
    const data_flow::Subset& end_subset,
    const DebugInfo& debug_info
) {
    return this->add_memlet(state, src, "void", dst, dst_conn, begin_subset, end_subset, debug_info);
};

data_flow::Memlet& SDFGBuilder::add_computational_memlet(
    control_flow::State& state,
    data_flow::LibraryNode& src,
    const std::string& src_conn,
    data_flow::AccessNode& dst,
    const data_flow::Subset& begin_subset,
    const data_flow::Subset& end_subset,
    const DebugInfo& debug_info
) {
    return this->add_memlet(state, src, src_conn, dst, "void", begin_subset, end_subset, debug_info);
};

data_flow::Memlet& SDFGBuilder::add_reference_memlet(
    control_flow::State& state,
    data_flow::AccessNode& src,
    data_flow::AccessNode& dst,
    const data_flow::Subset& subset,
    const DebugInfo& debug_info
) {
    return this->add_memlet(state, src, "void", dst, "ref", subset, debug_info);
};

data_flow::Memlet& SDFGBuilder::add_dereference_memlet(
    control_flow::State& state,
    data_flow::AccessNode& src,
    data_flow::AccessNode& dst,
    bool derefs_src,
    const DebugInfo& debug_info
) {
    if (derefs_src) {
        return this->add_memlet(state, src, "void", dst, "deref", {symbolic::zero()}, debug_info);
    } else {
        return this->add_memlet(state, src, "deref", dst, "void", {symbolic::zero()}, debug_info);
    }
};

} // namespace builder
} // namespace sdfg

1	#include "sdfg/builder/sdfg_builder.h"
2
3	#include "sdfg/types/utils.h"
4
5	namespace sdfg {
6	namespace builder {
7
8	Function& SDFGBuilder::function() const { return static_cast<Function&>(*this->sdfg_); };	199✔
9
10	SDFGBuilder::SDFGBuilder(std::unique_ptr<SDFG>& sdfg)	×
11	: FunctionBuilder(), sdfg_(std::move(sdfg)) {	×
12
13	};	×
14
15	SDFGBuilder::SDFGBuilder(const std::string& name, FunctionType type)	49✔
16	: FunctionBuilder(), sdfg_(new SDFG(name, type)) {	49✔
17
18	};	49✔
19
20	SDFG& SDFGBuilder::subject() const { return *this->sdfg_; };	14✔
21
22	std::unique_ptr<SDFG> SDFGBuilder::move() {	31✔
23	#ifndef NDEBUG
24	this->sdfg_->validate();	31✔
25	#endif
26
27	return std::move(this->sdfg_);	31✔
28	};
29
30	/*** Section: Control-Flow Graph ***/
31
32	control_flow::State& SDFGBuilder::add_state(bool is_start_state, const DebugInfo& debug_info) {	61✔
33	auto vertex = boost::add_vertex(this->sdfg_->graph_);	61✔
34	auto res = this->sdfg_->states_.insert(	122✔
35	{vertex,	61✔
36	std::unique_ptr<control_flow::State>(new control_flow::State(this->new_element_id(), debug_info, vertex))}	61✔
37	);
38
39	assert(res.second);	61✔
40	(res.first).second->dataflow_->parent_ = (res.first).second.get();	61✔
41
42	if (is_start_state) {	61✔
43	this->sdfg_->start_state_ = (*res.first).second.get();	12✔
44	}	12✔
45
46	return (res.first).second;	61✔
47	};	×
48
49	control_flow::State& SDFGBuilder::
50	add_state_before(const control_flow::State& state, bool is_start_state, const DebugInfo& debug_info) {	1✔
51	auto& new_state = this->add_state(false, debug_info);	1✔
52
53	std::vector<const control_flow::InterstateEdge*> to_redirect;	1✔
54	for (auto& e : this->sdfg_->in_edges(state)) to_redirect.push_back(&e);	2✔
55
56	// Redirect control-flow
57	for (auto edge : to_redirect) {	2✔
58	this->add_edge(edge->src(), new_state, edge->condition());	1✔
59
60	auto desc = edge->edge();	1✔
61	this->sdfg_->edges_.erase(desc);	1✔
62	boost::remove_edge(desc, this->sdfg_->graph_);	1✔
63	}
64	this->add_edge(new_state, state);	1✔
65
66	if (is_start_state) {	1✔
67	this->sdfg_->start_state_ = &new_state;	×
68	}	×
69
70	return new_state;	1✔
71	};	1✔
72
73	control_flow::State& SDFGBuilder::
74	add_state_after(const control_flow::State& state, bool connect_states, const DebugInfo& debug_info) {	5✔
75	auto& new_state = this->add_state(false, debug_info);	5✔
76
77	std::vector<const control_flow::InterstateEdge*> to_redirect;	5✔
78	for (auto& e : this->sdfg_->out_edges(state)) to_redirect.push_back(&e);	6✔
79
80	// Redirect control-flow
81	for (auto& edge : to_redirect) {	6✔
82	this->add_edge(new_state, edge->dst(), edge->condition());	1✔
83
84	auto desc = edge->edge();	1✔
85	this->sdfg_->edges_.erase(desc);	1✔
86	boost::remove_edge(desc, this->sdfg_->graph_);	1✔
87	}
88	if (connect_states) {	5✔
89	this->add_edge(state, new_state);	4✔
90	}	4✔
91
92	return new_state;	5✔
93	};	5✔
94
95	control_flow::InterstateEdge& SDFGBuilder::
96	add_edge(const control_flow::State& src, const control_flow::State& dst, const DebugInfo& debug_info) {	39✔
97	return this->add_edge(src, dst, control_flow::Assignments{}, SymEngine::boolTrue, debug_info);	39✔
98	};	×
99
100	control_flow::InterstateEdge& SDFGBuilder::add_edge(	8✔
101	const control_flow::State& src,
102	const control_flow::State& dst,
103	const symbolic::Condition condition,
104	const DebugInfo& debug_info
105	) {
106	return this->add_edge(src, dst, control_flow::Assignments{}, condition, debug_info);	8✔
107	};	×
108
109	control_flow::InterstateEdge& SDFGBuilder::add_edge(	2✔
110	const control_flow::State& src,
111	const control_flow::State& dst,
112	const control_flow::Assignments& assignments,
113	const DebugInfo& debug_info
114	) {
115	return this->add_edge(src, dst, assignments, SymEngine::boolTrue, debug_info);	2✔
116	};	×
117
118	control_flow::InterstateEdge& SDFGBuilder::add_edge(	51✔
119	const control_flow::State& src,
120	const control_flow::State& dst,
121	const control_flow::Assignments& assignments,
122	const symbolic::Condition condition,
123	const DebugInfo& debug_info
124	) {
125	auto edge = boost::add_edge(src.vertex_, dst.vertex_, this->sdfg_->graph_);	51✔
126	assert(edge.second);	51✔
127
128	auto res = this->sdfg_->edges_.insert(	102✔
129	{edge.first,	102✔
130	std::unique_ptr<control_flow::InterstateEdge>(new control_flow::InterstateEdge(	51✔
131	this->new_element_id(), debug_info, edge.first, src, dst, condition, assignments	51✔
132	))}
133	);
134
135	assert(res.second);	51✔
136
137	return (res.first).second;	51✔
138	};	×
139
140	void SDFGBuilder::remove_edge(const control_flow::InterstateEdge& edge) {	×
141	auto desc = edge.edge();	×
142	this->sdfg_->edges_.erase(desc);	×
143
144	boost::remove_edge(desc, this->sdfg_->graph_);	×
145	};	×
146
147	std::tuple<control_flow::State&, control_flow::State&, control_flow::State&> SDFGBuilder::add_loop(	1✔
148	const control_flow::State& state,
149	sdfg::symbolic::Symbol iterator,
150	sdfg::symbolic::Expression init,
151	sdfg::symbolic::Condition cond,
152	sdfg::symbolic::Expression update,
153	const DebugInfo& debug_info
154	) {
155	// Init: iterator = init
156	auto& init_state = this->add_state_after(state, true, debug_info);	1✔
157	const graph::Edge init_edge_desc = (*this->sdfg_->in_edges(init_state).begin()).edge_;	1✔
158	auto& init_edge = this->sdfg_->edges_[init_edge_desc];	1✔
159	init_edge->assignments_.insert({iterator, init});	1✔
160
161	// Final state
162	auto& final_state = this->add_state_after(init_state, false, debug_info);	1✔
163
164	// Init -> early_exit -> final
165	auto& early_exit_state = this->add_state(false, debug_info);	1✔
166	this->add_edge(init_state, early_exit_state, symbolic::Not(cond));	1✔
167	this->add_edge(early_exit_state, final_state);	1✔
168
169	// Init -> header -> body
170	auto& header_state = this->add_state(false, debug_info);	1✔
171	this->add_edge(init_state, header_state, cond);	1✔
172
173	auto& body_state = this->add_state(false, debug_info);	1✔
174	this->add_edge(header_state, body_state);	1✔
175
176	auto& update_state = this->add_state(false, debug_info);	1✔
177	this->add_edge(body_state, update_state, {{iterator, update}});	1✔
178
179	// Back edge and exit edge
180	this->add_edge(update_state, header_state, cond);	1✔
181	this->add_edge(update_state, final_state, symbolic::Not(cond));	1✔
182
183	return {init_state, body_state, final_state};	1✔
184	};	×
185
186	/*** Section: Dataflow Graph ***/
187
188	data_flow::AccessNode& SDFGBuilder::
189	add_access(control_flow::State& state, const std::string& data, const DebugInfo& debug_info) {	6✔
190	auto& dataflow = state.dataflow();	6✔
191	auto vertex = boost::add_vertex(dataflow.graph_);	6✔
192	auto res = dataflow.nodes_.insert(	12✔
193	{vertex,	6✔
194	std::unique_ptr<	6✔
195	data_flow::AccessNode>(new data_flow::AccessNode(this->new_element_id(), debug_info, vertex, dataflow, data)	6✔
196	)}
197	);
198
199	return dynamic_cast<data_flow::AccessNode&>(*(res.first->second));	6✔
200	};	×
201
202	data_flow::Tasklet& SDFGBuilder::add_tasklet(	3✔
203	control_flow::State& state,
204	const data_flow::TaskletCode code,
205	const std::pair<std::string, sdfg::types::Scalar>& output,
206	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
207	const DebugInfo& debug_info
208	) {
209	auto& dataflow = state.dataflow();	3✔
210	auto vertex = boost::add_vertex(dataflow.graph_);	3✔
211	auto res = dataflow.nodes_.insert(	6✔
212	{vertex,	3✔
213	std::unique_ptr<data_flow::Tasklet>(new data_flow::Tasklet(	6✔
214	this->new_element_id(), debug_info, vertex, dataflow, code, output, inputs, symbolic::__true__()	3✔
215	))}
216	);
217
218	return dynamic_cast<data_flow::Tasklet&>(*(res.first->second));	3✔
UNCOV 219	};	×
220
221	data_flow::Memlet& SDFGBuilder::add_memlet(	6✔
222	control_flow::State& state,
223	data_flow::DataFlowNode& src,
224	const std::string& src_conn,
225	data_flow::DataFlowNode& dst,
226	const std::string& dst_conn,
227	const data_flow::Subset& subset,
228	const DebugInfo& debug_info
229	) {
230	auto& dataflow = state.dataflow();	6✔
231	auto edge = boost::add_edge(src.vertex_, dst.vertex_, dataflow.graph_);	6✔
232	auto res = dataflow.edges_.insert(	12✔
233	{edge.first,	12✔
234	std::unique_ptr<data_flow::Memlet>(new data_flow::Memlet(	6✔
235	this->new_element_id(), debug_info, edge.first, dataflow, src, src_conn, dst, dst_conn, subset	6✔
236	))}
237	);
238
239	return dynamic_cast<data_flow::Memlet&>(*(res.first->second));	6✔
240	};	×
241
242	data_flow::Memlet& SDFGBuilder::add_memlet(	×
243	control_flow::State& state,
244	data_flow::DataFlowNode& src,
245	const std::string& src_conn,
246	data_flow::DataFlowNode& dst,
247	const std::string& dst_conn,
248	const data_flow::Subset& begin_subset,
249	const data_flow::Subset& end_subset,
250	const DebugInfo& debug_info
251	) {
252	auto& dataflow = state.dataflow();	×
UNCOV 253	auto edge = boost::add_edge(src.vertex_, dst.vertex_, dataflow.graph_);	×
254	auto res = dataflow.edges_.insert(	×
255	{edge.first,	×
256	std::unique_ptr<data_flow::Memlet>(new data_flow::Memlet(	×
257	this->new_element_id(), debug_info, edge.first, dataflow, src, src_conn, dst, dst_conn, begin_subset, end_subset	×
258	))}
259	);
260
261	return dynamic_cast<data_flow::Memlet&>(*(res.first->second));	×
262	};	×
263
NEW 264	data_flow::Memlet& SDFGBuilder::add_computational_memlet(	×
265	control_flow::State& state,
266	data_flow::AccessNode& src,
267	data_flow::Tasklet& dst,
268	const std::string& dst_conn,
269	const data_flow::Subset& subset,
270	const DebugInfo& debug_info
271	) {
NEW 272	return this->add_memlet(state, src, "void", dst, dst_conn, subset, debug_info);	×
NEW 273	};	×
274
NEW 275	data_flow::Memlet& SDFGBuilder::add_computational_memlet(	×
276	control_flow::State& state,
277	data_flow::Tasklet& src,
278	const std::string& src_conn,
279	data_flow::AccessNode& dst,
280	const data_flow::Subset& subset,
281	const DebugInfo& debug_info
282	) {
NEW 283	return this->add_memlet(state, src, src_conn, dst, "void", subset, debug_info);	×
NEW 284	};	×
285
NEW 286	data_flow::Memlet& SDFGBuilder::add_computational_memlet(	×
287	control_flow::State& state,
288	data_flow::AccessNode& src,
289	data_flow::LibraryNode& dst,
290	const std::string& dst_conn,
291	const data_flow::Subset& begin_subset,
292	const data_flow::Subset& end_subset,
293	const DebugInfo& debug_info
294	) {
NEW 295	return this->add_memlet(state, src, "void", dst, dst_conn, begin_subset, end_subset, debug_info);	×
NEW 296	};	×
297
NEW 298	data_flow::Memlet& SDFGBuilder::add_computational_memlet(	×
299	control_flow::State& state,
300	data_flow::LibraryNode& src,
301	const std::string& src_conn,
302	data_flow::AccessNode& dst,
303	const data_flow::Subset& begin_subset,
304	const data_flow::Subset& end_subset,
305	const DebugInfo& debug_info
306	) {
NEW 307	return this->add_memlet(state, src, src_conn, dst, "void", begin_subset, end_subset, debug_info);	×
NEW 308	};	×
309
NEW 310	data_flow::Memlet& SDFGBuilder::add_reference_memlet(	×
311	control_flow::State& state,
312	data_flow::AccessNode& src,
313	data_flow::AccessNode& dst,
314	const data_flow::Subset& subset,
315	const DebugInfo& debug_info
316	) {
NEW 317	return this->add_memlet(state, src, "void", dst, "ref", subset, debug_info);	×
NEW 318	};	×
319
NEW 320	data_flow::Memlet& SDFGBuilder::add_dereference_memlet(	×
321	control_flow::State& state,
322	data_flow::AccessNode& src,
323	data_flow::AccessNode& dst,
324	bool derefs_src,
325	const DebugInfo& debug_info
326	) {
NEW 327	if (derefs_src) {	×
NEW 328	return this->add_memlet(state, src, "void", dst, "deref", {symbolic::zero()}, debug_info);	×
329	} else {
NEW 330	return this->add_memlet(state, src, "deref", dst, "void", {symbolic::zero()}, debug_info);	×
331	}
NEW 332	};	×
333
334	} // namespace builder
335	} // namespace sdfg

daisytuner / sdfglib / 16439608634

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