15680526203

Committed 16 Jun 2025 12:15PM UTC coverage: 61.814% (-3.1%) from 64.886%

Build # 15680526203

Build Type

Pull #70

github

Committed by

web-flow

Commit Message

Merge b4d2c1d98 into 838eda599

Pull Request Pull Request #70: Changes in order for the Einsum plugin to work correctly

Run Details

0 of 73 new or added lines in 6 files covered. (0.0%)

303 existing lines in 20 files now uncovered.

7600 of 12295 relevant lines covered (61.81%)

115.18 hits per line

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

70.83

/include/sdfg/data_flow/data_flow_graph.h

#pragma once

#include <boost/graph/graphviz.hpp>
#include <nlohmann/json.hpp>
#include <string>

#include "sdfg/data_flow/access_node.h"
#include "sdfg/data_flow/data_flow_node.h"
#include "sdfg/data_flow/library_node.h"
#include "sdfg/data_flow/memlet.h"
#include "sdfg/data_flow/tasklet.h"
#include "sdfg/graph/graph.h"
#include "sdfg/helpers/helpers.h"
#include "sdfg/symbolic/symbolic.h"

using json = nlohmann::json;

namespace sdfg {

namespace builder {
class SDFGBuilder;
class StructuredSDFGBuilder;
}  // namespace builder

namespace data_flow {

class DataFlowGraph {
    friend class sdfg::builder::SDFGBuilder;
    friend class sdfg::builder::StructuredSDFGBuilder;

   private:
    // Remark: Exclusive resource
    graph::Graph graph_;
    std::unordered_map<graph::Vertex, std::unique_ptr<data_flow::DataFlowNode>,
                       boost::hash<graph::Vertex>>
        nodes_;
    std::unordered_map<graph::Edge, std::unique_ptr<data_flow::Memlet>, boost::hash<graph::Edge>>
        edges_;

    Element* parent_;

   public:
    DataFlowGraph() = default;
    ~DataFlowGraph() = default;

    DataFlowGraph(const DataFlowGraph& graph) = delete;
    DataFlowGraph& operator=(const DataFlowGraph&) = delete;

    const Element* get_parent() const;

    Element* get_parent();

    auto nodes() const {
        return std::views::values(this->nodes_) |
               std::views::transform(helpers::indirect<data_flow::DataFlowNode>) |
               std::views::transform(helpers::add_const<data_flow::DataFlowNode>);
    };

    auto nodes() {
        return std::views::values(this->nodes_) |
               std::views::transform(helpers::indirect<data_flow::DataFlowNode>);
    };

    auto edges() const {
        return std::views::values(this->edges_) |
               std::views::transform(helpers::indirect<data_flow::Memlet>) |
               std::views::transform(helpers::add_const<data_flow::Memlet>);
    };

    auto edges() {
        return std::views::values(this->edges_) |
               std::views::transform(helpers::indirect<data_flow::Memlet>);
    };

