#882

Committed 31 Aug 2023 07:44PM UTC coverage: 41.798% (-44.7%) from 86.546%

Build # #882

Build Type

push

Committed by

Commit Message

Run Details

19442 of 46514 relevant lines covered (41.8%)

126375.38 hits per line

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

39.39

/libs/core/coroutines/src/thread_enums.cpp

//  Copyright (c) 2007-2023 Hartmut Kaiser
//  Copyright (c)      2011 Bryce Lelbach, Katelyn Kufahl
//  Copyright (c) 2008-2009 Chirag Dekate, Anshul Tandon
//  Copyright (c) 2015 Patricia Grubel
//  Copyright (c) 2017 Shoshana Jakobovits
//
//  SPDX-License-Identifier: BSL-1.0
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <hpx/coroutines/thread_enums.hpp>

#include <cstddef>
#include <cstdint>
#include <ostream>

namespace hpx::threads {

    ///////////////////////////////////////////////////////////////////////
    namespace strings {

        // clang-format off
        inline constexpr char const* const thread_state_names[] = {
            "unknown",
            "active",
            "pending",
            "suspended",
            "depleted",
            "terminated",
            "staged",
            "pending_do_not_schedule",
            "pending_boost",
            "deleted"
        };
        // clang-format on

    }    // namespace strings

    char const* get_thread_state_name(thread_schedule_state state) noexcept
    {
        if (state < thread_schedule_state::unknown ||
            state > thread_schedule_state::deleted)
        {
            return "unknown";
        }
        return strings::thread_state_names[static_cast<std::size_t>(state)];
    }

    char const* get_thread_state_name(thread_state state) noexcept
    {
        return get_thread_state_name(state.state());
    }

    std::ostream& operator<<(std::ostream& os, thread_schedule_state t)
    {
        os << get_thread_state_name(t) << " (" << static_cast<std::uint32_t>(t)
           << ")";
        return os;
    }

    ///////////////////////////////////////////////////////////////////////
    namespace strings {

        // clang-format off
        inline constexpr char const* const thread_state_ex_names[] = {
            "wait_unknown",
            "wait_signaled",
            "wait_timeout",
            "wait_terminate",
            "wait_abort"
        };
        // clang-format on

    }    // namespace strings

    char const* get_thread_state_ex_name(thread_restart_state state_ex) noexcept
    {
        if (state_ex < thread_restart_state::signaled ||
            state_ex > thread_restart_state::abort)
        {
            return "wait_unknown";
        }
        return strings::thread_state_ex_names[static_cast<std::size_t>(
            state_ex)];
    }

    std::ostream& operator<<(std::ostream& os, thread_restart_state t)
    {
        os << get_thread_state_ex_name(t) << " ("
           << static_cast<std::uint32_t>(t) << ")";
        return os;
    }

    ///////////////////////////////////////////////////////////////////////
    namespace strings {

        // clang-format off
        inline constexpr char const* const thread_priority_names[] = {
            "default",
            "low",
            "normal",
            "high (recursive)",
            "boost",
            "high (non-recursive)",
            "bound",
        };
        // clang-format on
    }    // namespace strings

    char const* get_thread_priority_name(thread_priority priority) noexcept
    {
        if (priority < thread_priority::default_ ||
            priority > thread_priority::bound)
        {
            return "unknown";
        }
        return strings::thread_priority_names[static_cast<std::size_t>(
            priority)];
    }

    std::ostream& operator<<(std::ostream& os, thread_priority t)
    {
        os << get_thread_priority_name(t) << " ("
           << static_cast<std::uint32_t>(t) << ")";
        return os;
    }

    namespace strings {

        // clang-format off
        inline constexpr char const* const stack_size_names[] = {
            "small",
            "medium",
            "large",
            "huge",
            "nostack",
        };
        // clang-format on

    }    // namespace strings

    char const* get_stack_size_enum_name(thread_stacksize size) noexcept
    {
        if (size == thread_stacksize::unknown)
            return "unknown";

        if (size < thread_stacksize::small_ || size > thread_stacksize::nostack)
            return "custom";

        return strings::stack_size_names[static_cast<std::size_t>(size) - 1];
    }

    std::ostream& operator<<(std::ostream& os, thread_stacksize t)
    {
        os << get_stack_size_enum_name(t) << " ("
           << static_cast<std::uint32_t>(t) << ")";
        return os;
    }
}    // namespace hpx::threads

