9945915519

Committed 15 Jul 2024 08:07PM UTC coverage: 93.077% (-1.3%) from 94.362%

Build # 9945915519

Build Type

push

github

Committed by

fknorr

Commit Message

Rename existing backend / executor -> legacy_backend / legacy_executor

Names 'backend' and 'executor' will be re-used, but we want to keep the
old APIs around in the meantime to keep changesets small.

Run Details

3188 of 3687 branches covered (86.47%)

Branch coverage included in aggregate %.

17 of 23 new or added lines in 6 files covered. (73.91%)

95 existing lines in 8 files now uncovered.

7232 of 7508 relevant lines covered (96.32%)

169246.64 hits per line

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

89.58

/include/utils.h

#pragma once

#include <algorithm>
#include <cassert>
#include <cstdint>
#include <functional>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>

#include <fmt/format.h>

#include "types.h"


namespace celerity::detail::utils {

/// Like std::move, but move-constructs the result so it does not reference the argument after returning.
template <typename T>
T take(T& from) {
        return std::move(from);
}

template <typename T, typename P>
bool isa(const P* p) {
        return dynamic_cast<const T*>(p) != nullptr;
}

template <typename T, typename P>
auto as(P* p) {
        assert(isa<T>(p));
        return static_cast<std::conditional_t<std::is_const_v<P>, const T*, T*>>(p);
}

template <typename BitMaskT>
constexpr inline uint32_t popcount(const BitMaskT bit_mask) noexcept {
        static_assert(std::is_integral_v<BitMaskT> && std::is_unsigned_v<BitMaskT>, "popcount argument needs to be an unsigned integer type.");

        uint32_t counter = 0;
        for(auto b = bit_mask; b; b >>= 1) {
                counter += b & 1;
        }
        return counter;
}

// Implementation from Boost.ContainerHash, licensed under the Boost Software License, Version 1.0.
inline void hash_combine(std::size_t& seed, std::size_t value) { seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2); }

struct pair_hash {
        template <typename U, typename V>
        std::size_t operator()(const std::pair<U, V>& p) const {
                std::size_t seed = 0;
                hash_combine(seed, std::hash<U>{}(p.first));
                hash_combine(seed, std::hash<V>{}(p.second));
                return seed;
        }
};

} // namespace celerity::detail::utils

namespace celerity::detail::utils_detail {

template <typename... Without, typename... ToKeep, typename T, typename... Ts>
constexpr auto tuple_without_impl(const std::tuple<ToKeep...>& to_keep, const std::tuple<T, Ts...>& to_check) {
        if constexpr((std::is_same_v<T, Without> || ...)) {
                if constexpr(sizeof...(Ts) == 0) {
                        return to_keep;
                } else {
                        return tuple_without_impl<Without...>(to_keep, std::tuple{std::get<Ts>(to_check)...});
                }
        } else {
                if constexpr(sizeof...(Ts) == 0) {
                        return std::tuple_cat(to_keep, to_check);
                } else {
                        return tuple_without_impl<Without...>(std::tuple_cat(to_keep, std::tuple{std::get<T>(to_check)}), std::tuple{std::get<Ts>(to_check)...});
                }
        }
}

template <typename Tuple, typename Callback>
constexpr void tuple_for_each_pair_impl(const Tuple&, Callback&&, std::index_sequence<>) {}

template <typename Tuple, size_t I1, size_t I2, size_t... Is, typename Callback>
constexpr void tuple_for_each_pair_impl(const Tuple& tuple, const Callback& cb, std::index_sequence<I1, I2, Is...>) {
        cb(std::get<I1>(tuple), std::get<I2>(tuple));
        tuple_for_each_pair_impl(tuple, cb, std::index_sequence<Is...>{});
}

template <typename Container, typename Key, typename Enable = void>
struct has_member_find : std::false_type {};

template <typename Container, typename Key>
struct has_member_find<Container, Key, std::void_t<decltype(std::declval<const Container&>().find(std::declval<const Key&>()))>> : std::true_type {};

template <typename Container, typename Key>
inline constexpr bool has_member_find_v = has_member_find<Container, Key>::value;

} // namespace celerity::detail::utils_detail

