27981272983

Committed 22 Jun 2026 08:18PM UTC coverage: 61.754% (-0.03%) from 61.782%

Build # 27981272983

Build Type

Pull #781

github

Committed by

web-flow

Commit Message

Merge bddaa3724 into fe87d162b

Pull Request Pull Request #781: Extend Segformer benchmarks setup

Coverage Stats

987 of 1432 new or added lines in 62 files covered. (68.92%)

9 existing lines in 7 files now uncovered.

38121 of 61730 relevant lines covered (61.75%)

993.19 hits per line

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

37.21

/sdfg/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
)
    : StdlibNode(
          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 { LibraryNode::validate(function); }

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

data_flow::PointerAccessType MemsetNode::pointer_access_type(int input_idx) const {
    if (input_idx == 0) {
        return data_flow::PointerAccessMeta::create_full_write_only(num_, true);
    } else {
        return StdlibNode::pointer_access_type(input_idx);
    }
}

std::string MemsetNode::toStr() const {
    return StdlibNode::toStr() + "(n: " + num_->__str__() + ", v: " + value_->__str__() + ")";
}

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

void MemsetNode::replace(const symbolic::ExpressionMapping& replacements) {
    this->value_ = symbolic::subs(this->value_, replacements);
    this->num_ = symbolic::subs(this->num_, replacements);
}

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_with_edges(
    codegen::CodegenOutput& out,
    std::vector<codegen::DispatchInput>& inputs,
    std::vector<codegen::DispatchOutput>& outputs
) {
    auto& node = static_cast<const MemsetNode&>(node_);

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

MemsetNode& add_memset_node(
    builder::StructuredSDFGBuilder& builder,
    Block& block,
    const std::string& dst_ptr,
    const symbolic::Expression& value,
    const symbolic::Expression& num,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& dst_ptr_access = builder.add_access(block, dst_ptr);
    auto& libnode = builder.add_library_node<stdlib::MemsetNode>(block, debug_info, value, num);
    builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);

    return static_cast<MemsetNode&>(libnode);
}

std::tuple<Block&, MemsetNode&> add_memset_block(
    builder::StructuredSDFGBuilder& builder,
    Sequence& parent,
    const std::string& dst_ptr,
    const symbolic::Expression& value,
    const symbolic::Expression& num,
    const types::IType& ptr_type,
    DebugInfo debug_info
) {
    auto& block = builder.add_block(parent);

    auto& libnode = add_memset_node(builder, block, dst_ptr, value, num, ptr_type, debug_info);

    return {block, libnode};
}

} // 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(
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	: StdlibNode(	22✔
15	element_id,	22✔
16	debug_info,	22✔
17	vertex,	22✔
18	parent,	22✔
19	LibraryNodeType_Memset,	22✔
20	{},	22✔
21	{"_ptr"},	22✔
22	true,	22✔
23	data_flow::ImplementationType_NONE	22✔
24	),	22✔
25	num_(num), value_(value) {}	22✔
26
27	const symbolic::Expression MemsetNode::value() const { return value_; }	2✔
28
29	const symbolic::Expression MemsetNode::num() const { return num_; }	6✔
30
31	void MemsetNode::validate(const Function& function) const { LibraryNode::validate(function); }	11✔
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	data_flow::PointerAccessType MemsetNode::pointer_access_type(int input_idx) const {	×
46	if (input_idx == 0) {	×
47	return data_flow::PointerAccessMeta::create_full_write_only(num_, true);	×
48	} else {	×
49	return StdlibNode::pointer_access_type(input_idx);	×
50	}	×
51	}	×
52
53	std::string MemsetNode::toStr() const {	×
54	return StdlibNode::toStr() + "(n: " + num_->__str__() + ", v: " + value_->__str__() + ")";	×
55	}	×
56
57	void MemsetNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
58	this->value_ = symbolic::subs(this->value_, old_expression, new_expression);	×
59	this->num_ = symbolic::subs(this->num_, old_expression, new_expression);	×
60	}	×
61
NEW 62	void MemsetNode::replace(const symbolic::ExpressionMapping& replacements) {	×
NEW 63	this->value_ = symbolic::subs(this->value_, replacements);	×
NEW 64	this->num_ = symbolic::subs(this->num_, replacements);	×
NEW 65	}	×
66
67	nlohmann::json MemsetNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
68	const MemsetNode& node = static_cast<const MemsetNode&>(library_node);	×
69
70	nlohmann::json j;	×
71	j["code"] = node.code().value();	×
72
73	sdfg::serializer::JSONSerializer serializer;	×
74	j["value"] = serializer.expression(node.value());	×
75	j["num"] = serializer.expression(node.num());	×
76
77	return j;	×
78	}	×
79
80	data_flow::LibraryNode& MemsetNodeSerializer::deserialize(
81	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
82	) {	×
83	assert(j.contains("code"));	×
84	assert(j.contains("debug_info"));	×
85	assert(j.contains("value"));	×
86	assert(j.contains("num"));	×
87
88	auto code = j["code"].get<std::string>();	×
89	if (code != LibraryNodeType_Memset.value()) {	×
90	throw InvalidSDFGException("Invalid library node code");	×
91	}	×
92
93	// Extract debug info using JSONSerializer
94	sdfg::serializer::JSONSerializer serializer;	×
95	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
96
97	// Extract properties
98	auto value = symbolic::parse(j.at("value"));	×
99	auto num = symbolic::parse(j.at("num"));	×
100
101	return builder.add_library_node<MemsetNode>(parent, debug_info, value, num);	×
102	}	×
103
104	MemsetNodeDispatcher::MemsetNodeDispatcher(
105	codegen::LanguageExtension& language_extension,
106	const Function& function,
107	const data_flow::DataFlowGraph& data_flow_graph,
108	const MemsetNode& node
109	)
110	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
111
112	void MemsetNodeDispatcher::dispatch_code_with_edges(
113	codegen::CodegenOutput& out,
114	std::vector<codegen::DispatchInput>& inputs,
115	std::vector<codegen::DispatchOutput>& outputs
116	) {	×
117	auto& node = static_cast<const MemsetNode&>(node_);	×
118
119	out.stream << language_extension_.external_prefix() << "memset(" << inputs.at(0).expr << ", "	×
120	<< language_extension_.expression(node.value()) << ", " << language_extension_.expression(node.num())	×
121	<< ")"	×
122	<< ";";	×
123	out.stream << std::endl;	×
124	}	×
125
126	MemsetNode& add_memset_node(
127	builder::StructuredSDFGBuilder& builder,
128	Block& block,
129	const std::string& dst_ptr,
130	const symbolic::Expression& value,
131	const symbolic::Expression& num,
132	const types::IType& ptr_type,
133	DebugInfo debug_info
134	) {	22✔
135	auto& dst_ptr_access = builder.add_access(block, dst_ptr);	22✔
136	auto& libnode = builder.add_library_node<stdlib::MemsetNode>(block, debug_info, value, num);	22✔
137	builder.add_computational_memlet(block, dst_ptr_access, libnode, "_ptr", {}, ptr_type);	22✔
138
139	return static_cast<MemsetNode&>(libnode);	22✔
140	}	22✔
141
142	std::tuple<Block&, MemsetNode&> add_memset_block(
143	builder::StructuredSDFGBuilder& builder,
144	Sequence& parent,
145	const std::string& dst_ptr,
146	const symbolic::Expression& value,
147	const symbolic::Expression& num,
148	const types::IType& ptr_type,
149	DebugInfo debug_info
150	) {	22✔
151	auto& block = builder.add_block(parent);	22✔
152
153	auto& libnode = add_memset_node(builder, block, dst_ptr, value, num, ptr_type, debug_info);	22✔
154
155	return {block, libnode};	22✔
156	}	22✔
157
158	} // namespace stdlib
159	} // namespace sdfg

daisytuner / docc / 27981272983

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