16439520920

Committed 22 Jul 2025 08:53AM UTC coverage: 65.927% (+0.8%) from 65.094%

Build # 16439520920

Build Type

Pull #153

github

Committed by

web-flow

Commit Message

Merge a0eea6968 into abe57c083

Pull Request Pull Request #153: Restricts memlets to contiguous memory

Run Details

211 of 300 new or added lines in 29 files covered. (70.33%)

66 existing lines in 7 files now uncovered.

8314 of 12611 relevant lines covered (65.93%)

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

daisytuner / sdfglib / 16439520920

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