16069945621

Committed 04 Jul 2025 08:56AM UTC coverage: 64.375% (-0.2%) from 64.606%

Build # 16069945621

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #137 from daisytuner/clang-format

runs clang-format on codebase

Run Details

609 of 827 new or added lines in 63 files covered. (73.64%)

46 existing lines in 30 files now uncovered.

8578 of 13325 relevant lines covered (64.38%)

177.24 hits per line

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

31.01

/src/data_flow/data_flow_graph.cpp

#include "sdfg/data_flow/data_flow_graph.h"

namespace sdfg {
namespace data_flow {

const Element* DataFlowGraph::get_parent() const { return this->parent_; };

Element* DataFlowGraph::get_parent() { return this->parent_; };

size_t DataFlowGraph::in_degree(const data_flow::DataFlowNode& node) const {
    return boost::in_degree(node.vertex(), this->graph_);
};

size_t DataFlowGraph::out_degree(const data_flow::DataFlowNode& node) const {
    return boost::out_degree(node.vertex(), this->graph_);
};

void DataFlowGraph::replace(const symbolic::Expression& old_expression, const symbolic::Expression& new_expression) {
    for (auto& node : this->nodes_) {
        node.second->replace(old_expression, new_expression);
    }

    for (auto& edge : this->edges_) {
        edge.second->replace(old_expression, new_expression);
    }
};

/***** Section: Analysis *****/

std::unordered_set<const data_flow::Tasklet*> DataFlowGraph::tasklets() const {
    std::unordered_set<const data_flow::Tasklet*> ts;
    for (auto& node : this->nodes_) {
        if (auto tasklet = dynamic_cast<const data_flow::Tasklet*>(node.second.get())) {
            ts.insert(tasklet);
        }
    }

    return ts;
};

std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::data_nodes() const {
    std::unordered_set<const data_flow::AccessNode*> dnodes;
    for (auto& node : this->nodes_) {
        if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {
            dnodes.insert(access_node);
        }
    }

    return dnodes;
};

std::unordered_set<data_flow::AccessNode*> DataFlowGraph::data_nodes() {
    std::unordered_set<data_flow::AccessNode*> dnodes;
    for (auto& node : this->nodes_) {
        if (auto access_node = dynamic_cast<data_flow::AccessNode*>(node.second.get())) {
            dnodes.insert(access_node);
        }
    }

    return dnodes;
};

std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::reads() const {
    std::unordered_set<const data_flow::AccessNode*> rs;
    for (auto& node : this->nodes_) {
        if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {
            if (this->out_degree(*access_node) > 0) {
                rs.insert(access_node);
            }
        }
    }

    return rs;
};

std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::writes() const {
    std::unordered_set<const data_flow::AccessNode*> ws;
    for (auto& node : this->nodes_) {
        if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {
            if (this->in_degree(*access_node) > 0) {
                ws.insert(access_node);
            }
        }
    }

    return ws;
};

std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::sources() const {
    std::unordered_set<const data_flow::DataFlowNode*> ss;
    for (auto& node : this->nodes_) {
        if (this->in_degree(*node.second) == 0) {
            ss.insert(node.second.get());
        }
    }

    return ss;
};

std::unordered_set<data_flow::DataFlowNode*> DataFlowGraph::sources() {
    std::unordered_set<data_flow::DataFlowNode*> ss;
    for (auto& node : this->nodes_) {
        if (this->in_degree(*node.second) == 0) {
            ss.insert(node.second.get());
        }
    }

    return ss;
};

std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::sinks() const {
    std::unordered_set<const data_flow::DataFlowNode*> ss;
    for (auto& node : this->nodes_) {
        if (this->out_degree(*node.second) == 0) {
            ss.insert(node.second.get());
        }
    }

    return ss;
};

std::unordered_set<data_flow::DataFlowNode*> DataFlowGraph::sinks() {
    std::unordered_set<data_flow::DataFlowNode*> ss;
    for (auto& node : this->nodes_) {
        if (this->out_degree(*node.second) == 0) {
            ss.insert(node.second.get());
        }
    }

    return ss;
};

std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::predecessors(const data_flow::DataFlowNode& node
) const {
    std::unordered_set<const data_flow::DataFlowNode*> ss;
    for (auto& edge : this->in_edges(node)) {
        ss.insert(&edge.src());
    }

    return ss;
};

std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::successors(const data_flow::DataFlowNode& node
) const {
    std::unordered_set<const data_flow::DataFlowNode*> ss;
    for (auto& edge : this->out_edges(node)) {
        ss.insert(&edge.dst());
    }

    return ss;
};

std::list<const data_flow::DataFlowNode*> DataFlowGraph::topological_sort() const {
    std::list<graph::Vertex> order = graph::topological_sort(this->graph_);

    std::list<const data_flow::DataFlowNode*> topo_nodes;
    for (auto& vertex : order) {
        topo_nodes.push_back(this->nodes_.at(vertex).get());
    }

    return topo_nodes;
};

std::list<data_flow::DataFlowNode*> DataFlowGraph::topological_sort() {
    std::list<graph::Vertex> order = graph::topological_sort(this->graph_);

    std::list<data_flow::DataFlowNode*> topo_nodes;
    for (auto& vertex : order) {
        topo_nodes.push_back(this->nodes_.at(vertex).get());
    }

    return topo_nodes;
};

std::unordered_map<std::string, const data_flow::AccessNode*> DataFlowGraph::dominators() const {
    std::unordered_map<std::string, const data_flow::AccessNode*> frontier;
    for (auto& node : this->topological_sort()) {
        if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node)) {
            if (frontier.find(access_node->data()) == frontier.end()) {
                frontier[access_node->data()] = access_node;
            }
        }
    }