1	// Copyright (c) 2007-2023 Hartmut Kaiser
2	// Copyright (c) 2011 Bryce Lelbach, Katelyn Kufahl
3	// Copyright (c) 2008-2009 Chirag Dekate, Anshul Tandon
4	// Copyright (c) 2015 Patricia Grubel
5	// Copyright (c) 2017 Shoshana Jakobovits
6	//
7	// SPDX-License-Identifier: BSL-1.0
8	// Distributed under the Boost Software License, Version 1.0. (See accompanying
9	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
10
11	#include <hpx/coroutines/thread_enums.hpp>
12
13	#include <cstddef>
14	#include <cstdint>
15	#include <ostream>
16
17	namespace hpx::threads {
18
19	///////////////////////////////////////////////////////////////////////
20	namespace strings {
21
22	// clang-format off
23	inline constexpr char const* const thread_state_names[] = {
24	"unknown",
25	"active",
26	"pending",
27	"suspended",
28	"depleted",
29	"terminated",
30	"staged",
31	"pending_do_not_schedule",
32	"pending_boost",
33	"deleted"
34	};
35	// clang-format on
36
37	} // namespace strings
38
39	char const* get_thread_state_name(thread_schedule_state state) noexcept	6✔
40	{
41	if (state < thread_schedule_state::unknown \|\|	6✔
42	state > thread_schedule_state::deleted)
43	{
44	return "unknown";
45	}
46	return strings::thread_state_names[static_cast<std::size_t>(state)];	6✔
47	}
48
49	char const* get_thread_state_name(thread_state state) noexcept	6✔
50	{
51	return get_thread_state_name(state.state());	6✔
52	}
53
54	std::ostream& operator<<(std::ostream& os, thread_schedule_state t)	×
55	{
56	os << get_thread_state_name(t) << " (" << static_cast<std::uint32_t>(t)	×
57	<< ")";	×
58	return os;	×
59	}
60
61	///////////////////////////////////////////////////////////////////////
62	namespace strings {
63
64	// clang-format off
65	inline constexpr char const* const thread_state_ex_names[] = {
66	"wait_unknown",
67	"wait_signaled",
68	"wait_timeout",
69	"wait_terminate",
70	"wait_abort"
71	};
72	// clang-format on
73
74	} // namespace strings
75
76	char const* get_thread_state_ex_name(thread_restart_state state_ex) noexcept	×
77	{
78	if (state_ex < thread_restart_state::signaled \|\|	×
79	state_ex > thread_restart_state::abort)
80	{
81	return "wait_unknown";
82	}
83	return strings::thread_state_ex_names[static_cast<std::size_t>(	×
84	state_ex)];	×
85	}
86
87	std::ostream& operator<<(std::ostream& os, thread_restart_state t)	×
88	{
89	os << get_thread_state_ex_name(t) << " ("	×
90	<< static_cast<std::uint32_t>(t) << ")";	×
91	return os;	×
92	}
93
94	///////////////////////////////////////////////////////////////////////
95	namespace strings {
96
97	// clang-format off
98	inline constexpr char const* const thread_priority_names[] = {
99	"default",
100	"low",
101	"normal",
102	"high (recursive)",
103	"boost",
104	"high (non-recursive)",
105	"bound",
106	};
107	// clang-format on
108	} // namespace strings
109
110	char const* get_thread_priority_name(thread_priority priority) noexcept	3✔
111	{
112	if (priority < thread_priority::default_ \|\|	3✔
113	priority > thread_priority::bound)
114	{
115	return "unknown";
116	}
117	return strings::thread_priority_names[static_cast<std::size_t>(	3✔
118	priority)];	3✔
119	}
120
121	std::ostream& operator<<(std::ostream& os, thread_priority t)	×
122	{
123	os << get_thread_priority_name(t) << " ("	×
124	<< static_cast<std::uint32_t>(t) << ")";	×
125	return os;	×
126	}
127
128	namespace strings {
129
130	// clang-format off
131	inline constexpr char const* const stack_size_names[] = {
132	"small",
133	"medium",
134	"large",
135	"huge",
136	"nostack",
137	};
138	// clang-format on
139
140	} // namespace strings
141
142	char const* get_stack_size_enum_name(thread_stacksize size) noexcept	2✔
143	{
144	if (size == thread_stacksize::unknown)	2✔
145	return "unknown";
146
147	if (size < thread_stacksize::small_ \|\| size > thread_stacksize::nostack)	2✔
148	return "custom";
149
150	return strings::stack_size_names[static_cast<std::size_t>(size) - 1];	2✔
151	}
152
153	std::ostream& operator<<(std::ostream& os, thread_stacksize t)	×
154	{
155	os << get_stack_size_enum_name(t) << " ("	×
156	<< static_cast<std::uint32_t>(t) << ")";	×
157	return os;	×
158	}
159	} // namespace hpx::threads

STEllAR-GROUP / hpx / #882

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