    auto in_edges(const data_flow::DataFlowNode& node) const {
        auto [eb, ee] = boost::in_edges(node.vertex(), this->graph_);
        auto edges = std::ranges::subrange(eb, ee);

        auto memlets =
            std::views::transform(
                edges,
                [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {
                    return *(lookup_table.find(edge)->second);
                }) |
            std::views::transform(helpers::add_const<data_flow::Memlet>);

        return memlets;
    };

    auto in_edges(const data_flow::DataFlowNode& node) {
        auto [eb, ee] = boost::in_edges(node.vertex(), this->graph_);
        auto edges = std::ranges::subrange(eb, ee);

        auto memlets = std::views::transform(
            edges, [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {
                return *(lookup_table.find(edge)->second);
            });

        return memlets;
    };

    auto out_edges(const data_flow::DataFlowNode& node) const {
        auto [eb, ee] = boost::out_edges(node.vertex(), this->graph_);
        auto edges = std::ranges::subrange(eb, ee);

        auto memlets =
            std::views::transform(
                edges,
                [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {
                    return *(lookup_table.find(edge)->second);
                }) |
            std::views::transform(helpers::add_const<data_flow::Memlet>);

        return memlets;
    };

    auto out_edges(const data_flow::DataFlowNode& node) {
        auto [eb, ee] = boost::out_edges(node.vertex(), this->graph_);
        auto edges = std::ranges::subrange(eb, ee);

        auto memlets = std::views::transform(
            edges, [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {
                return *(lookup_table.find(edge)->second);
            });

        return memlets;
    };

    size_t in_degree(const data_flow::DataFlowNode& node) const;

    size_t out_degree(const data_flow::DataFlowNode& node) const;

    void replace(const symbolic::Expression& old_expression,
                 const symbolic::Expression& new_expression);

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

    std::unordered_set<const data_flow::Tasklet*> tasklets() const;

    std::unordered_set<const data_flow::AccessNode*> data_nodes() const;

    std::unordered_set<data_flow::AccessNode*> data_nodes();

    std::unordered_set<const data_flow::AccessNode*> reads() const;

    std::unordered_set<const data_flow::AccessNode*> writes() const;

    std::unordered_set<const data_flow::DataFlowNode*> sources() const;

    std::unordered_set<data_flow::DataFlowNode*> sources();

    std::unordered_set<const data_flow::DataFlowNode*> sinks() const;

    std::unordered_set<data_flow::DataFlowNode*> sinks();

    std::unordered_set<const data_flow::DataFlowNode*> predecessors(
        const data_flow::DataFlowNode& node) const;

    std::unordered_set<const data_flow::DataFlowNode*> successors(
        const data_flow::DataFlowNode& node) const;

    std::list<const data_flow::DataFlowNode*> topological_sort() const;

    std::list<data_flow::DataFlowNode*> topological_sort();

    std::unordered_map<std::string, const data_flow::AccessNode*> dominators() const;

    std::unordered_map<std::string, const data_flow::AccessNode*> post_dominators() const;

    std::unordered_map<std::string, data_flow::AccessNode*> post_dominators();

    auto all_simple_paths(const data_flow::DataFlowNode& src,
                          const data_flow::DataFlowNode& dst) const;

    const std::pair<size_t, const std::unordered_map<const data_flow::DataFlowNode*, size_t>>
    weakly_connected_components() const;

    /***** Section: Serialization *****/

    std::unique_ptr<DataFlowGraph> clone() const;
};

}  // namespace data_flow
}  // namespace sdfg

1	#pragma once
2
3	#include <boost/graph/graphviz.hpp>
4	#include <nlohmann/json.hpp>
5	#include <string>
6
7	#include "sdfg/data_flow/access_node.h"
8	#include "sdfg/data_flow/data_flow_node.h"
9	#include "sdfg/data_flow/library_node.h"
10	#include "sdfg/data_flow/memlet.h"
11	#include "sdfg/data_flow/tasklet.h"
12	#include "sdfg/graph/graph.h"
13	#include "sdfg/helpers/helpers.h"
14	#include "sdfg/symbolic/symbolic.h"
15
16	using json = nlohmann::json;
17
18	namespace sdfg {
19
20	namespace builder {
21	class SDFGBuilder;
22	class StructuredSDFGBuilder;
23	} // namespace builder
24
25	namespace data_flow {
26
27	class DataFlowGraph {
28	friend class sdfg::builder::SDFGBuilder;
29	friend class sdfg::builder::StructuredSDFGBuilder;
30
31	private:
32	// Remark: Exclusive resource
33	graph::Graph graph_;
34	std::unordered_map<graph::Vertex, std::unique_ptr<data_flow::DataFlowNode>,
35	boost::hash<graph::Vertex>>
36	nodes_;
37	std::unordered_map<graph::Edge, std::unique_ptr<data_flow::Memlet>, boost::hash<graph::Edge>>
38	edges_;
39
40	Element* parent_;
41
42	public:
43	DataFlowGraph() = default;
44	~DataFlowGraph() = default;
45
46	DataFlowGraph(const DataFlowGraph& graph) = delete;
47	DataFlowGraph& operator=(const DataFlowGraph&) = delete;
48
49	const Element* get_parent() const;
50
51	Element* get_parent();
52
UNCOV 53	auto nodes() const {	×
UNCOV 54	return std::views::values(this->nodes_) \|	×
UNCOV 55	std::views::transform(helpers::indirect<data_flow::DataFlowNode>) \|	×
UNCOV 56	std::views::transform(helpers::add_const<data_flow::DataFlowNode>);	×
57	};
58
59	auto nodes() {
60	return std::views::values(this->nodes_) \|
61	std::views::transform(helpers::indirect<data_flow::DataFlowNode>);
62	};
63
64	auto edges() const {
65	return std::views::values(this->edges_) \|
66	std::views::transform(helpers::indirect<data_flow::Memlet>) \|
67	std::views::transform(helpers::add_const<data_flow::Memlet>);
68	};
69
70	auto edges() {
71	return std::views::values(this->edges_) \|
72	std::views::transform(helpers::indirect<data_flow::Memlet>);
73	};
74
75	auto in_edges(const data_flow::DataFlowNode& node) const {	10✔
76	auto [eb, ee] = boost::in_edges(node.vertex(), this->graph_);	20✔
77	auto edges = std::ranges::subrange(eb, ee);	20✔
78
79	auto memlets =
80	std::views::transform(	10✔
81	edges,
82	[&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {	25✔
83	return *(lookup_table.find(edge)->second);	15✔
84	}) \|	10✔
85	std::views::transform(helpers::add_const<data_flow::Memlet>);	10✔
86
87	return memlets;	10✔
88	};
89
90	auto in_edges(const data_flow::DataFlowNode& node) {
91	auto [eb, ee] = boost::in_edges(node.vertex(), this->graph_);
92	auto edges = std::ranges::subrange(eb, ee);
93
94	auto memlets = std::views::transform(
95	edges, [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {
96	return *(lookup_table.find(edge)->second);
97	});
98
99	return memlets;
100	};
101
102	auto out_edges(const data_flow::DataFlowNode& node) const {	8✔
103	auto [eb, ee] = boost::out_edges(node.vertex(), this->graph_);	16✔
104	auto edges = std::ranges::subrange(eb, ee);	16✔
105
106	auto memlets =
107	std::views::transform(	8✔
108	edges,
109	[&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {	14✔
110	return *(lookup_table.find(edge)->second);	6✔
111	}) \|	8✔
112	std::views::transform(helpers::add_const<data_flow::Memlet>);	8✔
113
114	return memlets;	8✔
115	};	967✔
116		1,934✔
117	auto out_edges(const data_flow::DataFlowNode& node) {	1,934✔
118	auto [eb, ee] = boost::out_edges(node.vertex(), this->graph_);	967✔
119	auto edges = std::ranges::subrange(eb, ee);	1,758✔
120		791✔
121	auto memlets = std::views::transform(	967✔
122	edges, [&lookup_table = this->edges_](const graph::Edge& edge) -> data_flow::Memlet& {	1,786✔
123	return *(lookup_table.find(edge)->second);	3,572✔
124	});	3,572✔
125		1,786✔
126	return memlets;	3,133✔
127	};	1,347✔
128		1,786✔
129	size_t in_degree(const data_flow::DataFlowNode& node) const;	549✔
130		549✔
UNCOV 131	size_t out_degree(const data_flow::DataFlowNode& node) const;	×
UNCOV 132		×
UNCOV 133	void replace(const symbolic::Expression& old_expression,	×
UNCOV 134	const symbolic::Expression& new_expression);	×
UNCOV 135		×
UNCOV 136	/*** Section: Analysis ***/	×
UNCOV 137		×
UNCOV 138	std::unordered_set<const data_flow::Tasklet*> tasklets() const;	×
UNCOV 139		×
UNCOV 140	std::unordered_set<const data_flow::AccessNode*> data_nodes() const;	×
141
142	std::unordered_set<data_flow::AccessNode*> data_nodes();
143
144	std::unordered_set<const data_flow::AccessNode*> reads() const;
145
146	std::unordered_set<const data_flow::AccessNode*> writes() const;
147
148	std::unordered_set<const data_flow::DataFlowNode*> sources() const;
149
150	std::unordered_set<data_flow::DataFlowNode*> sources();
151
152	std::unordered_set<const data_flow::DataFlowNode*> sinks() const;
153
154	std::unordered_set<data_flow::DataFlowNode*> sinks();
155
156	std::unordered_set<const data_flow::DataFlowNode*> predecessors(
157	const data_flow::DataFlowNode& node) const;
158
159	std::unordered_set<const data_flow::DataFlowNode*> successors(
160	const data_flow::DataFlowNode& node) const;
161
162	std::list<const data_flow::DataFlowNode*> topological_sort() const;
163
164	std::list<data_flow::DataFlowNode*> topological_sort();
165
166	std::unordered_map<std::string, const data_flow::AccessNode*> dominators() const;
167
168	std::unordered_map<std::string, const data_flow::AccessNode*> post_dominators() const;
169
170	std::unordered_map<std::string, data_flow::AccessNode*> post_dominators();
171
172	auto all_simple_paths(const data_flow::DataFlowNode& src,
173	const data_flow::DataFlowNode& dst) const;
174
175	const std::pair<size_t, const std::unordered_map<const data_flow::DataFlowNode*, size_t>>
176	weakly_connected_components() const;
177
178	/*** Section: Serialization ***/
179
180	std::unique_ptr<DataFlowGraph> clone() const;
181	};
182
183	} // namespace data_flow
184	} // namespace sdfg

daisytuner / sdfglib / 15680526203

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