    return frontier;
};

std::unordered_map<std::string, const data_flow::AccessNode*> DataFlowGraph::post_dominators() const {
    std::unordered_map<std::string, const data_flow::AccessNode*> frontier;
    for (auto& node : this->topological_sort()) {
        if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node)) {
            frontier[access_node->data()] = access_node;
        }
    }

    return frontier;
};

std::unordered_map<std::string, data_flow::AccessNode*> DataFlowGraph::post_dominators() {
    std::unordered_map<std::string, data_flow::AccessNode*> frontier;
    for (auto& node : this->topological_sort()) {
        if (auto access_node = dynamic_cast<data_flow::AccessNode*>(node)) {
            frontier[access_node->data()] = access_node;
        }
    }

    return frontier;
};

auto DataFlowGraph::all_simple_paths(const data_flow::DataFlowNode& src, const data_flow::DataFlowNode& dst) const {
    std::list<std::list<graph::Edge>> all_paths_raw = graph::all_simple_paths(this->graph_, src.vertex(), dst.vertex());

    std::list<std::list<std::reference_wrapper<data_flow::Memlet>>> all_paths;
    for (auto& path_raw : all_paths_raw) {
        std::list<std::reference_wrapper<data_flow::Memlet>> path;
        for (auto& edge : path_raw) {
            path.push_back(*this->edges_.at(edge));
        }
        all_paths.push_back(path);
    }

    return all_paths;
};

const std::pair<size_t, const std::unordered_map<const data_flow::DataFlowNode*, size_t>> DataFlowGraph::
    weakly_connected_components() const {
    auto ccs_vertex = graph::weakly_connected_components(this->graph_);

    std::unordered_map<const data_flow::DataFlowNode*, size_t> ccs;
    for (auto& entry : ccs_vertex.second) {
        ccs[this->nodes_.at(entry.first).get()] = entry.second;
    }

    return {ccs_vertex.first, ccs};
};

} // namespace data_flow
} // namespace sdfg

