16779684622

Committed 06 Aug 2025 02:21PM UTC coverage: 64.3% (-1.0%) from 65.266%

Build # 16779684622

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #172 from daisytuner/opaque-pointers

Opaque pointers, typed memlets, untyped tasklet connectors

Run Details

330 of 462 new or added lines in 38 files covered. (71.43%)

382 existing lines in 30 files now uncovered.

8865 of 13787 relevant lines covered (64.3%)

116.73 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 {
    // TODO: Implement
}

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

daisytuner / sdfglib / 16779684622

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