20606101998

Committed 30 Dec 2025 09:15PM UTC coverage: 39.289% (+0.002%) from 39.287%

Build # 20606101998

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #418 from daisytuner/formatting

formatting

Run Details

14705 of 48717 branches covered (30.18%)

Branch coverage included in aggregate %.

2 of 19 new or added lines in 7 files covered. (10.53%)

1 existing line in 1 file now uncovered.

12576 of 20719 relevant lines covered (60.7%)

86.36 hits per line

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

15.38

/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
)
    : LibraryNode(
          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 {}

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_);
}

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(
    codegen::PrettyPrinter& stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::CodeSnippetFactory& library_snippet_factory
) {
    auto& node = static_cast<const MemsetNode&>(node_);

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

} // 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(	4✔
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	: LibraryNode(	4!
15	element_id,	4✔
16	debug_info,	4✔
17	vertex,	4✔
18	parent,	4✔
19	LibraryNodeType_Memset,
20	{"_ptr"},	4!
21	{},	4✔
22	true,
23	data_flow::ImplementationType_NONE
24	),
25	num_(num), value_(value) {}	4!
26
27	const symbolic::Expression MemsetNode::value() const { return value_; }	2✔
28
29	const symbolic::Expression MemsetNode::num() const { return num_; }	2✔
30
31	void MemsetNode::validate(const Function& function) const {}	3✔
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
45	void MemsetNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
46	this->value_ = symbolic::subs(this->value_, old_expression, new_expression);	×
47	this->num_ = symbolic::subs(this->num_, old_expression, new_expression);	×
48	}	×
49
50	nlohmann::json MemsetNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
51	const MemsetNode& node = static_cast<const MemsetNode&>(library_node);	×
52
53	nlohmann::json j;	×
54	j["code"] = node.code().value();	×
55
56	sdfg::serializer::JSONSerializer serializer;	×
57	j["value"] = serializer.expression(node.value());	×
58	j["num"] = serializer.expression(node.num());	×
59
60	return j;	×
61	}	×
62
63	data_flow::LibraryNode& MemsetNodeSerializer::deserialize(	×
64	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
65	) {
66	assert(j.contains("code"));	×
67	assert(j.contains("debug_info"));	×
68	assert(j.contains("value"));	×
69	assert(j.contains("num"));	×
70
71	auto code = j["code"].get<std::string>();	×
72	if (code != LibraryNodeType_Memset.value()) {	×
73	throw InvalidSDFGException("Invalid library node code");	×
74	}
75
76	// Extract debug info using JSONSerializer
77	sdfg::serializer::JSONSerializer serializer;	×
78	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
79
80	// Extract properties
81	auto value = symbolic::parse(j.at("value"));	×
82	auto num = symbolic::parse(j.at("num"));	×
83
84	return builder.add_library_node<MemsetNode>(parent, debug_info, value, num);	×
85	}	×
86
87	MemsetNodeDispatcher::MemsetNodeDispatcher(	×
88	codegen::LanguageExtension& language_extension,
89	const Function& function,
90	const data_flow::DataFlowGraph& data_flow_graph,
91	const MemsetNode& node
92	)
93	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
94
95	void MemsetNodeDispatcher::dispatch_code(	×
96	codegen::PrettyPrinter& stream,
97	codegen::PrettyPrinter& globals_stream,
98	codegen::CodeSnippetFactory& library_snippet_factory
99	) {
100	auto& node = static_cast<const MemsetNode&>(node_);	×
101
NEW 102	stream << language_extension_.external_prefix() << "memset(" << node.outputs().at(0) << ", "	×
NEW 103	<< language_extension_.expression(node.value()) << ", " << language_extension_.expression(node.num()) << ")"	×
NEW 104	<< ";";	×
105	stream << std::endl;	×
106	}	×
107
108	} // namespace stdlib
109	} // namespace sdfg

daisytuner / sdfglib / 20606101998

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