26520678771

Committed 27 May 2026 03:22PM UTC coverage: 60.864% (-0.02%) from 60.886%

Build # 26520678771

Build Type

Pull #719

github

Committed by

web-flow

Commit Message

Merge 99c5e4f9d into 707dadcf8

Pull Request Pull Request #719: Libnode ptr edges

Coverage Stats

961 of 1749 new or added lines in 52 files covered. (54.95%)

90 existing lines in 29 files now uncovered.

35222 of 57870 relevant lines covered (60.86%)

11043.61 hits per line

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

82.46

/sdfg/src/data_flow/access_node.cpp

#include "sdfg/data_flow/access_node.h"

#include <unordered_set>
#include "sdfg/data_flow/data_flow_graph.h"
#include "sdfg/function.h"

namespace sdfg {
namespace data_flow {

AccessNode::AccessNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    DataFlowGraph& parent,
    const std::string& data
)
    : DataFlowNode(element_id, debug_info, vertex, parent), data_(data) {

      };

void AccessNode::validate(const Function& function) const {
    if (!function.exists(this->data_)) {
        throw InvalidSDFGException("Access node " + this->data_ + " uses non-existent variable");
    }

    auto& graph = this->get_parent();

    if (graph.out_degree(*this) > 1) {
        MemletType type = (*graph.out_edges(*this).begin()).type();
        for (auto& oedge : graph.out_edges(*this)) {
            if (oedge.type() != type) {
                throw InvalidSDFGException("Access node " + this->data() + " used with multiple memlet types");
            }
        }
    }

    if (graph.in_degree(*this) > 1) {
        MemletType type = (*graph.in_edges(*this).begin()).type();
        for (auto& iedge : graph.in_edges(*this)) {
            if (iedge.type() != type) {
                throw InvalidSDFGException("Access node " + this->data() + " used with multiple memlet types");
            }
        }
    }
}

const std::string& AccessNode::data() const { return this->data_; };

void AccessNode::data(const std::string data) { this->data_ = data; }

bool AccessNode::side_effect() const { return get_parent().in_degree(*this) > 0; }

std::unique_ptr<DataFlowNode> AccessNode::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
    const {
    return std::unique_ptr<AccessNode>(new AccessNode(element_id, this->debug_info_, vertex, parent, this->data_));
};

void AccessNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    if (SymEngine::is_a<SymEngine::Symbol>(*old_expression) && SymEngine::is_a<SymEngine::Symbol>(*new_expression)) {
        auto old_symbol = SymEngine::rcp_static_cast<const SymEngine::Symbol>(old_expression);
        if (this->data_ == old_symbol->get_name()) {
            auto new_symbol = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
            this->data_ = new_symbol->get_name();
        }
    }
}

/**
 * Every read can be removed
 */
EdgeRemoveOption AccessNode::can_remove_out_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const {
    return EdgeRemoveOption::Trivially;
}

EdgeRemoveOption AccessNode::can_remove_in_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const {
    return (graph.out_degree(*this) == 0) ? EdgeRemoveOption::RemoveNodeAfter : EdgeRemoveOption::Trivially;
}

bool AccessNode::identicalBackingData(const AccessNode& src1, const AccessNode& src2) {
    return src1.data() == src2.data();
}

namespace {
bool is_special_constant(const std::string& data) {
    static const std::unordered_set<std::string> constants = {
        "true",
        "false",
        "INT8_MIN",
        "INT8_MAX",
        "UINT8_MAX",
        "INT16_MIN",
        "INT16_MAX",
        "UINT16_MAX",
        "INT32_MIN",
        "INT32_MAX",
        "UINT32_MAX",
        "INT64_MIN",
        "INT64_MAX",
        "UINT64_MAX",
    };
    return constants.find(data) != constants.end();
}
} // namespace

ConstantNode::ConstantNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    DataFlowGraph& parent,
    const std::string& data,
    const types::IType& type
)
    : AccessNode(element_id, debug_info, vertex, parent, data), type_(type.clone()) {};

