10019413888

Committed 20 Jul 2024 10:08AM UTC coverage: 92.909% (-0.2%) from 93.077%

Build # 10019413888

Build Type

Pull #261

github

Committed by

web-flow

Commit Message

Merge 3e21d8a3e into fa0265a9a

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

Run Details

3305 of 3839 branches covered (86.09%)

Branch coverage included in aggregate %.

509 of 553 new or added lines in 15 files covered. (92.04%)

1 existing line in 1 file now uncovered.

7753 of 8063 relevant lines covered (96.16%)

158444.29 hits per line

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

80.17

/src/utils.cc

#include "utils.h"
#include "log.h"

#include <atomic>
#include <regex>
#include <stdexcept>

#if !defined(_MSC_VER)
// Required for kernel name demangling in Clang
#include <cxxabi.h>
#endif


namespace celerity::detail::utils {

std::string get_simplified_type_name_from_pointer(const std::type_info& pointer_type_info) {
#if !defined(_MSC_VER)
        const std::unique_ptr<char, void (*)(void*)> demangle_buffer(abi::__cxa_demangle(pointer_type_info.name(), nullptr, nullptr, nullptr), std::free);
        std::string demangled_type_name = demangle_buffer.get();
#else
        std::string demangled_type_name = pointer_type_info.name();
#endif

        // get rid of the pointer "*"
        if(!demangled_type_name.empty() && demangled_type_name.back() == '*') { demangled_type_name.pop_back(); }

        if(demangled_type_name.length() < 2) return demangled_type_name;
        bool templated = false;
        // there are two options:
        // 1. the type is templated; in this case, the last character is ">" and we go back to the matching "<"
        std::string::size_type last_idx = demangled_type_name.length() - 1;
        if(demangled_type_name[last_idx] == '>') {
                templated = true;
                int open = 0;
                while(last_idx > 1) {
                        last_idx--;
                        if(demangled_type_name[last_idx] == '>') { open++; }
                        if(demangled_type_name[last_idx] == '<') {
                                if(open > 0) {
                                        open--;
                                } else {
                                        last_idx--;
                                        break;
                                }
                        }
                }
        }
        // 2. the type isn't templated (or we just removed the template); in this case, we are interested in the part from the end to the last ":" (or the start)
        std::string::size_type start_idx = last_idx - 1;
        while(start_idx > 0 && demangled_type_name[start_idx - 1] != ':') {
                start_idx--;
        }
        // if the type was templated, we add a "<...>" to indicate that
        return demangled_type_name.substr(start_idx, last_idx - start_idx + 1) + (templated ? "<...>" : "");
}

std::string escape_for_dot_label(std::string str) {
        str = std::regex_replace(str, std::regex("&"), "&amp;");
        str = std::regex_replace(str, std::regex("<"), "&lt;");
        str = std::regex_replace(str, std::regex(">"), "&gt;");
        return str;
}

[[noreturn]] void unreachable() {
        assert(!"executed unreachable code");
        abort();
}

// The panic solution defaults to `log_and_abort`, but is set to `throw_logic_error` in test binaries. Since panics are triggered from celerity library code, we
// manage it in a global and decide which path to take at runtime. We have also considered deciding this at link time by defining a weak symbol (GCC
// __attribute__((weak))) in the library which is overwritten by a strong symbol in the test library, but decided against this because there is no equivalent in
// MSVC and we would have to resort to even dirtier linker hacks for that target.
std::atomic<panic_solution> g_panic_solution = panic_solution::log_and_abort; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

void set_panic_solution(panic_solution solution) { g_panic_solution.store(solution, std::memory_order_relaxed); }

[[noreturn]] void panic(const std::string& msg) {
        switch(g_panic_solution.load(std::memory_order_relaxed)) {
        case celerity::detail::utils::panic_solution::throw_logic_error: {
                throw std::logic_error(msg);
        }
        case celerity::detail::utils::panic_solution::log_and_abort:
        default: {
                // Print directly instead of logging: The abort message must not be hidden by log level setting, and in tests would be captured without the logging
                // infrastructure having a chance of dumping the logs due to the abort.
                fmt::print(stderr, "celerity-runtime panic: {}\n", msg);
                std::abort();
        }
        }
}

void report_error(const error_policy policy, const std::string& msg) {
        switch(policy) {
        case error_policy::ignore: break;
        case error_policy::log_warning: CELERITY_WARN("{}", msg); break;
        case error_policy::log_error: CELERITY_ERROR("{}", msg); break;
        case error_policy::panic: panic(msg); break;
        }
}

std::string make_buffer_debug_label(const buffer_id bid, const std::string& name) {
        // if there is no name defined, the name will be the buffer id.
        // if there is a name we want "id name"
        return !name.empty() ? fmt::format("B{} \"{}\"", bid, name) : fmt::format("B{}", bid);
}

std::string make_task_debug_label(const task_type tt, const task_id tid, const std::string& debug_name, bool title_case) {
        const auto type_string = [tt] {
                switch(tt) {
                case task_type::epoch: return "epoch";
                case task_type::host_compute: return "host-compute task";
                case task_type::device_compute: return "device kernel";
                case task_type::collective: return "collective host task";
                case task_type::master_node: return "master-node host task";
                case task_type::horizon: return "horizon";
                case task_type::fence: return "fence";
                default: return "unknown task";
                }
        }();

        auto label = fmt::format("{} T{}", type_string, tid);
        if(title_case) { label[0] = static_cast<char>(std::toupper(label[0])); }
        if(!debug_name.empty()) { fmt::format_to(std::back_inserter(label), " \"{}\"", debug_name); }
        return label;
}

} // namespace celerity::detail::utils


