9973137045

Committed 17 Jul 2024 11:05AM UTC coverage: 92.797% (-0.3%) from 93.077%

Build # 9973137045

Build Type

Pull #261

github

Committed by

fknorr

Commit Message

[RM] drop executor::wait(), join in destructor instead

Pull Request Pull Request #261: [IDAG] Backends & Execution

Run Details

3300 of 3839 branches covered (85.96%)

Branch coverage included in aggregate %.

496 of 545 new or added lines in 15 files covered. (91.01%)

1 existing line in 1 file now uncovered.

7741 of 8059 relevant lines covered (96.05%)

159691.14 hits per line

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

87.5

/include/print_utils.h

#pragma once

#include "backend/sycl_backend.h"
#include "grid.h"
#include "intrusive_graph.h"
#include "ranges.h"
#include "types.h"

#include <fmt/format.h>


template <typename Interface, int Dims>
struct fmt::formatter<celerity::detail::coordinate<Interface, Dims>> : fmt::formatter<size_t> {
        format_context::iterator format(const Interface& coord, format_context& ctx) const {
                auto out = ctx.out();
                *out++ = '[';
                for(int d = 0; d < Dims; ++d) {
                        if(d != 0) *out++ = ',';
                        out = formatter<size_t>::format(coord[d], ctx);
                }
                *out++ = ']';
                return out;
        }
};

template <int Dims>
struct fmt::formatter<celerity::id<Dims>> : fmt::formatter<celerity::detail::coordinate<celerity::id<Dims>, Dims>> {};

template <int Dims>
struct fmt::formatter<celerity::range<Dims>> : fmt::formatter<celerity::detail::coordinate<celerity::range<Dims>, Dims>> {};

template <int Dims>
struct fmt::formatter<celerity::detail::box<Dims>> : fmt::formatter<celerity::id<Dims>> {
        format_context::iterator format(const celerity::detail::box<Dims>& box, format_context& ctx) const {
                auto out = ctx.out();
                out = formatter<celerity::id<Dims>>::format(box.get_min(), ctx);
                out = std::copy_n(" - ", 3, out);
                out = formatter<celerity::id<Dims>>::format(box.get_max(), ctx);
                return out;
        }
};

template <int Dims>
struct fmt::formatter<celerity::detail::region<Dims>> : fmt::formatter<celerity::detail::box<Dims>> {
        format_context::iterator format(const celerity::detail::region<Dims>& region, format_context& ctx) const {
                auto out = ctx.out();
                *out++ = '{';
                for(size_t i = 0; i < region.get_boxes().size(); ++i) {
                        if(i != 0) out = std::copy_n(", ", 2, out);
                        out = formatter<celerity::detail::box<Dims>>::format(region.get_boxes()[i], ctx);
                }
                *out++ = '}';
                return out;
        }
};

template <int Dims>
struct fmt::formatter<celerity::subrange<Dims>> : fmt::formatter<celerity::id<Dims>> {
        format_context::iterator format(const celerity::subrange<Dims>& sr, format_context& ctx) const {
                auto out = ctx.out();
                out = formatter<celerity::id<Dims>>::format(sr.offset, ctx);
                out = std::copy_n(" + ", 3, out);
                out = formatter<celerity::id<Dims>>::format(celerity::id(sr.range), ctx); // cast to id to avoid multiple inheritance
                return out;
        }
};

template <int Dims>
struct fmt::formatter<celerity::chunk<Dims>> : fmt::formatter<celerity::subrange<Dims>> {
        format_context::iterator format(const celerity::chunk<Dims>& chunk, format_context& ctx) const {
                auto out = ctx.out();
                out = fmt::formatter<celerity::subrange<Dims>>::format(celerity::subrange(chunk.offset, chunk.range), ctx);
                out = std::copy_n(" : ", 3, out);
                out = formatter<celerity::id<Dims>>::format(celerity::id(chunk.global_size), ctx); // cast to id to avoid multiple inheritance
                return out;
        }
};


// TODO prefix type aliases like in GDB pretty_printers (requires removing explicit prefixes elsewhere in the code)
#define CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(TYPE_ALIAS)                                                                              \
        template <>                                                                                                                                                \
        struct fmt::formatter<celerity::detail::TYPE_ALIAS> : fmt::formatter<celerity::detail::TYPE_ALIAS::value_type> {};

CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(task_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(buffer_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(node_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(command_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(collective_group_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(reduction_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(host_object_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(hydration_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(memory_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(device_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(raw_allocation_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(instruction_id)
CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(message_id)

#undef CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS


template <>
struct fmt::formatter<celerity::detail::dependency_kind> : fmt::formatter<std::string_view> {
        format_context::iterator format(const celerity::detail::dependency_kind kind, format_context& ctx) const {
                const auto repr = [=]() -> std::string_view {
                        switch(kind) {
                        case celerity::detail::dependency_kind::anti_dep: return "anti_dep";
                        case celerity::detail::dependency_kind::true_dep: return "true_dep";
                        default: return "???";
                        }
                }();
                return std::copy(repr.begin(), repr.end(), ctx.out());
        }
};

template <>
struct fmt::formatter<celerity::detail::dependency_origin> : fmt::formatter<std::string_view> {
        format_context::iterator format(const celerity::detail::dependency_origin origin, format_context& ctx) const {
                const auto repr = [=]() -> std::string_view {
                        switch(origin) {
                        case celerity::detail::dependency_origin::dataflow: return "dataflow";
                        case celerity::detail::dependency_origin::collective_group_serialization: return "collective_group_serialization";
                        case celerity::detail::dependency_origin::execution_front: return "execution_front";
                        case celerity::detail::dependency_origin::last_epoch: return "last_epoch";
                        default: return "???";
                        }
                }();
                return std::copy(repr.begin(), repr.end(), ctx.out());
        }
};

template <>
struct fmt::formatter<celerity::detail::allocation_id> {
        constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }

        format_context::iterator format(const celerity::detail::allocation_id aid, format_context& ctx) const {
                if(aid == celerity::detail::null_allocation_id) { return fmt::format_to(ctx.out(), "null"); }
                return fmt::format_to(ctx.out(), "M{}.A{}", aid.get_memory_id(), aid.get_raw_allocation_id());
        }
};

template <>
struct fmt::formatter<celerity::detail::allocation_with_offset> {
        constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }

        format_context::iterator format(const celerity::detail::allocation_with_offset& aid, format_context& ctx) const {
                if(aid.offset_bytes > 0) {
                        return fmt::format_to(ctx.out(), "{} + {} bytes", aid.id, aid.offset_bytes);
                } else {
                        return fmt::format_to(ctx.out(), "{}", aid.id);
                }
        }
};

template <>
struct fmt::formatter<celerity::detail::transfer_id> {
        constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }

        format_context::iterator format(const celerity::detail::transfer_id& trid, format_context& ctx) const {
                const auto [tid, bid, rid] = trid;
                auto out = ctx.out();
                if(rid != celerity::detail::no_reduction_id) {
                        out = fmt::format_to(out, "T{}.B{}.R{}", tid, bid, rid);
                } else {
                        out = fmt::format_to(out, "T{}.B{}", tid, bid);
                }
                return ctx.out();
        }
};

template <>
struct fmt::formatter<celerity::detail::sycl_backend_type> : fmt::formatter<std::string_view> {
        format_context::iterator format(const celerity::detail::sycl_backend_type type, format_context& ctx) const {
                const auto repr = [=]() -> std::string_view {
                        switch(type) {
                        case celerity::detail::sycl_backend_type::generic: return "generic";
                        case celerity::detail::sycl_backend_type::cuda: return "CUDA";
                        default: abort();
                        }
                }();
                return std::copy(repr.begin(), repr.end(), ctx.out());
        }
};

1	#pragma once
2
3	#include "backend/sycl_backend.h"
4	#include "grid.h"
5	#include "intrusive_graph.h"
6	#include "ranges.h"
7	#include "types.h"
8
9	#include <fmt/format.h>
10
11
12	template <typename Interface, int Dims>
13	struct fmt::formatter<celerity::detail::coordinate<Interface, Dims>> : fmt::formatter<size_t> {
14	format_context::iterator format(const Interface& coord, format_context& ctx) const {	18,157✔
15	auto out = ctx.out();	18,157✔
16	*out++ = '[';	18,157✔
17	for(int d = 0; d < Dims; ++d) {	72,336✔
18	if(d != 0) *out++ = ',';	54,179✔
19	out = formatter<size_t>::format(coord[d], ctx);	54,179✔
20	}
21	*out++ = ']';	18,157✔
22	return out;	18,157✔
23	}
24	};
25
26	template <int Dims>
27	struct fmt::formatter<celerity::id<Dims>> : fmt::formatter<celerity::detail::coordinate<celerity::id<Dims>, Dims>> {};
28
29	template <int Dims>
30	struct fmt::formatter<celerity::range<Dims>> : fmt::formatter<celerity::detail::coordinate<celerity::range<Dims>, Dims>> {};
31
32	template <int Dims>
33	struct fmt::formatter<celerity::detail::box<Dims>> : fmt::formatter<celerity::id<Dims>> {
34	format_context::iterator format(const celerity::detail::box<Dims>& box, format_context& ctx) const {	4,614✔
35	auto out = ctx.out();	4,614✔
36	out = formatter<celerity::id<Dims>>::format(box.get_min(), ctx);	4,614✔
37	out = std::copy_n(" - ", 3, out);	4,614✔
38	out = formatter<celerity::id<Dims>>::format(box.get_max(), ctx);	4,614✔
39	return out;	4,614✔
40	}
41	};
42
43	template <int Dims>
44	struct fmt::formatter<celerity::detail::region<Dims>> : fmt::formatter<celerity::detail::box<Dims>> {
45	format_context::iterator format(const celerity::detail::region<Dims>& region, format_context& ctx) const {	229✔
46	auto out = ctx.out();	229✔
47	*out++ = '{';	229✔
48	for(size_t i = 0; i < region.get_boxes().size(); ++i) {	475✔
49	if(i != 0) out = std::copy_n(", ", 2, out);	246✔
50	out = formatter<celerity::detail::box<Dims>>::format(region.get_boxes()[i], ctx);	246✔
51	}
52	*out++ = '}';	229✔
53	return out;	229✔
54	}
55	};
56
57	template <int Dims>
58	struct fmt::formatter<celerity::subrange<Dims>> : fmt::formatter<celerity::id<Dims>> {
59	format_context::iterator format(const celerity::subrange<Dims>& sr, format_context& ctx) const {	4,423✔
60	auto out = ctx.out();	4,423✔
61	out = formatter<celerity::id<Dims>>::format(sr.offset, ctx);	4,423✔
62	out = std::copy_n(" + ", 3, out);	4,423✔
63	out = formatter<celerity::id<Dims>>::format(celerity::id(sr.range), ctx); // cast to id to avoid multiple inheritance	4,423✔
64	return out;	4,423✔
65	}
66	};
67
68	template <int Dims>
69	struct fmt::formatter<celerity::chunk<Dims>> : fmt::formatter<celerity::subrange<Dims>> {
70	format_context::iterator format(const celerity::chunk<Dims>& chunk, format_context& ctx) const {
71	auto out = ctx.out();
72	out = fmt::formatter<celerity::subrange<Dims>>::format(celerity::subrange(chunk.offset, chunk.range), ctx);
73	out = std::copy_n(" : ", 3, out);
74	out = formatter<celerity::id<Dims>>::format(celerity::id(chunk.global_size), ctx); // cast to id to avoid multiple inheritance
75	return out;
76	}
77	};
78
79
80	// TODO prefix type aliases like in GDB pretty_printers (requires removing explicit prefixes elsewhere in the code)
81	#define CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(TYPE_ALIAS) \
82	template <> \
83	struct fmt::formatter<celerity::detail::TYPE_ALIAS> : fmt::formatter<celerity::detail::TYPE_ALIAS::value_type> {};
84
85	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(task_id)
86	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(buffer_id)
87	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(node_id)
88	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(command_id)
89	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(collective_group_id)
90	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(reduction_id)
91	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(host_object_id)
92	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(hydration_id)
93	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(memory_id)
94	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(device_id)
95	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(raw_allocation_id)
96	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(instruction_id)
97	CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS(message_id)
98
99	#undef CELERITY_DETAIL_IMPLEMENT_FMT_FORMATTER_FOR_STRONG_TYPE_ALIAS
100
101
102	template <>
103	struct fmt::formatter<celerity::detail::dependency_kind> : fmt::formatter<std::string_view> {
104	format_context::iterator format(const celerity::detail::dependency_kind kind, format_context& ctx) const {	16✔
105	const auto repr = [=]() -> std::string_view {	32✔
106	switch(kind) {	16!
107	case celerity::detail::dependency_kind::anti_dep: return "anti_dep";	8✔
108	case celerity::detail::dependency_kind::true_dep: return "true_dep";	8✔
109	default: return "???";	×
110	}
111	}();	16✔
112	return std::copy(repr.begin(), repr.end(), ctx.out());	32✔
113	}
114	};
115
116	template <>
117	struct fmt::formatter<celerity::detail::dependency_origin> : fmt::formatter<std::string_view> {
118	format_context::iterator format(const celerity::detail::dependency_origin origin, format_context& ctx) const {	10✔
119	const auto repr = [=]() -> std::string_view {	20✔
120	switch(origin) {	10!
121	case celerity::detail::dependency_origin::dataflow: return "dataflow";	5✔
122	case celerity::detail::dependency_origin::collective_group_serialization: return "collective_group_serialization";	5✔
123	case celerity::detail::dependency_origin::execution_front: return "execution_front";	×
124	case celerity::detail::dependency_origin::last_epoch: return "last_epoch";	×
125	default: return "???";	×
126	}
127	}();	10✔
128	return std::copy(repr.begin(), repr.end(), ctx.out());	20✔
129	}
130	};
131
132	template <>
133	struct fmt::formatter<celerity::detail::allocation_id> {
134	constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }	256✔
135
136	format_context::iterator format(const celerity::detail::allocation_id aid, format_context& ctx) const {	256✔
137	if(aid == celerity::detail::null_allocation_id) { return fmt::format_to(ctx.out(), "null"); }	258✔
138	return fmt::format_to(ctx.out(), "M{}.A{}", aid.get_memory_id(), aid.get_raw_allocation_id());	508✔
139	}
140	};
141
142	template <>
143	struct fmt::formatter<celerity::detail::allocation_with_offset> {
144	constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }	60✔
145
146	format_context::iterator format(const celerity::detail::allocation_with_offset& aid, format_context& ctx) const {	60✔
147	if(aid.offset_bytes > 0) {	60✔
148	return fmt::format_to(ctx.out(), "{} + {} bytes", aid.id, aid.offset_bytes);	36✔
149	} else {
150	return fmt::format_to(ctx.out(), "{}", aid.id);	84✔
151	}
152	}
153	};
154
155	template <>
156	struct fmt::formatter<celerity::detail::transfer_id> {
157	constexpr format_parse_context::iterator parse(format_parse_context& ctx) { return ctx.begin(); }	745✔
158
159	format_context::iterator format(const celerity::detail::transfer_id& trid, format_context& ctx) const {	745✔
160	const auto [tid, bid, rid] = trid;	745✔
161	auto out = ctx.out();	745✔
162	if(rid != celerity::detail::no_reduction_id) {	745✔
163	out = fmt::format_to(out, "T{}.B{}.R{}", tid, bid, rid);	146✔
164	} else {
165	out = fmt::format_to(out, "T{}.B{}", tid, bid);	1,344✔
166	}
167	return ctx.out();	1,490✔
168	}
169	};
170
171	template <>
172	struct fmt::formatter<celerity::detail::sycl_backend_type> : fmt::formatter<std::string_view> {
173	format_context::iterator format(const celerity::detail::sycl_backend_type type, format_context& ctx) const {	40✔
174	const auto repr = [=]() -> std::string_view {	80✔
175	switch(type) {	40!
176	case celerity::detail::sycl_backend_type::generic: return "generic";	40✔
NEW 177	case celerity::detail::sycl_backend_type::cuda: return "CUDA";	×
NEW 178	default: abort();	×
179	}
180	}();	40✔
181	return std::copy(repr.begin(), repr.end(), ctx.out());	80✔
182	}
183	};

celerity / celerity-runtime / 9973137045

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