void ConstantNode::validate(const Function& function) const {
    if (function.exists(this->data_)) {
        throw InvalidSDFGException("ConstantNode " + this->data_ + " uses variable");
    }

    auto& graph = this->get_parent();
    if (graph.in_degree(*this) > 0) {
        throw InvalidSDFGException("ConstantNode " + this->data_ + " has incoming edges");
    }

    switch (this->type_->type_id()) {
        case types::TypeID::Scalar: {
            auto& scalar_type = static_cast<const types::Scalar&>(*this->type_);
            switch (scalar_type.primitive_type()) {
                case types::PrimitiveType::Bool:
                case types::PrimitiveType::Int8:
                case types::PrimitiveType::Int16:
                case types::PrimitiveType::Int32:
                case types::PrimitiveType::Int64:
                case types::PrimitiveType::UInt8:
                case types::PrimitiveType::UInt16:
                case types::PrimitiveType::UInt32:
                case types::PrimitiveType::UInt64: {
                    auto data = this->data();
                    if (is_special_constant(data)) {
                        break;
                    }

                    try {
                        helpers::parse_number_signed(data);
                    } catch (const std::exception& e) {
                        throw InvalidSDFGException("ConstantNode " + data + " has non-integer scalar type");
                    }
                    break;
                }
                default:
                    break;
            }
            break;
        }
        default:
            break;
    }
}

const types::IType& ConstantNode::type() const { return *this->type_; };

std::unique_ptr<DataFlowNode> ConstantNode::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
    const {
    return std::unique_ptr<
        ConstantNode>(new ConstantNode(element_id, this->debug_info_, vertex, parent, this->data(), *this->type_));
};

} // namespace data_flow
} // namespace sdfg

