26556322966

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

Build # 26556322966

Build Type

push

github

Committed by

web-flow

Commit Message

Libnode ptr edges (#719)

Migrating SDFGs to treat pointers as inputs to libNodes / Calls as scalars.
A pointer will only appear in an output edge if its actually returned from the function (like malloc).

* Stdlib, Blas and Tensor Matmul nodes were migrated to this new format. Other, currently transitory Tensor Nodes are not yet migrated.
* DOCC version was bumped to incorporate previous docc-llvm versions (up to 0.4.0) that had been counted separately.
! Until all passes consider the use / leak of pointers as uncertainty / hiding potential writes, TensorNodes are declared as general side-effect.
* Lots of utility functions to centralize the creation (and edges) of various libNodes that needed to be changed.
* Fixed & unified docc paths across python and llvm front-ends.
* Skip BlockFusion test that fails to its libNodes currently having side effects
~ Prevent a crash in DotViz when using symbolic offsets into structs
* Removing old ConstProp pass, it is not safe for the new pointer representation and should not be all too critical

Coverage Stats

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

87 existing lines in 28 files now uncovered.

35225 of 57870 relevant lines covered (60.87%)

11046.32 hits per line

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

39.02

/sdfg/src/data_flow/library_nodes/stdlib/memset.cpp

#include "sdfg/data_flow/library_nodes/stdlib/memset.h"

namespace sdfg {
namespace stdlib {

MemsetNode::MemsetNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    data_flow::DataFlowGraph& parent,
    const symbolic::Expression value,
    const symbolic::Expression num
)
    : StdlibNode(
          element_id,
          debug_info,
          vertex,
          parent,
          LibraryNodeType_Memset,
          {},
          {"_ptr"},
          true,
          data_flow::ImplementationType_NONE
      ),
      num_(num), value_(value) {}

const symbolic::Expression MemsetNode::value() const { return value_; }

const symbolic::Expression MemsetNode::num() const { return num_; }

void MemsetNode::validate(const Function& function) const { LibraryNode::validate(function); }

symbolic::SymbolSet MemsetNode::symbols() const {
    auto value_symbols = symbolic::atoms(this->value_);
    auto num_symbols = symbolic::atoms(this->num_);
    num_symbols.insert(value_symbols.begin(), value_symbols.end());
    return num_symbols;
}

std::unique_ptr<data_flow::DataFlowNode> MemsetNode::
    clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {
    return std::make_unique<MemsetNode>(element_id, debug_info_, vertex, parent, value_, num_);
}

data_flow::PointerAccessType MemsetNode::pointer_access_type(int input_idx) const {
    if (input_idx == 0) {
        return data_flow::PointerAccessMeta::create_full_write_only(num_, true);
    } else {
        return StdlibNode::pointer_access_type(input_idx);
    }
}

std::string MemsetNode::toStr() const {
    return StdlibNode::toStr() + "(n: " + num_->__str__() + ", v: " + value_->__str__() + ")";
}

void MemsetNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    this->value_ = symbolic::subs(this->value_, old_expression, new_expression);
    this->num_ = symbolic::subs(this->num_, old_expression, new_expression);
}

nlohmann::json MemsetNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {
    const MemsetNode& node = static_cast<const MemsetNode&>(library_node);

    nlohmann::json j;
    j["code"] = node.code().value();

    sdfg::serializer::JSONSerializer serializer;
    j["value"] = serializer.expression(node.value());
    j["num"] = serializer.expression(node.num());

    return j;
}

data_flow::LibraryNode& MemsetNodeSerializer::deserialize(
    const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
) {
    assert(j.contains("code"));
    assert(j.contains("debug_info"));
    assert(j.contains("value"));
    assert(j.contains("num"));

    auto code = j["code"].get<std::string>();
    if (code != LibraryNodeType_Memset.value()) {
        throw InvalidSDFGException("Invalid library node code");
    }

    // Extract debug info using JSONSerializer
    sdfg::serializer::JSONSerializer serializer;
    DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);

    // Extract properties
    auto value = symbolic::parse(j.at("value"));
    auto num = symbolic::parse(j.at("num"));

    return builder.add_library_node<MemsetNode>(parent, debug_info, value, num);
}

