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

50.0

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

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

namespace sdfg {
namespace stdlib {

FreeNode::FreeNode(
    size_t element_id, const DebugInfo& debug_info, const graph::Vertex vertex, data_flow::DataFlowGraph& parent
)
    : StdlibNode(
          element_id,
          debug_info,
          vertex,
          parent,
          LibraryNodeType_Free,
          {},
          {"_ptr"},
          true,
          data_flow::ImplementationType_NONE
      ) {}


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

symbolic::SymbolSet FreeNode::symbols() const { return {}; }

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

void FreeNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    // Do nothing
    return;
}

data_flow::PointerAccessType FreeNode::pointer_access_type(int input_idx) const {
    if (input_idx == 0) {
        return data_flow::PointerAccessMeta::create_invalidate();
    } else {
        return LibraryNode::pointer_access_type(input_idx);
    }
}

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

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

    return j;
}

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

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

    sdfg::serializer::JSONSerializer serializer;
    DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);

    return builder.add_library_node<FreeNode>(parent, debug_info);
}

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

void FreeNodeDispatcher::dispatch_code_with_edges(
    codegen::CodegenOutput& out,
    std::vector<codegen::DispatchInput>& inputs,
    std::vector<codegen::DispatchOutput>& outputs
) {
    out.stream << out.language_extension.external_prefix() << "free(" << inputs.at(0).expr << ");" << std::endl;
}

FreeNode& add_free_node(
    builder::StructuredSDFGBuilder& builder,
    Block& block,
    const std::string& ptr,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& dst_ptr_access = builder.add_access(block, ptr);
    auto& libnode = builder.add_library_node<stdlib::FreeNode>(block, debug_info);
    builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);

    return static_cast<FreeNode&>(libnode);
}

std::tuple<Block&, FreeNode&> add_free_block(
    builder::StructuredSDFGBuilder& builder,
    Sequence& parent,
    const std::string& ptr,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& block = builder.add_block(parent);

    auto& libnode = add_free_node(builder, block, ptr, ptr_type, debug_info);

    return {block, libnode};
}

} // namespace stdlib
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/stdlib/free.h"
2
3	namespace sdfg {
4	namespace stdlib {
5
6	FreeNode::FreeNode(
7	size_t element_id, const DebugInfo& debug_info, const graph::Vertex vertex, data_flow::DataFlowGraph& parent
8	)
9	: StdlibNode(	56✔
10	element_id,	56✔
11	debug_info,	56✔
12	vertex,	56✔
13	parent,	56✔
14	LibraryNodeType_Free,	56✔
15	{},	56✔
16	{"_ptr"},	56✔
17	true,	56✔
18	data_flow::ImplementationType_NONE	56✔
19	) {}	56✔
20
21
22	void FreeNode::validate(const Function& function) const { LibraryNode::validate(function); }	139✔
23
24	symbolic::SymbolSet FreeNode::symbols() const { return {}; }	60✔
25
26	std::unique_ptr<data_flow::DataFlowNode> FreeNode::
27	clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {	×
28	return std::make_unique<FreeNode>(element_id, debug_info_, vertex, parent);	×
29	}	×
30
31	void FreeNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
32	// Do nothing
33	return;	×
34	}	×
35
36	data_flow::PointerAccessType FreeNode::pointer_access_type(int input_idx) const {	3✔
37	if (input_idx == 0) {	3✔
38	return data_flow::PointerAccessMeta::create_invalidate();	3✔
39	} else {	3✔
NEW 40	return LibraryNode::pointer_access_type(input_idx);	×
NEW 41	}	×
42	}	3✔
43
44	nlohmann::json FreeNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
45	const FreeNode& node = static_cast<const FreeNode&>(library_node);	×
46
47	nlohmann::json j;	×
48	j["code"] = node.code().value();	×
49
50	return j;	×
51	}	×
52
53	data_flow::LibraryNode& FreeNodeSerializer::deserialize(
54	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
55	) {	×
56	assert(j.contains("code"));	×
57	assert(j.contains("debug_info"));	×
58
59	auto code = j["code"].get<std::string>();	×
60	if (code != LibraryNodeType_Free.value()) {	×
61	throw InvalidSDFGException("Invalid library node code");	×
62	}	×
63
64	sdfg::serializer::JSONSerializer serializer;	×
65	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
66
67	return builder.add_library_node<FreeNode>(parent, debug_info);	×
68	}	×
69
70	FreeNodeDispatcher::FreeNodeDispatcher(
71	codegen::LanguageExtension& language_extension,
72	const Function& function,
73	const data_flow::DataFlowGraph& data_flow_graph,
74	const FreeNode& node
75	)
76	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
77
78	void FreeNodeDispatcher::dispatch_code_with_edges(
79	codegen::CodegenOutput& out,
80	std::vector<codegen::DispatchInput>& inputs,
81	std::vector<codegen::DispatchOutput>& outputs
NEW 82	) {	×
NEW 83	out.stream << out.language_extension.external_prefix() << "free(" << inputs.at(0).expr << ");" << std::endl;	×
NEW 84	}	×
85
86	FreeNode& add_free_node(
87	builder::StructuredSDFGBuilder& builder,
88	Block& block,
89	const std::string& ptr,
90	const types::IType& ptr_type,
91	DebugInfo debug_info
92	) {	2✔
93	auto& dst_ptr_access = builder.add_access(block, ptr);	2✔
94	auto& libnode = builder.add_library_node<stdlib::FreeNode>(block, debug_info);	2✔
95	builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);	2✔
96
97	return static_cast<FreeNode&>(libnode);	2✔
98	}	2✔
99
100	std::tuple<Block&, FreeNode&> add_free_block(
101	builder::StructuredSDFGBuilder& builder,
102	Sequence& parent,
103	const std::string& ptr,
104	const types::IType& ptr_type,
105	DebugInfo debug_info
106	) {	2✔
107	auto& block = builder.add_block(parent);	2✔
108
109	auto& libnode = add_free_node(builder, block, ptr, ptr_type, debug_info);	2✔
110
111	return {block, libnode};	2✔
112	}	2✔
113
114	} // namespace stdlib
115	} // 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