1	#include "sdfg/data_flow/access_node.h"
2
3	#include <unordered_set>
4	#include "sdfg/data_flow/data_flow_graph.h"
5	#include "sdfg/function.h"
6
7	namespace sdfg {
8	namespace data_flow {
9
10	AccessNode::AccessNode(
11	size_t element_id,
12	const DebugInfo& debug_info,
13	const graph::Vertex vertex,
14	DataFlowGraph& parent,
15	const std::string& data
16	)
17	: DataFlowNode(element_id, debug_info, vertex, parent), data_(data) {	7,196✔
18
19	};	7,196✔
20
21	void AccessNode::validate(const Function& function) const {	11,368✔
22	if (!function.exists(this->data_)) {	11,368✔
23	throw InvalidSDFGException("Access node " + this->data_ + " uses non-existent variable");	×
24	}	×
25
26	auto& graph = this->get_parent();	11,368✔
27
28	if (graph.out_degree(*this) > 1) {	11,368✔
29	MemletType type = (graph.out_edges(this).begin()).type();	283✔
30	for (auto& oedge : graph.out_edges(*this)) {	567✔
31	if (oedge.type() != type) {	567✔
32	throw InvalidSDFGException("Access node " + this->data() + " used with multiple memlet types");	×
33	}	×
34	}	567✔
35	}	283✔
36
37	if (graph.in_degree(*this) > 1) {	11,368✔
38	MemletType type = (graph.in_edges(this).begin()).type();	5✔
39	for (auto& iedge : graph.in_edges(*this)) {	10✔
40	if (iedge.type() != type) {	10✔
41	throw InvalidSDFGException("Access node " + this->data() + " used with multiple memlet types");	×
42	}	×
43	}	10✔
44	}	5✔
45	}	11,368✔
46
47	const std::string& AccessNode::data() const { return this->data_; };	34,070✔
48
49	void AccessNode::data(const std::string data) { this->data_ = data; }	144✔
50
51	bool AccessNode::side_effect() const { return get_parent().in_degree(*this) > 0; }	17✔
52
53	std::unique_ptr<DataFlowNode> AccessNode::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
54	const {	50✔
55	return std::unique_ptr<AccessNode>(new AccessNode(element_id, this->debug_info_, vertex, parent, this->data_));	50✔
56	};	50✔
57
58	void AccessNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	566✔
59	if (SymEngine::is_a<SymEngine::Symbol>(old_expression) && SymEngine::is_a<SymEngine::Symbol>(new_expression)) {	566✔
60	auto old_symbol = SymEngine::rcp_static_cast<const SymEngine::Symbol>(old_expression);	429✔
61	if (this->data_ == old_symbol->get_name()) {	429✔
62	auto new_symbol = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	29✔
63	this->data_ = new_symbol->get_name();	29✔
64	}	29✔
65	}	429✔
66	}	566✔
67
68	/**
69	* Every read can be removed
70	*/
71	EdgeRemoveOption AccessNode::can_remove_out_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const {	16✔
72	return EdgeRemoveOption::Trivially;	16✔
73	}	16✔
74
NEW 75	EdgeRemoveOption AccessNode::can_remove_in_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const {	×
NEW 76	return (graph.out_degree(*this) == 0) ? EdgeRemoveOption::RemoveNodeAfter : EdgeRemoveOption::Trivially;	×
NEW 77	}	×
78
79	bool AccessNode::identicalBackingData(const AccessNode& src1, const AccessNode& src2) {	34✔
80	return src1.data() == src2.data();	34✔
81	}	34✔
82
83	namespace {
84	bool is_special_constant(const std::string& data) {	71✔
85	static const std::unordered_set<std::string> constants = {	71✔
86	"true",	71✔
87	"false",	71✔
88	"INT8_MIN",	71✔
89	"INT8_MAX",	71✔
90	"UINT8_MAX",	71✔
91	"INT16_MIN",	71✔
92	"INT16_MAX",	71✔
93	"UINT16_MAX",	71✔
94	"INT32_MIN",	71✔
95	"INT32_MAX",	71✔
96	"UINT32_MAX",	71✔
97	"INT64_MIN",	71✔
98	"INT64_MAX",	71✔
99	"UINT64_MAX",	71✔
100	};	71✔
101	return constants.find(data) != constants.end();	71✔
102	}	71✔
103	} // namespace
104
105	ConstantNode::ConstantNode(
106	size_t element_id,
107	const DebugInfo& debug_info,
108	const graph::Vertex vertex,
109	DataFlowGraph& parent,
110	const std::string& data,
111	const types::IType& type
112	)
113	: AccessNode(element_id, debug_info, vertex, parent, data), type_(type.clone()) {};	404✔
114
115	void ConstantNode::validate(const Function& function) const {	655✔
116	if (function.exists(this->data_)) {	655✔
117	throw InvalidSDFGException("ConstantNode " + this->data_ + " uses variable");	×
118	}	×
119
120	auto& graph = this->get_parent();	655✔
121	if (graph.in_degree(*this) > 0) {	655✔
122	throw InvalidSDFGException("ConstantNode " + this->data_ + " has incoming edges");	×
123	}	×
124
125	switch (this->type_->type_id()) {	655✔
126	case types::TypeID::Scalar: {	613✔
127	auto& scalar_type = static_cast<const types::Scalar&>(*this->type_);	613✔
128	switch (scalar_type.primitive_type()) {	613✔
129	case types::PrimitiveType::Bool:	×
130	case types::PrimitiveType::Int8:	×
131	case types::PrimitiveType::Int16:	×
132	case types::PrimitiveType::Int32:	46✔
133	case types::PrimitiveType::Int64:	49✔
134	case types::PrimitiveType::UInt8:	49✔
135	case types::PrimitiveType::UInt16:	49✔
136	case types::PrimitiveType::UInt32:	63✔
137	case types::PrimitiveType::UInt64: {	71✔
138	auto data = this->data();	71✔
139	if (is_special_constant(data)) {	71✔
140	break;	×
141	}	×
142
143	try {	71✔
144	helpers::parse_number_signed(data);	71✔
145	} catch (const std::exception& e) {	71✔
146	throw InvalidSDFGException("ConstantNode " + data + " has non-integer scalar type");	×
147	}	×
148	break;	71✔
149	}	71✔
150	default:	542✔
151	break;	542✔
152	}	613✔
153	break;	613✔
154	}	613✔
155	default:	613✔
156	break;	42✔
157	}	655✔
158	}	655✔
159
160	const types::IType& ConstantNode::type() const { return *this->type_; };	292✔
161
162	std::unique_ptr<DataFlowNode> ConstantNode::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
163	const {	6✔
164	return std::unique_ptr<	6✔
165	ConstantNode>(new ConstantNode(element_id, this->debug_info_, vertex, parent, this->data(), *this->type_));	6✔
166	};	6✔
167
168	} // namespace data_flow
169	} // namespace sdfg

daisytuner / docc / 26520678771

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