1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
//
// Copyright 2010-2011,2015 Ettus Research LLC
// Copyright 2018-2020 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
#include <uhd/exception.hpp>
#include <uhd/utils/log.hpp>
#include <uhd/utils/thread.hpp>
#include <vector>
bool uhd::set_thread_priority_safe(float priority, bool realtime)
{
try {
set_thread_priority(priority, realtime);
return true;
} catch (const std::exception& e) {
UHD_LOGGER_WARNING("UHD")
<< "Unable to set the thread priority. Performance may be "
"negatively affected.\n"
"Please see the general application notes in the manual for "
"instructions.\n"
<< e.what();
return false;
}
}
static void check_priority_range(float priority)
{
if (priority > +1.0 or priority < -1.0) {
throw uhd::value_error("priority out of range [-1.0, +1.0]");
}
}
/***********************************************************************
* Pthread API to set priority
**********************************************************************/
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
# include <pthread.h>
void uhd::set_thread_priority(float priority, bool realtime)
{
check_priority_range(priority);
// when realtime is not enabled, use sched other
int policy = (realtime) ? SCHED_RR : SCHED_OTHER;
// we cannot have below normal priority, set to zero
if (priority < 0)
priority = 0;
// get the priority bounds for the selected policy
int min_pri = sched_get_priority_min(policy);
int max_pri = sched_get_priority_max(policy);
if (min_pri == -1 or max_pri == -1)
throw uhd::os_error("error in sched_get_priority_min/max");
// set the new priority and policy
sched_param sp;
sp.sched_priority = int(priority * (max_pri - min_pri)) + min_pri;
int ret = pthread_setschedparam(pthread_self(), policy, &sp);
if (ret != 0)
throw uhd::os_error("error in pthread_setschedparam");
}
#endif /* HAVE_PTHREAD_SETSCHEDPARAM */
/***********************************************************************
* Pthread API to set affinity
**********************************************************************/
#ifdef HAVE_PTHREAD_SETAFFINITY_NP
# include <pthread.h>
void uhd::set_thread_affinity(const std::vector<size_t>& cpu_affinity_list)
{
if (cpu_affinity_list.empty()) {
return;
}
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
for (auto cpu_num : cpu_affinity_list) {
if (cpu_num > CPU_SETSIZE) {
UHD_LOG_WARNING(
"UHD", "CPU index " << cpu_num << " in affinity list out of range");
}
CPU_SET(cpu_num, &cpu_set);
}
int status = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpu_set);
if (status != 0) {
UHD_LOG_WARNING("UHD", "Failed to set desired affinity for thread");
}
}
#endif /* HAVE_PTHREAD_SETAFFINITYNP */
/***********************************************************************
* Windows API to set priority
**********************************************************************/
#ifdef HAVE_WIN_SETTHREADPRIORITY
# include <windows.h>
void uhd::set_thread_priority(float priority, UHD_UNUSED(bool realtime))
{
check_priority_range(priority);
/*
* Process wide priority is no longer set.
* This is the responsibility of the application.
//set the priority class on the process
int pri_class = (realtime)? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS;
if (SetPriorityClass(GetCurrentProcess(), pri_class) == 0)
throw uhd::os_error("error in SetPriorityClass");
*/
// scale the priority value to the constants
int priorities[] = {THREAD_PRIORITY_IDLE,
THREAD_PRIORITY_LOWEST,
THREAD_PRIORITY_BELOW_NORMAL,
THREAD_PRIORITY_NORMAL,
THREAD_PRIORITY_ABOVE_NORMAL,
THREAD_PRIORITY_HIGHEST,
THREAD_PRIORITY_TIME_CRITICAL};
size_t pri_index = size_t((priority + 1.0) * 6 / 2.0); // -1 -> 0, +1 -> 6
// set the thread priority on the thread
if (SetThreadPriority(GetCurrentThread(), priorities[pri_index]) == 0)
throw uhd::os_error("error in SetThreadPriority");
}
#endif /* HAVE_WIN_SETTHREADPRIORITY */
/***********************************************************************
* Windows API to set affinity
**********************************************************************/
#ifdef HAVE_WIN_SETTHREADAFFINITYMASK
# include <windows.h>
void uhd::set_thread_affinity(const std::vector<size_t>& cpu_affinity_list)
{
if (cpu_affinity_list.empty()) {
return;
}
DWORD_PTR cpu_set{0};
for (auto cpu_num : cpu_affinity_list) {
if (cpu_num > 8 * sizeof(DWORD_PTR)) {
UHD_LOG_WARNING(
"UHD", "CPU index " << cpu_num << " in affinity list out of range");
}
cpu_set |= ((DWORD_PTR)1 << cpu_num);
}
DWORD_PTR status = SetThreadAffinityMask(GetCurrentThread(), cpu_set);
if (status == 0) {
UHD_LOG_WARNING("UHD", "Failed to set desired affinity for thread");
}
}
#endif /* HAVE_WIN_SETTHREADAFFINITYMASK */
/***********************************************************************
* Unimplemented API to set priority
**********************************************************************/
#ifdef HAVE_THREAD_PRIO_DUMMY
void uhd::set_thread_priority(float, bool)
{
UHD_LOG_DEBUG("UHD", "Setting thread priority is not implemented");
}
#endif /* HAVE_THREAD_PRIO_DUMMY */
/***********************************************************************
* Unimplemented API to set affinity
**********************************************************************/
#ifdef HAVE_THREAD_SETAFFINITY_DUMMY
void uhd::set_thread_affinity(const std::vector<size_t>& cpu_affinity_list)
{
UHD_LOG_DEBUG("UHD", "Setting thread affinity is not implemented");
}
#endif /* HAVE_THREAD_SETAFFINITY_DUMMY */
void uhd::set_thread_name(boost::thread* thrd, const std::string& name)
{
#ifdef HAVE_PTHREAD_SETNAME
pthread_setname_np(thrd->native_handle(), name.substr(0, 16).c_str());
#endif /* HAVE_PTHREAD_SETNAME */
#ifdef HAVE_THREAD_SETNAME_DUMMY
// Then we can't set the thread name. This function may get called
// before the logger starts, and thus can't log any error messages.
// Note that CMake will also tell the user about not being able to set
// thread names.
#endif /* HAVE_THREAD_SETNAME_DUMMY */
}
void uhd::set_thread_name(std::thread* thrd, const std::string& name)
{
#ifdef HAVE_PTHREAD_SETNAME
pthread_setname_np(thrd->native_handle(), name.substr(0, 16).c_str());
#endif /* HAVE_PTHREAD_SETNAME */
#ifdef HAVE_THREAD_SETNAME_DUMMY
// Then we can't set the thread name. This function may get called
// before the logger starts, and thus can't log any error messages.
// Note that CMake will also tell the user about not being able to set
// thread names.
#endif /* HAVE_THREAD_SETNAME_DUMMY */
}
|
