Commit | Line | Data |
---|---|---|
a0b57563 CB |
1 | /* Thread pool |
2 | ||
3666a048 | 3 | Copyright (C) 2019-2021 Free Software Foundation, Inc. |
a0b57563 CB |
4 | |
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | #include "common-defs.h" | |
21 | ||
22 | #if CXX_STD_THREAD | |
23 | ||
24 | #include "gdbsupport/thread-pool.h" | |
25 | #include "gdbsupport/alt-stack.h" | |
26 | #include "gdbsupport/block-signals.h" | |
27 | #include <algorithm> | |
14f62a09 | 28 | #include <system_error> |
a0b57563 | 29 | |
4da8c3a8 TT |
30 | /* On the off chance that we have the pthread library on a Windows |
31 | host, but std::thread is not using it, avoid calling | |
32 | pthread_setname_np on Windows. */ | |
33 | #ifndef _WIN32 | |
34 | #ifdef HAVE_PTHREAD_SETNAME_NP | |
35 | #define USE_PTHREAD_SETNAME_NP | |
36 | #endif | |
37 | #endif | |
38 | ||
39 | #ifdef USE_PTHREAD_SETNAME_NP | |
2e744276 | 40 | |
4da8c3a8 | 41 | #include <pthread.h> |
2e744276 | 42 | |
2e744276 | 43 | /* Handle platform discrepancies in pthread_setname_np: macOS uses a |
43198d20 CB |
44 | single-argument form, while Linux uses a two-argument form. NetBSD |
45 | takes a printf-style format and an argument. This wrapper handles the | |
46 | difference. */ | |
47 | ||
48 | ATTRIBUTE_UNUSED static void | |
49 | set_thread_name (int (*set_name) (pthread_t, const char *, void *), | |
50 | const char *name) | |
51 | { | |
52 | set_name (pthread_self (), "%s", const_cast<char *> (name)); | |
53 | } | |
2e744276 | 54 | |
2ffe5b9c | 55 | ATTRIBUTE_UNUSED static void |
2e744276 TT |
56 | set_thread_name (int (*set_name) (pthread_t, const char *), const char *name) |
57 | { | |
58 | set_name (pthread_self (), name); | |
59 | } | |
60 | ||
27e4fac7 TT |
61 | /* The macOS man page says that pthread_setname_np returns "void", but |
62 | the headers actually declare it returning "int". */ | |
2ffe5b9c | 63 | ATTRIBUTE_UNUSED static void |
27e4fac7 | 64 | set_thread_name (int (*set_name) (const char *), const char *name) |
2e744276 TT |
65 | { |
66 | set_name (name); | |
67 | } | |
68 | ||
2e744276 | 69 | #endif /* USE_PTHREAD_SETNAME_NP */ |
4da8c3a8 | 70 | |
a0b57563 CB |
71 | namespace gdb |
72 | { | |
73 | ||
74 | /* The thread pool detach()s its threads, so that the threads will not | |
75 | prevent the process from exiting. However, it was discovered that | |
76 | if any detached threads were still waiting on a condition variable, | |
77 | then the condition variable's destructor would wait for the threads | |
78 | to exit -- defeating the purpose. | |
79 | ||
80 | Allocating the thread pool on the heap and simply "leaking" it | |
81 | avoids this problem. | |
82 | */ | |
83 | thread_pool *thread_pool::g_thread_pool = new thread_pool (); | |
84 | ||
85 | thread_pool::~thread_pool () | |
86 | { | |
87 | /* Because this is a singleton, we don't need to clean up. The | |
88 | threads are detached so that they won't prevent process exit. | |
89 | And, cleaning up here would be actively harmful in at least one | |
90 | case -- see the comment by the definition of g_thread_pool. */ | |
91 | } | |
92 | ||
93 | void | |
94 | thread_pool::set_thread_count (size_t num_threads) | |
95 | { | |
96 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
97 | ||
98 | /* If the new size is larger, start some new threads. */ | |
99 | if (m_thread_count < num_threads) | |
100 | { | |
101 | /* Ensure that signals used by gdb are blocked in the new | |
102 | threads. */ | |
103 | block_signals blocker; | |
104 | for (size_t i = m_thread_count; i < num_threads; ++i) | |
105 | { | |
14f62a09 TT |
106 | try |
107 | { | |
108 | std::thread thread (&thread_pool::thread_function, this); | |
109 | thread.detach (); | |
110 | } | |
111 | catch (const std::system_error &) | |
112 | { | |
113 | /* libstdc++ may not implement std::thread, and will | |
114 | throw an exception on use. It seems fine to ignore | |
115 | this, and any other sort of startup failure here. */ | |
116 | num_threads = i; | |
117 | break; | |
118 | } | |
a0b57563 CB |
119 | } |
120 | } | |
121 | /* If the new size is smaller, terminate some existing threads. */ | |
122 | if (num_threads < m_thread_count) | |
123 | { | |
124 | for (size_t i = num_threads; i < m_thread_count; ++i) | |
125 | m_tasks.emplace (); | |
126 | m_tasks_cv.notify_all (); | |
127 | } | |
128 | ||
129 | m_thread_count = num_threads; | |
130 | } | |
131 | ||
132 | std::future<void> | |
698facb8 | 133 | thread_pool::post_task (std::function<void ()> &&func) |
a0b57563 | 134 | { |
698facb8 | 135 | std::packaged_task<void ()> t (std::move (func)); |
a0b57563 CB |
136 | std::future<void> f = t.get_future (); |
137 | ||
138 | if (m_thread_count == 0) | |
139 | { | |
140 | /* Just execute it now. */ | |
141 | t (); | |
142 | } | |
143 | else | |
144 | { | |
145 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
146 | m_tasks.emplace (std::move (t)); | |
147 | m_tasks_cv.notify_one (); | |
148 | } | |
149 | return f; | |
150 | } | |
151 | ||
152 | void | |
153 | thread_pool::thread_function () | |
154 | { | |
2e744276 TT |
155 | #ifdef USE_PTHREAD_SETNAME_NP |
156 | /* This must be done here, because on macOS one can only set the | |
157 | name of the current thread. */ | |
158 | set_thread_name (pthread_setname_np, "gdb worker"); | |
159 | #endif | |
160 | ||
a0b57563 CB |
161 | /* Ensure that SIGSEGV is delivered to an alternate signal |
162 | stack. */ | |
163 | gdb::alternate_signal_stack signal_stack; | |
164 | ||
165 | while (true) | |
166 | { | |
167 | optional<task> t; | |
168 | ||
169 | { | |
170 | /* We want to hold the lock while examining the task list, but | |
171 | not while invoking the task function. */ | |
172 | std::unique_lock<std::mutex> guard (m_tasks_mutex); | |
173 | while (m_tasks.empty ()) | |
174 | m_tasks_cv.wait (guard); | |
175 | t = std::move (m_tasks.front()); | |
176 | m_tasks.pop (); | |
177 | } | |
178 | ||
179 | if (!t.has_value ()) | |
180 | break; | |
181 | (*t) (); | |
182 | } | |
183 | } | |
184 | ||
185 | } | |
186 | ||
187 | #endif /* CXX_STD_THREAD */ |