namespace celerity::detail::utils {

/// See `utils::type_switch_t`.
template <typename Lookup, typename... KVs>
struct type_switch {};

/// `switch` equivalent of `std::conditional_t`. Use as `utils::type_switch_t<lookup-type, key-type-1(result-type-1), key-type-2(result-type-2), ...>`
template <typename Lookup, typename... KVs>
using type_switch_t = typename type_switch<Lookup, KVs...>::type;

template <typename MatchingKey, typename Value, typename... KVs>
struct type_switch<MatchingKey, MatchingKey(Value), KVs...> {
        using type = Value;
};

template <typename NonMatching, typename Key, typename Value, typename... KVs>
struct type_switch<NonMatching, Key(Value), KVs...> {
        using type = type_switch_t<NonMatching, KVs...>;
};

template <typename... Without, typename... Ts>
constexpr auto tuple_without(const std::tuple<Ts...>& tuple) {
        if constexpr(sizeof...(Ts) > 0) {
                return utils_detail::tuple_without_impl<Without...>({}, tuple);
        } else {
                return tuple;
        }
}

template <typename Tuple, typename Callback>
constexpr void tuple_for_each_pair(const Tuple& tuple, const Callback& cb) {
        static_assert(std::tuple_size_v<Tuple> % 2 == 0, "an even number of entries is required");
        utils_detail::tuple_for_each_pair_impl(tuple, cb, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
}

/// Fiddles out the base name of a (possibly templated) struct or class from a full (possibly mangled) type name.
/// The input parameter should be `typeid(Struct*)`, i.e. a _pointer_ to the desired struct type.
std::string get_simplified_type_name_from_pointer(const std::type_info& pointer_type_info);

/// Fiddles out the base name of a (possibly templated) struct or class from a full (possibly mangled) type name.
template <typename Struct>
std::string get_simplified_type_name() {
        // Using a pointer will also make this function work types that have no definitions, which commonly happens for kernel name type.
        return get_simplified_type_name_from_pointer(typeid(Struct*));
}

/// Escapes "<", ">", and "&" with their corresponding HTML escape sequences
std::string escape_for_dot_label(std::string str);

/// Print the buffer id as either 'B1' or 'B1 "name"' (if `name` is non-empty)
std::string make_buffer_debug_label(const buffer_id bid, const std::string& name = "");

[[noreturn]] void unreachable();

enum class panic_solution {
        log_and_abort,     ///< default
        throw_logic_error, ///< enabled in unit tests to detect and recover from panics
};

/// Globally and atomically sets the behavior of `utils::panic()`.
void set_panic_solution(panic_solution solution);

/// Either throws or aborts with a message, depending on the global `panic_solution` setting.
[[noreturn]] void panic(const std::string& msg);

/// Either throws or aborts with a message, depending on the global `panic_solution` setting.
template <typename... FmtParams>
[[noreturn]] void panic(fmt::format_string<FmtParams...> fmt_string, FmtParams&&... fmt_args) {
        // TODO also receive a std::source_location with C++20.
        panic(fmt::format(fmt_string, std::forward<FmtParams>(fmt_args)...));
}

/// Ignores, logs, or panics on an error depending on the `error_policy`.
void report_error(const error_policy policy, const std::string& msg);

/// Ignores, logs, or panics on an error depending on the `error_policy`.
template <typename... FmtParams, std::enable_if_t<sizeof...(FmtParams) >= 1, int> = 0>
void report_error(const error_policy policy, const fmt::format_string<FmtParams...> fmt_string, FmtParams&&... fmt_args) {
        // TODO also receive a std::source_location with C++20.
        if(policy != error_policy::ignore) { report_error(policy, fmt::format(fmt_string, std::forward<FmtParams>(fmt_args)...)); }
}

template <typename Container>
Container set_intersection(const Container& lhs, const Container& rhs) {
        using std::begin, std::end;
        assert(std::is_sorted(begin(lhs), end(lhs)));
        assert(std::is_sorted(begin(rhs), end(rhs)));
        Container intersection;
        std::set_intersection(begin(lhs), end(lhs), begin(rhs), end(rhs), std::back_inserter(intersection));
        return intersection;
}

template <typename Container, typename Key>
bool contains(const Container& container, const Key& key) {
        using std::begin, std::end;
        if constexpr(utils_detail::has_member_find_v<Container, Key>) {
                return container.find(key) != end(container);
        } else {
                return std::find(begin(container), end(container), key) != end(container);
        }
}

} // namespace celerity::detail::utils

1	#pragma once
2
3	#include <algorithm>
4	#include <cassert>
5	#include <cstdint>
6	#include <functional>
7	#include <string>
8	#include <tuple>
9	#include <type_traits>
10	#include <typeinfo>
11
12	#include <fmt/format.h>
13
14	#include "types.h"
15
16
17	namespace celerity::detail::utils {
18
19	/// Like std::move, but move-constructs the result so it does not reference the argument after returning.
20	template <typename T>
21	T take(T& from) {	450✔
22	return std::move(from);	450✔
23	}
24
25	template <typename T, typename P>
26	bool isa(const P* p) {	78,653✔
27	return dynamic_cast<const T*>(p) != nullptr;	78,653!
28	}
29
30	template <typename T, typename P>
31	auto as(P* p) {	17,631✔
32	assert(isa<T>(p));	17,631✔
33	return static_cast<std::conditional_t<std::is_const_v<P>, const T, T>>(p);	17,631✔
34	}
35
36	template <typename BitMaskT>
37	constexpr inline uint32_t popcount(const BitMaskT bit_mask) noexcept {
38	static_assert(std::is_integral_v<BitMaskT> && std::is_unsigned_v<BitMaskT>, "popcount argument needs to be an unsigned integer type.");
39
40	uint32_t counter = 0;
41	for(auto b = bit_mask; b; b >>= 1) {
42	counter += b & 1;
43	}
44	return counter;
45	}
46
47	// Implementation from Boost.ContainerHash, licensed under the Boost Software License, Version 1.0.
48	inline void hash_combine(std::size_t& seed, std::size_t value) { seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2); }	35,886✔
49
50	struct pair_hash {
51	template <typename U, typename V>
52	std::size_t operator()(const std::pair<U, V>& p) const {	10,038✔
53	std::size_t seed = 0;	10,038✔
54	hash_combine(seed, std::hash<U>{}(p.first));	10,038✔
55	hash_combine(seed, std::hash<V>{}(p.second));	10,038✔
56	return seed;	10,038✔
57	}
58	};
59
60	} // namespace celerity::detail::utils
61
62	namespace celerity::detail::utils_detail {
63
64	template <typename... Without, typename... ToKeep, typename T, typename... Ts>
65	constexpr auto tuple_without_impl(const std::tuple<ToKeep...>& to_keep, const std::tuple<T, Ts...>& to_check) {	14✔
66	if constexpr((std::is_same_v<T, Without> \|\| ...)) {
67	if constexpr(sizeof...(Ts) == 0) {
68	return to_keep;	6✔
69	} else {
70	return tuple_without_impl<Without...>(to_keep, std::tuple{std::get<Ts>(to_check)...});
71	}
72	} else {
73	if constexpr(sizeof...(Ts) == 0) {
74	return std::tuple_cat(to_keep, to_check);	5✔
75	} else {
76	return tuple_without_impl<Without...>(std::tuple_cat(to_keep, std::tuple{std::get<T>(to_check)}), std::tuple{std::get<Ts>(to_check)...});	3✔
77	}
78	}
79	}
80
81	template <typename Tuple, typename Callback>
82	constexpr void tuple_for_each_pair_impl(const Tuple&, Callback&&, std::index_sequence<>) {}	5,572✔
83
84	template <typename Tuple, size_t I1, size_t I2, size_t... Is, typename Callback>
85	constexpr void tuple_for_each_pair_impl(const Tuple& tuple, const Callback& cb, std::index_sequence<I1, I2, Is...>) {	10,432✔
86	cb(std::get<I1>(tuple), std::get<I2>(tuple));	10,432✔
87	tuple_for_each_pair_impl(tuple, cb, std::index_sequence<Is...>{});	10,432✔
88	}	10,432✔
89
90	template <typename Container, typename Key, typename Enable = void>
91	struct has_member_find : std::false_type {};
92
93	template <typename Container, typename Key>
94	struct has_member_find<Container, Key, std::void_t<decltype(std::declval<const Container&>().find(std::declval<const Key&>()))>> : std::true_type {};
95
96	template <typename Container, typename Key>
97	inline constexpr bool has_member_find_v = has_member_find<Container, Key>::value;
98
99	} // namespace celerity::detail::utils_detail
100
101	namespace celerity::detail::utils {
102
103	/// See `utils::type_switch_t`.
104	template <typename Lookup, typename... KVs>
105	struct type_switch {};
106
107	/// `switch` equivalent of `std::conditional_t`. Use as `utils::type_switch_t<lookup-type, key-type-1(result-type-1), key-type-2(result-type-2), ...>`
108	template <typename Lookup, typename... KVs>
109	using type_switch_t = typename type_switch<Lookup, KVs...>::type;
110
111	template <typename MatchingKey, typename Value, typename... KVs>
112	struct type_switch<MatchingKey, MatchingKey(Value), KVs...> {
113	using type = Value;
114	};
115
116	template <typename NonMatching, typename Key, typename Value, typename... KVs>
117	struct type_switch<NonMatching, Key(Value), KVs...> {
118	using type = type_switch_t<NonMatching, KVs...>;
119	};
120
121	template <typename... Without, typename... Ts>
122	constexpr auto tuple_without(const std::tuple<Ts...>& tuple) {	18✔
123	if constexpr(sizeof...(Ts) > 0) {
124	return utils_detail::tuple_without_impl<Without...>({}, tuple);	11✔
125	} else {
126	return tuple;	7✔
127	}
128	}
129
130	template <typename Tuple, typename Callback>
131	constexpr void tuple_for_each_pair(const Tuple& tuple, const Callback& cb) {	5,572✔
132	static_assert(std::tuple_size_v<Tuple> % 2 == 0, "an even number of entries is required");
133	utils_detail::tuple_for_each_pair_impl(tuple, cb, std::make_index_sequence<std::tuple_size_v<Tuple>>{});	5,572✔
134	}	5,572✔
135
136	/// Fiddles out the base name of a (possibly templated) struct or class from a full (possibly mangled) type name.
137	/// The input parameter should be `typeid(Struct*)`, i.e. a _pointer_ to the desired struct type.
138	std::string get_simplified_type_name_from_pointer(const std::type_info& pointer_type_info);
139
140	/// Fiddles out the base name of a (possibly templated) struct or class from a full (possibly mangled) type name.
141	template <typename Struct>
142	std::string get_simplified_type_name() {	1,705✔
143	// Using a pointer will also make this function work types that have no definitions, which commonly happens for kernel name type.
144	return get_simplified_type_name_from_pointer(typeid(Struct*));	1,705✔
145	}
146
147	/// Escapes "<", ">", and "&" with their corresponding HTML escape sequences
148	std::string escape_for_dot_label(std::string str);
149
150	/// Print the buffer id as either 'B1' or 'B1 "name"' (if `name` is non-empty)
151	std::string make_buffer_debug_label(const buffer_id bid, const std::string& name = "");
152
153	[[noreturn]] void unreachable();
154
155	enum class panic_solution {
156	log_and_abort, ///< default
157	throw_logic_error, ///< enabled in unit tests to detect and recover from panics
158	};
159
160	/// Globally and atomically sets the behavior of `utils::panic()`.
161	void set_panic_solution(panic_solution solution);
162
163	/// Either throws or aborts with a message, depending on the global `panic_solution` setting.
164	[[noreturn]] void panic(const std::string& msg);
165
166	/// Either throws or aborts with a message, depending on the global `panic_solution` setting.
167	template <typename... FmtParams>
UNCOV 168	[[noreturn]] void panic(fmt::format_string<FmtParams...> fmt_string, FmtParams&&... fmt_args) {	×
169	// TODO also receive a std::source_location with C++20.
UNCOV 170	panic(fmt::format(fmt_string, std::forward<FmtParams>(fmt_args)...));	×
171	}
172
173	/// Ignores, logs, or panics on an error depending on the `error_policy`.
174	void report_error(const error_policy policy, const std::string& msg);
175
176	/// Ignores, logs, or panics on an error depending on the `error_policy`.
177	template <typename... FmtParams, std::enable_if_t<sizeof...(FmtParams) >= 1, int> = 0>
178	void report_error(const error_policy policy, const fmt::format_string<FmtParams...> fmt_string, FmtParams&&... fmt_args) {	31✔
179	// TODO also receive a std::source_location with C++20.
180	if(policy != error_policy::ignore) { report_error(policy, fmt::format(fmt_string, std::forward<FmtParams>(fmt_args)...)); }	79!
181	}	14✔
182
183	template <typename Container>
184	Container set_intersection(const Container& lhs, const Container& rhs) {	3✔
185	using std::begin, std::end;
186	assert(std::is_sorted(begin(lhs), end(lhs)));	3✔
187	assert(std::is_sorted(begin(rhs), end(rhs)));	3✔
188	Container intersection;	3✔
189	std::set_intersection(begin(lhs), end(lhs), begin(rhs), end(rhs), std::back_inserter(intersection));	6✔
190	return intersection;	3✔
UNCOV 191	}	×
192
193	template <typename Container, typename Key>
194	bool contains(const Container& container, const Key& key) {	6✔
195	using std::begin, std::end;
196	if constexpr(utils_detail::has_member_find_v<Container, Key>) {
197	return container.find(key) != end(container);
198	} else {
199	return std::find(begin(container), end(container), key) != end(container);	18✔
200	}
201	}
202
203	} // namespace celerity::detail::utils

celerity / celerity-runtime / 9945915519

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