MemsetNodeDispatcher::MemsetNodeDispatcher(
    codegen::LanguageExtension& language_extension,
    const Function& function,
    const data_flow::DataFlowGraph& data_flow_graph,
    const MemsetNode& node
)
    : codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}

void MemsetNodeDispatcher::dispatch_code_with_edges(
    codegen::CodegenOutput& out,
    std::vector<codegen::DispatchInput>& inputs,
    std::vector<codegen::DispatchOutput>& outputs
) {
    auto& node = static_cast<const MemsetNode&>(node_);

    out.stream << language_extension_.external_prefix() << "memset(" << inputs.at(0).expr << ", "
               << language_extension_.expression(node.value()) << ", " << language_extension_.expression(node.num())
               << ")"
               << ";";
    out.stream << std::endl;
}

MemsetNode& add_memset_node(
    builder::StructuredSDFGBuilder& builder,
    Block& block,
    const std::string& dst_ptr,
    const symbolic::Expression& value,
    const symbolic::Expression& num,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& dst_ptr_access = builder.add_access(block, dst_ptr);
    auto& libnode = builder.add_library_node<stdlib::MemsetNode>(block, debug_info, value, num);
    builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);

    return static_cast<MemsetNode&>(libnode);
}

std::tuple<Block&, MemsetNode&> add_memset_block(
    builder::StructuredSDFGBuilder& builder,
    Sequence& parent,
    const std::string& dst_ptr,
    const symbolic::Expression& value,
    const symbolic::Expression& num,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& block = builder.add_block(parent);

    auto& libnode = add_memset_node(builder, block, dst_ptr, value, num, ptr_type, debug_info);

    return {block, libnode};
}

} // namespace stdlib
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/stdlib/memset.h"
2
3	namespace sdfg {
4	namespace stdlib {
5
6	MemsetNode::MemsetNode(
7	size_t element_id,
8	const DebugInfo& debug_info,
9	const graph::Vertex vertex,
10	data_flow::DataFlowGraph& parent,
11	const symbolic::Expression value,
12	const symbolic::Expression num
13	)
14	: StdlibNode(	22✔
15	element_id,	22✔
16	debug_info,	22✔
17	vertex,	22✔
18	parent,	22✔
19	LibraryNodeType_Memset,	22✔
20	{},	22✔
21	{"_ptr"},	22✔
22	true,	22✔
23	data_flow::ImplementationType_NONE	22✔
24	),	22✔
25	num_(num), value_(value) {}	22✔
26
27	const symbolic::Expression MemsetNode::value() const { return value_; }	2✔
28
29	const symbolic::Expression MemsetNode::num() const { return num_; }	6✔
30
31	void MemsetNode::validate(const Function& function) const { LibraryNode::validate(function); }	11✔
32
33	symbolic::SymbolSet MemsetNode::symbols() const {	1✔
34	auto value_symbols = symbolic::atoms(this->value_);	1✔
35	auto num_symbols = symbolic::atoms(this->num_);	1✔
36	num_symbols.insert(value_symbols.begin(), value_symbols.end());	1✔
37	return num_symbols;	1✔
38	}	1✔
39
40	std::unique_ptr<data_flow::DataFlowNode> MemsetNode::
41	clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {	×
42	return std::make_unique<MemsetNode>(element_id, debug_info_, vertex, parent, value_, num_);	×
43	}	×
44
NEW 45	data_flow::PointerAccessType MemsetNode::pointer_access_type(int input_idx) const {	×
NEW 46	if (input_idx == 0) {	×
NEW 47	return data_flow::PointerAccessMeta::create_full_write_only(num_, true);	×
NEW 48	} else {	×
NEW 49	return StdlibNode::pointer_access_type(input_idx);	×
NEW 50	}	×
NEW 51	}	×
52
NEW 53	std::string MemsetNode::toStr() const {	×
NEW 54	return StdlibNode::toStr() + "(n: " + num_->__str__() + ", v: " + value_->__str__() + ")";	×
NEW 55	}	×
56
57	void MemsetNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
58	this->value_ = symbolic::subs(this->value_, old_expression, new_expression);	×
59	this->num_ = symbolic::subs(this->num_, old_expression, new_expression);	×
60	}	×
61
62	nlohmann::json MemsetNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
63	const MemsetNode& node = static_cast<const MemsetNode&>(library_node);	×
64
65	nlohmann::json j;	×
66	j["code"] = node.code().value();	×
67
68	sdfg::serializer::JSONSerializer serializer;	×
69	j["value"] = serializer.expression(node.value());	×
70	j["num"] = serializer.expression(node.num());	×
71
72	return j;	×
73	}	×
74
75	data_flow::LibraryNode& MemsetNodeSerializer::deserialize(
76	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
77	) {	×
78	assert(j.contains("code"));	×
79	assert(j.contains("debug_info"));	×
80	assert(j.contains("value"));	×
81	assert(j.contains("num"));	×
82
83	auto code = j["code"].get<std::string>();	×
84	if (code != LibraryNodeType_Memset.value()) {	×
85	throw InvalidSDFGException("Invalid library node code");	×
86	}	×
87
88	// Extract debug info using JSONSerializer
89	sdfg::serializer::JSONSerializer serializer;	×
90	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
91
92	// Extract properties
93	auto value = symbolic::parse(j.at("value"));	×
94	auto num = symbolic::parse(j.at("num"));	×
95
96	return builder.add_library_node<MemsetNode>(parent, debug_info, value, num);	×
97	}	×
98
99	MemsetNodeDispatcher::MemsetNodeDispatcher(
100	codegen::LanguageExtension& language_extension,
101	const Function& function,
102	const data_flow::DataFlowGraph& data_flow_graph,
103	const MemsetNode& node
104	)
105	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
106
107	void MemsetNodeDispatcher::dispatch_code_with_edges(
108	codegen::CodegenOutput& out,
109	std::vector<codegen::DispatchInput>& inputs,
110	std::vector<codegen::DispatchOutput>& outputs
111	) {	×
112	auto& node = static_cast<const MemsetNode&>(node_);	×
113
NEW 114	out.stream << language_extension_.external_prefix() << "memset(" << inputs.at(0).expr << ", "	×
NEW 115	<< language_extension_.expression(node.value()) << ", " << language_extension_.expression(node.num())	×
NEW 116	<< ")"	×
NEW 117	<< ";";	×
NEW 118	out.stream << std::endl;	×
NEW 119	}	×
120
121	MemsetNode& add_memset_node(
122	builder::StructuredSDFGBuilder& builder,
123	Block& block,
124	const std::string& dst_ptr,
125	const symbolic::Expression& value,
126	const symbolic::Expression& num,
127	const types::IType& ptr_type,
128	DebugInfo debug_info
129	) {	22✔
130	auto& dst_ptr_access = builder.add_access(block, dst_ptr);	22✔
131	auto& libnode = builder.add_library_node<stdlib::MemsetNode>(block, debug_info, value, num);	22✔
132	builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);	22✔
133
134	return static_cast<MemsetNode&>(libnode);	22✔
135	}	22✔
136
137	std::tuple<Block&, MemsetNode&> add_memset_block(
138	builder::StructuredSDFGBuilder& builder,
139	Sequence& parent,
140	const std::string& dst_ptr,
141	const symbolic::Expression& value,
142	const symbolic::Expression& num,
143	const types::IType& ptr_type,
144	DebugInfo debug_info
145	) {	22✔
146	auto& block = builder.add_block(parent);	22✔
147
148	auto& libnode = add_memset_node(builder, block, dst_ptr, value, num, ptr_type, debug_info);	22✔
149
150	return {block, libnode};	22✔
151	}	22✔
152
153	} // namespace stdlib
154	} // namespace sdfg

daisytuner / docc / 26556322966

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