1	#include "sdfg/data_flow/data_flow_graph.h"
2
3	namespace sdfg {
4	namespace data_flow {
5
6	const Element* DataFlowGraph::get_parent() const { return this->parent_; };	×
7
8	Element* DataFlowGraph::get_parent() { return this->parent_; };	275✔
9
10	size_t DataFlowGraph::in_degree(const data_flow::DataFlowNode& node) const {	500✔
11	return boost::in_degree(node.vertex(), this->graph_);	500✔
12	};
13
14	size_t DataFlowGraph::out_degree(const data_flow::DataFlowNode& node) const {	490✔
15	return boost::out_degree(node.vertex(), this->graph_);	490✔
16	};
17
18	void DataFlowGraph::replace(const symbolic::Expression& old_expression, const symbolic::Expression& new_expression) {	2✔
19	for (auto& node : this->nodes_) {	10✔
20	node.second->replace(old_expression, new_expression);	8✔
21	}
22
23	for (auto& edge : this->edges_) {	8✔
24	edge.second->replace(old_expression, new_expression);	6✔
25	}
26	};	2✔
27
28	/*** Section: Analysis ***/
29
30	std::unordered_set<const data_flow::Tasklet*> DataFlowGraph::tasklets() const {	24✔
31	std::unordered_set<const data_flow::Tasklet*> ts;	24✔
32	for (auto& node : this->nodes_) {	93✔
33	if (auto tasklet = dynamic_cast<const data_flow::Tasklet*>(node.second.get())) {	69✔
34	ts.insert(tasklet);	24✔
35	}	24✔
36	}
37
38	return ts;	24✔
39	};	24✔
40
41	std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::data_nodes() const {	×
42	std::unordered_set<const data_flow::AccessNode*> dnodes;	×
43	for (auto& node : this->nodes_) {	×
44	if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {	×
45	dnodes.insert(access_node);	×
46	}	×
47	}
48
49	return dnodes;	×
50	};	×
51
52	std::unordered_set<data_flow::AccessNode*> DataFlowGraph::data_nodes() {	2✔
53	std::unordered_set<data_flow::AccessNode*> dnodes;	2✔
54	for (auto& node : this->nodes_) {	10✔
55	if (auto access_node = dynamic_cast<data_flow::AccessNode*>(node.second.get())) {	8✔
56	dnodes.insert(access_node);	6✔
57	}	6✔
58	}
59
60	return dnodes;	2✔
61	};	2✔
62
63	std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::reads() const {	×
64	std::unordered_set<const data_flow::AccessNode*> rs;	×
65	for (auto& node : this->nodes_) {	×
66	if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {	×
67	if (this->out_degree(*access_node) > 0) {	×
68	rs.insert(access_node);	×
69	}	×
70	}	×
71	}
72
73	return rs;	×
74	};	×
75
76	std::unordered_set<const data_flow::AccessNode*> DataFlowGraph::writes() const {	×
77	std::unordered_set<const data_flow::AccessNode*> ws;	×
78	for (auto& node : this->nodes_) {	×
79	if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node.second.get())) {	×
80	if (this->in_degree(*access_node) > 0) {	×
81	ws.insert(access_node);	×
82	}	×
83	}	×
84	}
85
86	return ws;	×
87	};	×
88
89	std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::sources() const {	×
90	std::unordered_set<const data_flow::DataFlowNode*> ss;	×
91	for (auto& node : this->nodes_) {	×
92	if (this->in_degree(*node.second) == 0) {	×
93	ss.insert(node.second.get());	×
94	}	×
95	}
96
97	return ss;	×
98	};	×
99
100	std::unordered_set<data_flow::DataFlowNode*> DataFlowGraph::sources() {	×
101	std::unordered_set<data_flow::DataFlowNode*> ss;	×
102	for (auto& node : this->nodes_) {	×
103	if (this->in_degree(*node.second) == 0) {	×
104	ss.insert(node.second.get());	×
105	}	×
106	}
107
108	return ss;	×
109	};	×
110
111	std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::sinks() const {	×
112	std::unordered_set<const data_flow::DataFlowNode*> ss;	×
113	for (auto& node : this->nodes_) {	×
114	if (this->out_degree(*node.second) == 0) {	×
115	ss.insert(node.second.get());	×
116	}	×
117	}
118
119	return ss;	×
120	};	×
121
122	std::unordered_set<data_flow::DataFlowNode*> DataFlowGraph::sinks() {	×
123	std::unordered_set<data_flow::DataFlowNode*> ss;	×
124	for (auto& node : this->nodes_) {	×
125	if (this->out_degree(*node.second) == 0) {	×
126	ss.insert(node.second.get());	×
127	}	×
128	}
129
130	return ss;	×
131	};	×
132
NEW 133	std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::predecessors(const data_flow::DataFlowNode& node	×
134	) const {
135	std::unordered_set<const data_flow::DataFlowNode*> ss;	×
136	for (auto& edge : this->in_edges(node)) {	×
137	ss.insert(&edge.src());	×
138	}
139
140	return ss;	×
141	};	×
142
NEW 143	std::unordered_set<const data_flow::DataFlowNode*> DataFlowGraph::successors(const data_flow::DataFlowNode& node	×
144	) const {
145	std::unordered_set<const data_flow::DataFlowNode*> ss;	×
146	for (auto& edge : this->out_edges(node)) {	×
147	ss.insert(&edge.dst());	×
148	}
149
150	return ss;	×
151	};	×
152
153	std::list<const data_flow::DataFlowNode*> DataFlowGraph::topological_sort() const {	182✔
154	std::list<graph::Vertex> order = graph::topological_sort(this->graph_);	182✔
155
156	std::list<const data_flow::DataFlowNode*> topo_nodes;	182✔
157	for (auto& vertex : order) {	569✔
158	topo_nodes.push_back(this->nodes_.at(vertex).get());	387✔
159	}
160
161	return topo_nodes;	182✔
162	};	182✔
163
164	std::list<data_flow::DataFlowNode*> DataFlowGraph::topological_sort() {	407✔
165	std::list<graph::Vertex> order = graph::topological_sort(this->graph_);	407✔
166
167	std::list<data_flow::DataFlowNode*> topo_nodes;	407✔
168	for (auto& vertex : order) {	1,127✔
169	topo_nodes.push_back(this->nodes_.at(vertex).get());	720✔
170	}
171
172	return topo_nodes;	407✔
173	};	407✔
174
175	std::unordered_map<std::string, const data_flow::AccessNode*> DataFlowGraph::dominators() const {	×
176	std::unordered_map<std::string, const data_flow::AccessNode*> frontier;	×
177	for (auto& node : this->topological_sort()) {	×
178	if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node)) {	×
179	if (frontier.find(access_node->data()) == frontier.end()) {	×
180	frontier[access_node->data()] = access_node;	×
181	}	×
182	}	×
183	}
184
185	return frontier;	×
186	};	×
187
NEW 188	std::unordered_map<std::string, const data_flow::AccessNode*> DataFlowGraph::post_dominators() const {	×
UNCOV 189	std::unordered_map<std::string, const data_flow::AccessNode*> frontier;	×
190	for (auto& node : this->topological_sort()) {	×
191	if (auto access_node = dynamic_cast<const data_flow::AccessNode*>(node)) {	×
192	frontier[access_node->data()] = access_node;	×
193	}	×
194	}
195
196	return frontier;	×
197	};	×
198
199	std::unordered_map<std::string, data_flow::AccessNode*> DataFlowGraph::post_dominators() {	3✔
200	std::unordered_map<std::string, data_flow::AccessNode*> frontier;	3✔
201	for (auto& node : this->topological_sort()) {	12✔
202	if (auto access_node = dynamic_cast<data_flow::AccessNode*>(node)) {	9✔
203	frontier[access_node->data()] = access_node;	6✔
204	}	6✔
205	}
206
207	return frontier;	3✔
208	};	3✔
209
NEW 210	auto DataFlowGraph::all_simple_paths(const data_flow::DataFlowNode& src, const data_flow::DataFlowNode& dst) const {	×
NEW 211	std::list<std::list<graph::Edge>> all_paths_raw = graph::all_simple_paths(this->graph_, src.vertex(), dst.vertex());	×
212
213	std::list<std::list<std::reference_wrapper<data_flow::Memlet>>> all_paths;	×
214	for (auto& path_raw : all_paths_raw) {	×
215	std::list<std::reference_wrapper<data_flow::Memlet>> path;	×
216	for (auto& edge : path_raw) {	×
217	path.push_back(*this->edges_.at(edge));	×
218	}
219	all_paths.push_back(path);	×
220	}	×
221
222	return all_paths;	×
223	};	×
224
225	const std::pair<size_t, const std::unordered_map<const data_flow::DataFlowNode*, size_t>> DataFlowGraph::
NEW 226	weakly_connected_components() const {	×
UNCOV 227	auto ccs_vertex = graph::weakly_connected_components(this->graph_);	×
228
229	std::unordered_map<const data_flow::DataFlowNode*, size_t> ccs;	×
230	for (auto& entry : ccs_vertex.second) {	×
231	ccs[this->nodes_.at(entry.first).get()] = entry.second;	×
232	}
233
234	return {ccs_vertex.first, ccs};	×
235	};	×
236
237	} // namespace data_flow
238	} // namespace sdfg

daisytuner / sdfglib / 16069945621

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