#856

Committed 28 Dec 2022 02:00AM UTC coverage: 86.602% (+0.05%) from 86.55%

Build # #856

Build Type

push

Committed by StellarBot

Commit Message

Merge #6119

6119: Update CMakeLists.txt r=hkaiser a=khuck

updating the default APEX version


Co-authored-by: Kevin Huck <khuck@cs.uoregon.edu>

Run Details

174566 of 201573 relevant lines covered (86.6%)

1876093.78 hits per line

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

66.67

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

//  Copyright (c) 2007-2022 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/config.hpp>
#include <hpx/coroutines/thread_enums.hpp>

#include <cstddef>

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"
        };
        // clang-format on

    }    // namespace strings

    char const* get_thread_state_name(thread_schedule_state state) noexcept
    {
        if (state < thread_schedule_state::active ||
            state > thread_schedule_state::pending_boost)
        {
            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 const t)
    {
        os << get_thread_state_name(t) << " (" << static_cast<std::size_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 const t)
    {
        os << get_thread_state_ex_name(t) << " (" << static_cast<std::size_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 const t)
    {
        os << get_thread_priority_name(t) << " (" << static_cast<std::size_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 const t)
    {
        os << get_stack_size_enum_name(t) << " (" << static_cast<std::size_t>(t)
           << ")";
        return os;
    }
}    // namespace hpx::threads

1	// Copyright (c) 2007-2022 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/config.hpp>
12	#include <hpx/coroutines/thread_enums.hpp>
13
14	#include <cstddef>
15
16	namespace hpx::threads {
17
18	///////////////////////////////////////////////////////////////////////
19	namespace strings {
20
21	// clang-format off
22	inline constexpr char const* const thread_state_names[] = {
23	"unknown",
24	"active",
25	"pending",
26	"suspended",
27	"depleted",
28	"terminated",
29	"staged",
30	"pending_do_not_schedule",
31	"pending_boost"
32	};
33	// clang-format on
34
35	} // namespace strings
36
37	char const* get_thread_state_name(thread_schedule_state state) noexcept	46,256,344✔
38	{
39	if (state < thread_schedule_state::active \|\|	46,256,344✔
40	state > thread_schedule_state::pending_boost)	46,256,827✔
41	{
42	return "unknown";	×
43	}
44	return strings::thread_state_names[static_cast<std::size_t>(state)];	46,256,587✔
45	}	46,256,651✔
46
47	char const* get_thread_state_name(thread_state state) noexcept	10✔
48	{
49	return get_thread_state_name(state.state());	10✔
50	}
51
52	std::ostream& operator<<(std::ostream& os, thread_schedule_state const t)	52✔
53	{
54	os << get_thread_state_name(t) << " (" << static_cast<std::size_t>(t)	52✔
55	<< ")";	52✔
56	return os;	52✔
57	}
58
59	///////////////////////////////////////////////////////////////////////
60	namespace strings {
61
62	// clang-format off
63	inline constexpr char const* const thread_state_ex_names[] = {
64	"wait_unknown",
65	"wait_signaled",
66	"wait_timeout",
67	"wait_terminate",
68	"wait_abort"
69	};
70	// clang-format on
71
72	} // namespace strings
73
74	char const* get_thread_state_ex_name(thread_restart_state state_ex) noexcept	×
75	{
76	if (state_ex < thread_restart_state::signaled \|\|	×
77	state_ex > thread_restart_state::abort)	×
78	{
79	return "wait_unknown";	×
80	}
81	return strings::thread_state_ex_names[static_cast<std::size_t>(	×
82	state_ex)];	×
83	}	×
84
85	std::ostream& operator<<(std::ostream& os, thread_restart_state const t)	×
86	{
87	os << get_thread_state_ex_name(t) << " (" << static_cast<std::size_t>(t)	×
88	<< ")";	×
89	return os;	×
90	}
91
92	///////////////////////////////////////////////////////////////////////
93	namespace strings {
94
95	// clang-format off
96	inline constexpr char const* const thread_priority_names[] = {
97	"default",
98	"low",
99	"normal",
100	"high (recursive)",
101	"boost",
102	"high (non-recursive)",
103	"bound",
104	};
105	// clang-format on
106	} // namespace strings
107
108	char const* get_thread_priority_name(thread_priority priority) noexcept	11,690,599✔
109	{
110	if (priority < thread_priority::default_ \|\|	11,690,599✔
111	priority > thread_priority::bound)	11,690,626✔
112	{
113	return "unknown";	×
114	}
115	return strings::thread_priority_names[static_cast<std::size_t>(	11,690,520✔
116	priority)];	11,690,520✔
117	}	11,690,530✔
118
119	std::ostream& operator<<(std::ostream& os, thread_priority const t)	6,950,955✔
120	{
121	os << get_thread_priority_name(t) << " (" << static_cast<std::size_t>(t)	6,950,967✔
122	<< ")";	6,950,967✔
123	return os;	6,950,967✔
124	}
125
126	namespace strings {
127
128	// clang-format off
129	inline constexpr char const* const stack_size_names[] = {
130	"small",
131	"medium",
132	"large",
133	"huge",
134	"nostack",
135	};
136	// clang-format on
137
138	} // namespace strings
139
140	char const* get_stack_size_enum_name(thread_stacksize size) noexcept	14✔
141	{
142	if (size == thread_stacksize::unknown)	14✔
143	return "unknown";	×
144
145	if (size < thread_stacksize::small_ \|\| size > thread_stacksize::nostack)	14✔
146	return "custom";	×
147
148	return strings::stack_size_names[static_cast<std::size_t>(size) - 1];	14✔
149	}	14✔
150
151	std::ostream& operator<<(std::ostream& os, thread_stacksize const t)	12✔
152	{
153	os << get_stack_size_enum_name(t) << " (" << static_cast<std::size_t>(t)	12✔
154	<< ")";	12✔
155	return os;	12✔
156	}
157	} // namespace hpx::threads

STEllAR-GROUP / hpx / #856

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