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

72.99

/sdfg/src/data_flow/pointer_metadata.cpp

#include "sdfg/data_flow/pointer_metadata.h"

#include "cereal/types/utility.hpp"
#include "sdfg/serializer/json_serializer.h"

namespace sdfg::data_flow {

MemoryAccessPatternType MemoryAccessPattern::ref() const {
    return std::unique_ptr<
        MemoryAccessPattern,
        AccessPatternsDeleter>(const_cast<MemoryAccessPattern*>(this), AccessPatternsDeleter(false));
}

MemoryAccessPatternType ConvexAccessPattern::clone() const {
    return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size_));
}

void ConvexAccessPattern::serialize_to_json(nlohmann::json& entry) {
    entry["type"] = "ConvexAccessPattern";
    serializer::JSONSerializer serializer;
    entry["size"] = serializer.expression(size_);
    entry["not_sparse"] = not_sparse_;
}

MemoryAccessPatternType ConvexAccessPattern::create(symbolic::Expression size, bool not_sparse) {
    return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size, not_sparse));
}

MemoryAccessPatternType NoAccessPattern::instance() {
    static std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter> instance(new NoAccessPattern());
    return instance->ref();
}

void NoAccessPattern::serialize_to_json(nlohmann::json& entry) { entry["type"] = "NoAccessPattern"; }

MemoryAccessPatternType NoAccessPattern::clone() const { return this->ref(); }

PointerAccessType PointerAccessMeta::ref() const {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(const_cast<PointerAccessMeta*>(this), PtrAccessDeleter(false));
}

PointerAccessType PointerAccessMeta::create_read_only(const symbolic::Expression& size, bool no_capture) {
    return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerReadOnly(size, no_capture));
}

PointerAccessType PointerAccessMeta::create_invalidate() {
    return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerInvalidate());
}

PointerAccessType PointerAccessMeta::create_full_write_only(const symbolic::Expression& size, bool no_capture) {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(new PointerFullWriteOnly(size, no_capture), PtrAccessDeleter(true));
}

PointerAccessType PointerAccessMeta::
    create_generic(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture) {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(new PointerGenericAccess(std::move(read_pattern), std::move(write_pattern), no_capture));
}

PointerReadOnly::PointerReadOnly(symbolic::Expression size, bool no_capture) : size_(size), no_capture_(no_capture) {}

MemoryAccessPatternType PointerReadOnly::access_read_pattern() const {
    if (size_.is_null()) {
        return {};
    } else {
        return ConvexAccessPattern::create(size_);
    }
}

MemoryAccessPatternType PointerReadOnly::access_write_pattern() const { return NoAccessPattern::instance(); }

void PointerReadOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    size_ = symbolic::subs(size_, old_expression, new_expression);
}

void PointerReadOnly::replace(const symbolic::ExpressionMapping& replacements) {
    size_ = SymEngine::subs(size_, replacements);
}

PointerAccessType PointerReadOnly::clone() const { return PointerAccessType(new PointerReadOnly(size_, no_capture_)); }

void PointerReadOnly::serialize_to_json(nlohmann::json& entry) {
    serializer::JSONSerializer serializer;
    entry["type"] = "PointerReadOnly";
    entry["size"] = serializer.expression(size_);
    entry["no_capture"] = no_capture_;
}

PointerFullWriteOnly::PointerFullWriteOnly(symbolic::Expression size, bool no_capture)
    : size_(size), no_capture_(no_capture) {}

MemoryAccessPatternType PointerFullWriteOnly::access_write_pattern() const {
    if (size_.is_null()) {
        return nullptr;
    } else {
        return ConvexAccessPattern::create(size_, true);
    }
}

MemoryAccessPatternType PointerFullWriteOnly::access_read_pattern() const { return NoAccessPattern::instance(); }

void PointerFullWriteOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    size_ = symbolic::subs(size_, old_expression, new_expression);
}

void PointerFullWriteOnly::replace(const symbolic::ExpressionMapping& replacements) {
    size_ = SymEngine::subs(size_, replacements);
}

PointerAccessType PointerFullWriteOnly::clone() const {
    return PointerAccessType(new PointerFullWriteOnly(size_, no_capture_));
}

void PointerFullWriteOnly::serialize_to_json(nlohmann::json& entry) {
    serializer::JSONSerializer serializer;
    entry["type"] = "PointerWriteOnly";
    entry["size"] = serializer.expression(size_);
    entry["no_capture"] = no_capture_;
}

PointerGenericAccess::
    PointerGenericAccess(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture)
    : read_pattern_(std::move(read_pattern)), write_pattern_(std::move(write_pattern)), no_capture_(no_capture) {}

