20896124135

Committed 11 Jan 2026 01:43PM UTC coverage: 62.33% (-0.07%) from 62.402%

Build # 20896124135

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #423 from daisytuner/copilot/extend-tensor-nodes-conv

Add ConvNode compatible with ONNX Conv operator with n-dimensional expansion and custom validation

Run Details

329 of 554 new or added lines in 21 files covered. (59.39%)

2 existing lines in 2 files now uncovered.

15413 of 24728 relevant lines covered (62.33%)

88.61 hits per line

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

0.0

/src/data_flow/library_nodes/metadata_node.cpp

#include "sdfg/data_flow/library_nodes/metadata_node.h"

namespace sdfg {
namespace data_flow {

MetadataNode::MetadataNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    DataFlowGraph& parent,
    const std::vector<std::string>& outputs,
    const std::vector<std::string>& inputs,
    std::unordered_map<std::string, std::string> metadata
)
    : LibraryNode(
          element_id, debug_info, vertex, parent, LibraryNodeType_Metadata, outputs, inputs, false, ImplementationType_NONE
      ),
      metadata_(metadata) {}

void MetadataNode::validate(const Function& function) const {
    LibraryNode::validate(function);
    // No specific validation for metadata
}

const std::unordered_map<std::string, std::string>& MetadataNode::metadata() const { return metadata_; }

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

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

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

nlohmann::json MetadataNodeSerializer::serialize(const LibraryNode& library_node) {
    const MetadataNode& metadata_node = static_cast<const MetadataNode&>(library_node);
    nlohmann::json j;

    j["code"] = metadata_node.code().value();
    j["outputs"] = metadata_node.outputs();
    j["inputs"] = metadata_node.inputs();
    j["side_effect"] = metadata_node.side_effect();
    j["metadata"] = metadata_node.metadata();

    return j;
}

LibraryNode& MetadataNodeSerializer::deserialize(
    const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
) {
    // Assertions for required fields
    assert(j.contains("element_id"));
    assert(j.contains("code"));
    assert(j.contains("outputs"));
    assert(j.contains("inputs"));
    assert(j.contains("debug_info"));
    assert(j.contains("metadata"));

    auto code = j["code"].get<std::string>();
    if (code != LibraryNodeType_Metadata.value()) {
        throw std::runtime_error("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 outputs = j.at("outputs").get<std::vector<std::string>>();
    auto inputs = j.at("inputs").get<std::vector<std::string>>();
    auto metadata = j.at("metadata").get<std::unordered_map<std::string, std::string>>();

    return builder.add_library_node<MetadataNode>(parent, debug_info, outputs, inputs, metadata);
}

MetadataDispatcher::MetadataDispatcher(
    codegen::LanguageExtension& language_extension,
    const Function& function,
    const DataFlowGraph& data_flow_graph,
    const MetadataNode& node
)
    : codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}

void MetadataDispatcher::dispatch(
    codegen::PrettyPrinter& stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::CodeSnippetFactory& library_snippet_factory
) {
    throw std::runtime_error("MetadataNode is not supported");
}

} // namespace data_flow
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/metadata_node.h"
2
3	namespace sdfg {
4	namespace data_flow {
5
6	MetadataNode::MetadataNode(
7	size_t element_id,
8	const DebugInfo& debug_info,
9	const graph::Vertex vertex,
10	DataFlowGraph& parent,
11	const std::vector<std::string>& outputs,
12	const std::vector<std::string>& inputs,
13	std::unordered_map<std::string, std::string> metadata
14	)
15	: LibraryNode(	×
16	element_id, debug_info, vertex, parent, LibraryNodeType_Metadata, outputs, inputs, false, ImplementationType_NONE	×
17	),	×
18	metadata_(metadata) {}	×
19
20	void MetadataNode::validate(const Function& function) const {	×
NEW 21	LibraryNode::validate(function);	×
22	// No specific validation for metadata
UNCOV 23	}	×
24
25	const std::unordered_map<std::string, std::string>& MetadataNode::metadata() const { return metadata_; }	×
26
27	symbolic::SymbolSet MetadataNode::symbols() const { return symbolic::SymbolSet(); }	×
28
29	std::unique_ptr<DataFlowNode> MetadataNode::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
30	const {	×
31	return std::make_unique<MetadataNode>(element_id, debug_info_, vertex, parent, outputs_, inputs_, metadata_);	×
32	}	×
33
34	void MetadataNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
35	// Do nothing
36	return;	×
37	}	×
38
39	nlohmann::json MetadataNodeSerializer::serialize(const LibraryNode& library_node) {	×
40	const MetadataNode& metadata_node = static_cast<const MetadataNode&>(library_node);	×
41	nlohmann::json j;	×
42
43	j["code"] = metadata_node.code().value();	×
44	j["outputs"] = metadata_node.outputs();	×
45	j["inputs"] = metadata_node.inputs();	×
46	j["side_effect"] = metadata_node.side_effect();	×
47	j["metadata"] = metadata_node.metadata();	×
48
49	return j;	×
50	}	×
51
52	LibraryNode& MetadataNodeSerializer::deserialize(
53	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
54	) {	×
55	// Assertions for required fields
56	assert(j.contains("element_id"));	×
57	assert(j.contains("code"));	×
58	assert(j.contains("outputs"));	×
59	assert(j.contains("inputs"));	×
60	assert(j.contains("debug_info"));	×
61	assert(j.contains("metadata"));	×
62
63	auto code = j["code"].get<std::string>();	×
64	if (code != LibraryNodeType_Metadata.value()) {	×
65	throw std::runtime_error("Invalid library node code");	×
66	}	×
67
68	// Extract debug info using JSONSerializer
69	sdfg::serializer::JSONSerializer serializer;	×
70	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
71
72	// Extract properties
73	auto outputs = j.at("outputs").get<std::vector<std::string>>();	×
74	auto inputs = j.at("inputs").get<std::vector<std::string>>();	×
75	auto metadata = j.at("metadata").get<std::unordered_map<std::string, std::string>>();	×
76
77	return builder.add_library_node<MetadataNode>(parent, debug_info, outputs, inputs, metadata);	×
78	}	×
79
80	MetadataDispatcher::MetadataDispatcher(
81	codegen::LanguageExtension& language_extension,
82	const Function& function,
83	const DataFlowGraph& data_flow_graph,
84	const MetadataNode& node
85	)
86	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
87
88	void MetadataDispatcher::dispatch(
89	codegen::PrettyPrinter& stream,
90	codegen::PrettyPrinter& globals_stream,
91	codegen::CodeSnippetFactory& library_snippet_factory
92	) {	×
93	throw std::runtime_error("MetadataNode is not supported");	×
94	}	×
95
96	} // namespace data_flow
97	} // namespace sdfg

daisytuner / sdfglib / 20896124135

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