// implemented here because types.h must not depend on utils.h
std::size_t std::hash<celerity::detail::transfer_id>::operator()(const celerity::detail::transfer_id& t) const noexcept {
        auto hash = std::hash<celerity::detail::task_id>{}(t.consumer_tid);
        celerity::detail::utils::hash_combine(hash, std::hash<celerity::detail::buffer_id>{}(t.bid));
        celerity::detail::utils::hash_combine(hash, std::hash<celerity::detail::reduction_id>{}(t.rid));
        return hash;
}

1	#include "utils.h"
2	#include "log.h"
3
4	#include <atomic>
5	#include <regex>
6	#include <stdexcept>
7
8	#if !defined(_MSC_VER)
9	// Required for kernel name demangling in Clang
10	#include <cxxabi.h>
11	#endif
12
13
14	namespace celerity::detail::utils {
15
16	std::string get_simplified_type_name_from_pointer(const std::type_info& pointer_type_info) {	1,999✔
17	#if !defined(_MSC_VER)
18	const std::unique_ptr<char, void ()(void)> demangle_buffer(abi::__cxa_demangle(pointer_type_info.name(), nullptr, nullptr, nullptr), std::free);	1,999✔
19	std::string demangled_type_name = demangle_buffer.get();	5,997✔
20	#else
21	std::string demangled_type_name = pointer_type_info.name();
22	#endif
23
24	// get rid of the pointer "*"
25	if(!demangled_type_name.empty() && demangled_type_name.back() == '*') { demangled_type_name.pop_back(); }	1,999!
26
27	if(demangled_type_name.length() < 2) return demangled_type_name;	1,999!
28	bool templated = false;	1,999✔
29	// there are two options:
30	// 1. the type is templated; in this case, the last character is ">" and we go back to the matching "<"
31	std::string::size_type last_idx = demangled_type_name.length() - 1;	1,999✔
32	if(demangled_type_name[last_idx] == '>') {	1,999✔
33	templated = true;	49✔
34	int open = 0;	49✔
35	while(last_idx > 1) {	1,106!
36	last_idx--;	1,106✔
37	if(demangled_type_name[last_idx] == '>') { open++; }	1,106✔
38	if(demangled_type_name[last_idx] == '<') {	1,106✔
39	if(open > 0) {	57✔
40	open--;	8✔
41	} else {
42	last_idx--;	49✔
43	break;	49✔
44	}
45	}
46	}
47	}
48	// 2. the type isn't templated (or we just removed the template); in this case, we are interested in the part from the end to the last ":" (or the start)
49	std::string::size_type start_idx = last_idx - 1;	1,999✔
50	while(start_idx > 0 && demangled_type_name[start_idx - 1] != ':') {	35,189✔
51	start_idx--;	33,190✔
52	}
53	// if the type was templated, we add a "<...>" to indicate that
54	return demangled_type_name.substr(start_idx, last_idx - start_idx + 1) + (templated ? "<...>" : "");	3,998✔
55	}	1,999✔
56
57	std::string escape_for_dot_label(std::string str) {	326✔
58	str = std::regex_replace(str, std::regex("&"), "&");	326✔
59	str = std::regex_replace(str, std::regex("<"), "<");	326✔
60	str = std::regex_replace(str, std::regex(">"), ">");	326✔
61	return str;	326✔
62	}
63
64	[[noreturn]] void unreachable() {	×
65	assert(!"executed unreachable code");	×
66	abort();
67	}
68
69	// The panic solution defaults to `log_and_abort`, but is set to `throw_logic_error` in test binaries. Since panics are triggered from celerity library code, we
70	// manage it in a global and decide which path to take at runtime. We have also considered deciding this at link time by defining a weak symbol (GCC
71	// __attribute__((weak))) in the library which is overwritten by a strong symbol in the test library, but decided against this because there is no equivalent in
72	// MSVC and we would have to resort to even dirtier linker hacks for that target.
73	std::atomic<panic_solution> g_panic_solution = panic_solution::log_and_abort; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
74
75	void set_panic_solution(panic_solution solution) { g_panic_solution.store(solution, std::memory_order_relaxed); }	13✔
76
77	[[noreturn]] void panic(const std::string& msg) {	17✔
78	switch(g_panic_solution.load(std::memory_order_relaxed)) {	17!
79	case celerity::detail::utils::panic_solution::throw_logic_error: {	17✔
80	throw std::logic_error(msg);	17✔
81	}
82	case celerity::detail::utils::panic_solution::log_and_abort:	×
83	default: {
84	// Print directly instead of logging: The abort message must not be hidden by log level setting, and in tests would be captured without the logging
85	// infrastructure having a chance of dumping the logs due to the abort.
86	fmt::print(stderr, "celerity-runtime panic: {}\n", msg);	×
87	std::abort();	×
88	}
89	}
90	}
91
92	void report_error(const error_policy policy, const std::string& msg) {	31✔
93	switch(policy) {	31!
94	case error_policy::ignore: break;	×
95	case error_policy::log_warning: CELERITY_WARN("{}", msg); break;	4✔
96	case error_policy::log_error: CELERITY_ERROR("{}", msg); break;	24✔
97	case error_policy::panic: panic(msg); break;	17✔
98	}
99	}	14✔
100
101	std::string make_buffer_debug_label(const buffer_id bid, const std::string& name) {	273✔
102	// if there is no name defined, the name will be the buffer id.
103	// if there is a name we want "id name"
104	return !name.empty() ? fmt::format("B{} \"{}\"", bid, name) : fmt::format("B{}", bid);	546✔
105	}
106
107	std::string make_task_debug_label(const task_type tt, const task_id tid, const std::string& debug_name, bool title_case) {	31✔
108	const auto type_string = [tt] {	31✔
109	switch(tt) {	31!
NEW 110	case task_type::epoch: return "epoch";	×
111	case task_type::host_compute: return "host-compute task";	2✔
112	case task_type::device_compute: return "device kernel";	20✔
113	case task_type::collective: return "collective host task";	7✔
114	case task_type::master_node: return "master-node host task";	2✔
NEW 115	case task_type::horizon: return "horizon";	×
NEW 116	case task_type::fence: return "fence";	×
NEW 117	default: return "unknown task";	×
118	}
119	}();	31✔
120
121	auto label = fmt::format("{} T{}", type_string, tid);	31✔
122	if(title_case) { label[0] = static_cast<char>(std::toupper(label[0])); }	31✔
123	if(!debug_name.empty()) { fmt::format_to(std::back_inserter(label), " \"{}\"", debug_name); }	31✔
124	return label;	62✔
NEW 125	}	×
126
127	} // namespace celerity::detail::utils
128
129
130	// implemented here because types.h must not depend on utils.h
131	std::size_t std::hash<celerity::detail::transfer_id>::operator()(const celerity::detail::transfer_id& t) const noexcept {	7,068✔
132	auto hash = std::hash<celerity::detail::task_id>{}(t.consumer_tid);	7,068✔
133	celerity::detail::utils::hash_combine(hash, std::hash<celerity::detail::buffer_id>{}(t.bid));	7,068✔
134	celerity::detail::utils::hash_combine(hash, std::hash<celerity::detail::reduction_id>{}(t.rid));	7,068✔
135	return hash;	7,068✔
136	}

celerity / celerity-runtime / 10019413888

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