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

0.0

/sdfg/src/data_flow/library_nodes/stdlib/calloc.cpp

#include "sdfg/data_flow/library_nodes/stdlib/calloc.h"

namespace sdfg {
namespace stdlib {

CallocNode::CallocNode(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    data_flow::DataFlowGraph& parent,
    const symbolic::Expression num,
    const symbolic::Expression size
)
    : StdlibNode(
          element_id,
          debug_info,
          vertex,
          parent,
          LibraryNodeType_Calloc,
          {"_ret"},
          {},
          true,
          data_flow::ImplementationType_NONE
      ),
      num_(num), size_(size) {}

const symbolic::Expression CallocNode::num() const { return num_; }

const symbolic::Expression CallocNode::size() const { return size_; }

void CallocNode::validate(const Function& function) const { LibraryNode::validate(function); }

symbolic::SymbolSet CallocNode::symbols() const {
    auto num_symbols = symbolic::atoms(this->num_);
    auto size_symbols = symbolic::atoms(this->size_);
    num_symbols.insert(size_symbols.begin(), size_symbols.end());
    return num_symbols;
}

std::unique_ptr<data_flow::DataFlowNode> CallocNode::
    clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {
    return std::make_unique<CallocNode>(element_id, debug_info_, vertex, parent, num_, size_);
}

void CallocNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    this->size_ = symbolic::subs(this->size_, old_expression, new_expression);
    this->num_ = symbolic::subs(this->num_, old_expression, new_expression);
}

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

nlohmann::json CallocNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {
    const CallocNode& node = static_cast<const CallocNode&>(library_node);

    nlohmann::json j;
    j["code"] = node.code().value();

    sdfg::serializer::JSONSerializer serializer;
    j["size"] = serializer.expression(node.size());
    j["num"] = serializer.expression(node.num());

    return j;
}

data_flow::LibraryNode& CallocNodeSerializer::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("size"));
    assert(j.contains("num"));

    auto code = j["code"].get<std::string>();
    if (code != LibraryNodeType_Calloc.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 size = symbolic::parse(j.at("size"));
    auto num = symbolic::parse(j.at("num"));

    return builder.add_library_node<CallocNode>(parent, debug_info, num, size);
}

CallocNodeDispatcher::CallocNodeDispatcher(
    codegen::LanguageExtension& language_extension,
    const Function& function,
    const data_flow::DataFlowGraph& data_flow_graph,
    const CallocNode& node
)
    : codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}

void CallocNodeDispatcher::dispatch_code(
    codegen::PrettyPrinter& stream,
    codegen::PrettyPrinter& globals_stream,
    codegen::CodeSnippetFactory& library_snippet_factory
) {
    auto& Calloc_node = static_cast<const CallocNode&>(node_);

    stream << Calloc_node.outputs().at(0);
    stream << " = ";
    stream << language_extension_.external_prefix() << "calloc(" << language_extension_.expression(Calloc_node.num())
           << ", " << language_extension_.expression(Calloc_node.size()) << ")" << ";";
    stream << std::endl;
}

} // namespace stdlib
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/stdlib/calloc.h"
2
3	namespace sdfg {
4	namespace stdlib {
5
6	CallocNode::CallocNode(
7	size_t element_id,
8	const DebugInfo& debug_info,
9	const graph::Vertex vertex,
10	data_flow::DataFlowGraph& parent,
11	const symbolic::Expression num,
12	const symbolic::Expression size
13	)
14	: StdlibNode(	×
15	element_id,	×
16	debug_info,	×
17	vertex,	×
18	parent,	×
19	LibraryNodeType_Calloc,	×
20	{"_ret"},	×
21	{},	×
22	true,	×
23	data_flow::ImplementationType_NONE	×
24	),	×
25	num_(num), size_(size) {}	×
26
27	const symbolic::Expression CallocNode::num() const { return num_; }	×
28
29	const symbolic::Expression CallocNode::size() const { return size_; }	×
30
31	void CallocNode::validate(const Function& function) const { LibraryNode::validate(function); }	×
32
33	symbolic::SymbolSet CallocNode::symbols() const {	×
34	auto num_symbols = symbolic::atoms(this->num_);	×
35	auto size_symbols = symbolic::atoms(this->size_);	×
36	num_symbols.insert(size_symbols.begin(), size_symbols.end());	×
37	return num_symbols;	×
38	}	×
39
40	std::unique_ptr<data_flow::DataFlowNode> CallocNode::
41	clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {	×
42	return std::make_unique<CallocNode>(element_id, debug_info_, vertex, parent, num_, size_);	×
43	}	×
44
45	void CallocNode::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
46	this->size_ = symbolic::subs(this->size_, old_expression, new_expression);	×
47	this->num_ = symbolic::subs(this->num_, old_expression, new_expression);	×
48	}	×
49
NEW 50	void CallocNode::replace(const symbolic::ExpressionMapping& replacements) {	×
NEW 51	this->size_ = symbolic::subs(this->size_, replacements);	×
NEW 52	this->num_ = symbolic::subs(this->num_, replacements);	×
NEW 53	}	×
54
55	nlohmann::json CallocNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {	×
56	const CallocNode& node = static_cast<const CallocNode&>(library_node);	×
57
58	nlohmann::json j;	×
59	j["code"] = node.code().value();	×
60
61	sdfg::serializer::JSONSerializer serializer;	×
62	j["size"] = serializer.expression(node.size());	×
63	j["num"] = serializer.expression(node.num());	×
64
65	return j;	×
66	}	×
67
68	data_flow::LibraryNode& CallocNodeSerializer::deserialize(
69	const nlohmann::json& j, builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& parent
70	) {	×
71	assert(j.contains("code"));	×
72	assert(j.contains("debug_info"));	×
73	assert(j.contains("size"));	×
74	assert(j.contains("num"));	×
75
76	auto code = j["code"].get<std::string>();	×
77	if (code != LibraryNodeType_Calloc.value()) {	×
78	throw InvalidSDFGException("Invalid library node code");	×
79	}	×
80
81	// Extract debug info using JSONSerializer
82	sdfg::serializer::JSONSerializer serializer;	×
83	DebugInfo debug_info = serializer.json_to_debug_info(j["debug_info"]);	×
84
85	// Extract properties
86	auto size = symbolic::parse(j.at("size"));	×
87	auto num = symbolic::parse(j.at("num"));	×
88
89	return builder.add_library_node<CallocNode>(parent, debug_info, num, size);	×
90	}	×
91
92	CallocNodeDispatcher::CallocNodeDispatcher(
93	codegen::LanguageExtension& language_extension,
94	const Function& function,
95	const data_flow::DataFlowGraph& data_flow_graph,
96	const CallocNode& node
97	)
98	: codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}	×
99
100	void CallocNodeDispatcher::dispatch_code(
101	codegen::PrettyPrinter& stream,
102	codegen::PrettyPrinter& globals_stream,
103	codegen::CodeSnippetFactory& library_snippet_factory
104	) {	×
105	auto& Calloc_node = static_cast<const CallocNode&>(node_);	×
106
107	stream << Calloc_node.outputs().at(0);	×
108	stream << " = ";	×
109	stream << language_extension_.external_prefix() << "calloc(" << language_extension_.expression(Calloc_node.num())	×
110	<< ", " << language_extension_.expression(Calloc_node.size()) << ")" << ";";	×
111	stream << std::endl;	×
112	}	×
113
114	} // namespace stdlib
115	} // 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