MemoryAccessPatternType PointerGenericAccess::access_read_pattern() const {
    return read_pattern_ ? read_pattern_->ref() : nullptr;
}

MemoryAccessPatternType PointerGenericAccess::access_write_pattern() const {
    return write_pattern_ ? write_pattern_->ref() : nullptr;
}

bool PointerGenericAccess::may_contain_reads() const { return !read_pattern_ || !read_pattern_->empty(); }

bool PointerGenericAccess::may_contain_writes() const { return !write_pattern_ || !write_pattern_->empty(); }

void PointerGenericAccess::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    if (read_pattern_) {
        read_pattern_->replace(old_expression, new_expression);
    }
    if (write_pattern_) {
        write_pattern_->replace(old_expression, new_expression);
    }
}

void PointerGenericAccess::replace(const symbolic::ExpressionMapping& replacements) {
    if (read_pattern_) {
        read_pattern_->replace(replacements);
    }
    if (write_pattern_) {
        write_pattern_->replace(replacements);
    }
}

PointerAccessType PointerGenericAccess::clone() const {
    auto rd_patt_new = read_pattern_ ? read_pattern_->clone() : nullptr;
    auto wr_patt_new = write_pattern_ ? write_pattern_->clone() : nullptr;
    return PointerAccessType(new PointerGenericAccess(std::move(rd_patt_new), std::move(wr_patt_new), no_capture_));
}

void PointerGenericAccess::serialize_to_json(nlohmann::json& entry) {
    entry["type"] = "PointerGenericAccess";
    if (read_pattern_) {
        read_pattern_->serialize_to_json(entry["read_pattern"]);
    }
    if (write_pattern_) {
        write_pattern_->serialize_to_json(entry["write_pattern"]);
    }
    entry["no_capture"] = no_capture_;
}

PointerAccessType PointerInvalidate::clone() const { return PointerAccessType(new PointerInvalidate()); }

void PointerInvalidate::serialize_to_json(nlohmann::json& entry) { entry["type"] = "PointerInvalidate"; }

PointerAccessType PointerAccessMetaSerializer::deserialize(const nlohmann::json& entry) {
    if (entry.is_null()) {
        return nullptr;
    } else {
        auto type = entry.at("type").get<std::string>();

        if (type == "PointerInvalidate") {
            return PointerAccessMeta::create_invalidate();
        } else if (type == "PointerReadOnly") {
            return deserialize_read_only(entry);
        } else if (type == "PointerWriteOnly") {
            return deserialize_write_only(entry);
        } else if (type == "PointerGenericAccess") {
            return deserialize_generic(entry);
        } else {
            throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);
        }
    }
}

std::vector<PointerAccessType> PointerAccessMetaSerializer::deserialize_list(nlohmann::json::const_reference list) {
    std::vector<PointerAccessType> result;
    for (const auto& entry : list) {
        result.push_back(deserialize(entry));
    }
    return result;
}

std::vector<PointerAccessType> PointerAccessMetaSerializer::
    deserialize_list(nlohmann::json::const_iterator key, const nlohmann::json& parent) {
    if (key != parent.end()) {
        return deserialize_list(*key);
    } else {
        return {};
    }
}

PointerAccessType PointerAccessMetaSerializer::deserialize_read_only(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    bool no_capture = entry.at("no_capture").get<bool>();
    auto size = serializer.json_to_expr(entry.at("size"));
    return PointerAccessMeta::create_read_only(size, no_capture);
}

PointerAccessType PointerAccessMetaSerializer::deserialize_write_only(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    bool no_capture = entry.at("no_capture").get<bool>();
    auto size = serializer.json_to_expr(entry.at("size"));
    return PointerAccessMeta::create_full_write_only(size, no_capture);
}

PointerAccessType PointerAccessMetaSerializer::deserialize_generic(nlohmann::json::const_reference entry) {
    auto read_pattern = deserialize_access_pattern(entry.at("read_pattern"));
    auto write_pattern = deserialize_access_pattern(entry.at("write_pattern"));
    bool no_capture = entry.at("no_capture").get<bool>();
    return PointerAccessMeta::create_generic(std::move(read_pattern), std::move(write_pattern), no_capture);
}

MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_convex_pattern(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    auto size = serializer.json_to_expr(entry.at("size"));
    bool not_sparse = entry.at("not_sparse").get<bool>();
    return ConvexAccessPattern::create(size, not_sparse);
}

MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_access_pattern(nlohmann::json::const_reference entry) {
    if (entry.is_null()) {
        return nullptr;
    } else {
        auto type = entry.at("type").get<std::string>();
        if (type == "NoAccessPattern") {
            return NoAccessPattern::instance();
        } else if (type == "ConvexAccessPattern") {
            return deserialize_convex_pattern(entry);
        } else {
            throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);
        }
    }
}

nlohmann::json PointerAccessMetaSerializer::serialize(const std::vector<PointerAccessType>& vector) {
    auto arr = nlohmann::json::array();
    for (const auto& entry : vector) {
        nlohmann::json j;
        entry->serialize_to_json(j);
        arr.push_back(j);
    }
    return arr;
}

} // namespace sdfg::data_flow

1	#include "sdfg/data_flow/pointer_metadata.h"
2
3	#include "cereal/types/utility.hpp"
4	#include "sdfg/serializer/json_serializer.h"
5
6	namespace sdfg::data_flow {
7
8	MemoryAccessPatternType MemoryAccessPattern::ref() const {	8✔
9	return std::unique_ptr<	8✔
10	MemoryAccessPattern,	8✔
11	AccessPatternsDeleter>(const_cast<MemoryAccessPattern*>(this), AccessPatternsDeleter(false));	8✔
12	}	8✔
13
14	MemoryAccessPatternType ConvexAccessPattern::clone() const {	×
15	return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size_));	×
16	}	×
17
18	void ConvexAccessPattern::serialize_to_json(nlohmann::json& entry) {	1✔
19	entry["type"] = "ConvexAccessPattern";	1✔
20	serializer::JSONSerializer serializer;	1✔
21	entry["size"] = serializer.expression(size_);	1✔
22	entry["not_sparse"] = not_sparse_;	1✔
23	}	1✔
24
25	MemoryAccessPatternType ConvexAccessPattern::create(symbolic::Expression size, bool not_sparse) {	8✔
26	return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size, not_sparse));	8✔
27	}	8✔
28
29	MemoryAccessPatternType NoAccessPattern::instance() {	6✔
30	static std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter> instance(new NoAccessPattern());	6✔
31	return instance->ref();	6✔
32	}	6✔
33
34	void NoAccessPattern::serialize_to_json(nlohmann::json& entry) { entry["type"] = "NoAccessPattern"; }	1✔
35
36	MemoryAccessPatternType NoAccessPattern::clone() const { return this->ref(); }	×
37
38	PointerAccessType PointerAccessMeta::ref() const {	×
39	return std::unique_ptr<	×
40	PointerAccessMeta,	×
41	PtrAccessDeleter>(const_cast<PointerAccessMeta*>(this), PtrAccessDeleter(false));	×
42	}	×
43
44	PointerAccessType PointerAccessMeta::create_read_only(const symbolic::Expression& size, bool no_capture) {	6✔
45	return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerReadOnly(size, no_capture));	6✔
46	}	6✔
47
48	PointerAccessType PointerAccessMeta::create_invalidate() {	5✔
49	return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerInvalidate());	5✔
50	}	5✔
51
52	PointerAccessType PointerAccessMeta::create_full_write_only(const symbolic::Expression& size, bool no_capture) {	5✔
53	return std::unique_ptr<	5✔
54	PointerAccessMeta,	5✔
55	PtrAccessDeleter>(new PointerFullWriteOnly(size, no_capture), PtrAccessDeleter(true));	5✔
56	}	5✔
57
58	PointerAccessType PointerAccessMeta::
59	create_generic(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture) {	3✔
60	return std::unique_ptr<	3✔
61	PointerAccessMeta,	3✔
62	PtrAccessDeleter>(new PointerGenericAccess(std::move(read_pattern), std::move(write_pattern), no_capture));	3✔
63	}	3✔
64
65	PointerReadOnly::PointerReadOnly(symbolic::Expression size, bool no_capture) : size_(size), no_capture_(no_capture) {}	6✔
66
67	MemoryAccessPatternType PointerReadOnly::access_read_pattern() const {	2✔
68	if (size_.is_null()) {	2✔
69	return {};	×
70	} else {	2✔
71	return ConvexAccessPattern::create(size_);	2✔
72	}	2✔
73	}	2✔
74
75	MemoryAccessPatternType PointerReadOnly::access_write_pattern() const { return NoAccessPattern::instance(); }	2✔
76
77	void PointerReadOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
78	size_ = symbolic::subs(size_, old_expression, new_expression);	×
79	}	×
80
NEW 81	void PointerReadOnly::replace(const symbolic::ExpressionMapping& replacements) {	×
NEW 82	size_ = SymEngine::subs(size_, replacements);	×
NEW 83	}	×
84
UNCOV 85	PointerAccessType PointerReadOnly::clone() const { return PointerAccessType(new PointerReadOnly(size_, no_capture_)); }	×
86
87	void PointerReadOnly::serialize_to_json(nlohmann::json& entry) {	1✔
88	serializer::JSONSerializer serializer;	1✔
89	entry["type"] = "PointerReadOnly";	1✔
90	entry["size"] = serializer.expression(size_);	1✔
91	entry["no_capture"] = no_capture_;	1✔
92	}	1✔
93
94	PointerFullWriteOnly::PointerFullWriteOnly(symbolic::Expression size, bool no_capture)
95	: size_(size), no_capture_(no_capture) {}	5✔
96
97	MemoryAccessPatternType PointerFullWriteOnly::access_write_pattern() const {	2✔
98	if (size_.is_null()) {	2✔
99	return nullptr;	×
100	} else {	2✔
101	return ConvexAccessPattern::create(size_, true);	2✔
102	}	2✔
103	}	2✔
104
105	MemoryAccessPatternType PointerFullWriteOnly::access_read_pattern() const { return NoAccessPattern::instance(); }	2✔
106
107	void PointerFullWriteOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
108	size_ = symbolic::subs(size_, old_expression, new_expression);	×
109	}	×
110
NEW 111	void PointerFullWriteOnly::replace(const symbolic::ExpressionMapping& replacements) {	×
NEW 112	size_ = SymEngine::subs(size_, replacements);	×
NEW 113	}	×
114
115	PointerAccessType PointerFullWriteOnly::clone() const {	×
116	return PointerAccessType(new PointerFullWriteOnly(size_, no_capture_));	×
117	}	×
118
119	void PointerFullWriteOnly::serialize_to_json(nlohmann::json& entry) {	1✔
120	serializer::JSONSerializer serializer;	1✔
121	entry["type"] = "PointerWriteOnly";	1✔
122	entry["size"] = serializer.expression(size_);	1✔
123	entry["no_capture"] = no_capture_;	1✔
124	}	1✔
125
126	PointerGenericAccess::
127	PointerGenericAccess(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture)
128	: read_pattern_(std::move(read_pattern)), write_pattern_(std::move(write_pattern)), no_capture_(no_capture) {}	3✔
129
130	MemoryAccessPatternType PointerGenericAccess::access_read_pattern() const {	1✔
131	return read_pattern_ ? read_pattern_->ref() : nullptr;	1✔
132	}	1✔
133
134	MemoryAccessPatternType PointerGenericAccess::access_write_pattern() const {	1✔
135	return write_pattern_ ? write_pattern_->ref() : nullptr;	1✔
136	}	1✔
137
138	bool PointerGenericAccess::may_contain_reads() const { return !read_pattern_ \|\| !read_pattern_->empty(); }	1✔
139
140	bool PointerGenericAccess::may_contain_writes() const { return !write_pattern_ \|\| !write_pattern_->empty(); }	1✔
141
142	void PointerGenericAccess::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
143	if (read_pattern_) {	×
144	read_pattern_->replace(old_expression, new_expression);	×
145	}	×
146	if (write_pattern_) {	×
147	write_pattern_->replace(old_expression, new_expression);	×
148	}	×
149	}	×
150
NEW 151	void PointerGenericAccess::replace(const symbolic::ExpressionMapping& replacements) {	×
NEW 152	if (read_pattern_) {	×
NEW 153	read_pattern_->replace(replacements);	×
NEW 154	}	×
NEW 155	if (write_pattern_) {	×
NEW 156	write_pattern_->replace(replacements);	×
NEW 157	}	×
NEW 158	}	×
159
160	PointerAccessType PointerGenericAccess::clone() const {	×
161	auto rd_patt_new = read_pattern_ ? read_pattern_->clone() : nullptr;	×
162	auto wr_patt_new = write_pattern_ ? write_pattern_->clone() : nullptr;	×
163	return PointerAccessType(new PointerGenericAccess(std::move(rd_patt_new), std::move(wr_patt_new), no_capture_));	×
164	}	×
165
166	void PointerGenericAccess::serialize_to_json(nlohmann::json& entry) {	1✔
167	entry["type"] = "PointerGenericAccess";	1✔
168	if (read_pattern_) {	1✔
169	read_pattern_->serialize_to_json(entry["read_pattern"]);	1✔
170	}	1✔
171	if (write_pattern_) {	1✔
172	write_pattern_->serialize_to_json(entry["write_pattern"]);	1✔
173	}	1✔
174	entry["no_capture"] = no_capture_;	1✔
175	}	1✔
176
177	PointerAccessType PointerInvalidate::clone() const { return PointerAccessType(new PointerInvalidate()); }	×
178
179	void PointerInvalidate::serialize_to_json(nlohmann::json& entry) { entry["type"] = "PointerInvalidate"; }	1✔
180
181	PointerAccessType PointerAccessMetaSerializer::deserialize(const nlohmann::json& entry) {	4✔
182	if (entry.is_null()) {	4✔
183	return nullptr;	×
184	} else {	4✔
185	auto type = entry.at("type").get<std::string>();	4✔
186
187	if (type == "PointerInvalidate") {	4✔
188	return PointerAccessMeta::create_invalidate();	1✔
189	} else if (type == "PointerReadOnly") {	3✔
190	return deserialize_read_only(entry);	1✔
191	} else if (type == "PointerWriteOnly") {	2✔
192	return deserialize_write_only(entry);	1✔
193	} else if (type == "PointerGenericAccess") {	1✔
194	return deserialize_generic(entry);	1✔
195	} else {	1✔
196	throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);	×
197	}	×
198	}	4✔
199	}	4✔
200
201	std::vector<PointerAccessType> PointerAccessMetaSerializer::deserialize_list(nlohmann::json::const_reference list) {	4✔
202	std::vector<PointerAccessType> result;	4✔
203	for (const auto& entry : list) {	4✔
204	result.push_back(deserialize(entry));	4✔
205	}	4✔
206	return result;	4✔
207	}	4✔
208
209	std::vector<PointerAccessType> PointerAccessMetaSerializer::
210	deserialize_list(nlohmann::json::const_iterator key, const nlohmann::json& parent) {	3✔
211	if (key != parent.end()) {	3✔
212	return deserialize_list(*key);	3✔
213	} else {	3✔
214	return {};	×
215	}	×
216	}	3✔
217
218	PointerAccessType PointerAccessMetaSerializer::deserialize_read_only(nlohmann::json::const_reference entry) {	1✔
219	serializer::JSONSerializer serializer;	1✔
220	bool no_capture = entry.at("no_capture").get<bool>();	1✔
221	auto size = serializer.json_to_expr(entry.at("size"));	1✔
222	return PointerAccessMeta::create_read_only(size, no_capture);	1✔
223	}	1✔
224
225	PointerAccessType PointerAccessMetaSerializer::deserialize_write_only(nlohmann::json::const_reference entry) {	1✔
226	serializer::JSONSerializer serializer;	1✔
227	bool no_capture = entry.at("no_capture").get<bool>();	1✔
228	auto size = serializer.json_to_expr(entry.at("size"));	1✔
229	return PointerAccessMeta::create_full_write_only(size, no_capture);	1✔
230	}	1✔
231
232	PointerAccessType PointerAccessMetaSerializer::deserialize_generic(nlohmann::json::const_reference entry) {	1✔
233	auto read_pattern = deserialize_access_pattern(entry.at("read_pattern"));	1✔
234	auto write_pattern = deserialize_access_pattern(entry.at("write_pattern"));	1✔
235	bool no_capture = entry.at("no_capture").get<bool>();	1✔
236	return PointerAccessMeta::create_generic(std::move(read_pattern), std::move(write_pattern), no_capture);	1✔
237	}	1✔
238
239	MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_convex_pattern(nlohmann::json::const_reference entry) {	1✔
240	serializer::JSONSerializer serializer;	1✔
241	auto size = serializer.json_to_expr(entry.at("size"));	1✔
242	bool not_sparse = entry.at("not_sparse").get<bool>();	1✔
243	return ConvexAccessPattern::create(size, not_sparse);	1✔
244	}	1✔
245
246	MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_access_pattern(nlohmann::json::const_reference entry) {	2✔
247	if (entry.is_null()) {	2✔
248	return nullptr;	×
249	} else {	2✔
250	auto type = entry.at("type").get<std::string>();	2✔
251	if (type == "NoAccessPattern") {	2✔
252	return NoAccessPattern::instance();	1✔
253	} else if (type == "ConvexAccessPattern") {	1✔
254	return deserialize_convex_pattern(entry);	1✔
255	} else {	1✔
256	throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);	×
257	}	×
258	}	2✔
259	}	2✔
260
261	nlohmann::json PointerAccessMetaSerializer::serialize(const std::vector<PointerAccessType>& vector) {	4✔
262	auto arr = nlohmann::json::array();	4✔
263	for (const auto& entry : vector) {	4✔
264	nlohmann::json j;	4✔
265	entry->serialize_to_json(j);	4✔
266	arr.push_back(j);	4✔
267	}	4✔
268	return arr;	4✔
269	}	4✔
270
271	} // namespace sdfg::data_flow

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