]> Git Repo - binutils.git/blob - gdbsupport/thread-pool.cc
Automatic date update in version.in
[binutils.git] / gdbsupport / thread-pool.cc
1 /* Thread pool
2
3    Copyright (C) 2019-2022 Free Software Foundation, Inc.
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 #include "gdbsupport/thread-pool.h"
22
23 #if CXX_STD_THREAD
24
25 #include "gdbsupport/alt-stack.h"
26 #include "gdbsupport/block-signals.h"
27 #include <algorithm>
28 #include <system_error>
29
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
40
41 #include <pthread.h>
42
43 /* Handle platform discrepancies in pthread_setname_np: macOS uses a
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 do_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 }
54
55 ATTRIBUTE_UNUSED static void
56 do_set_thread_name (int (*set_name) (pthread_t, const char *),
57                     const char *name)
58 {
59   set_name (pthread_self (), name);
60 }
61
62 /* The macOS man page says that pthread_setname_np returns "void", but
63    the headers actually declare it returning "int".  */
64 ATTRIBUTE_UNUSED static void
65 do_set_thread_name (int (*set_name) (const char *), const char *name)
66 {
67   set_name (name);
68 }
69
70 static void
71 set_thread_name (const char *name)
72 {
73   do_set_thread_name (pthread_setname_np, name);
74 }
75
76 #elif defined (USE_WIN32API)
77
78 #include <windows.h>
79
80 typedef HRESULT WINAPI (SetThreadDescription_ftype) (HANDLE, PCWSTR);
81 static SetThreadDescription_ftype *dyn_SetThreadDescription;
82 static bool initialized;
83
84 static void
85 init_windows ()
86 {
87   initialized = true;
88
89   HMODULE hm = LoadLibrary (TEXT ("kernel32.dll"));
90   if (hm)
91     dyn_SetThreadDescription
92       = (SetThreadDescription_ftype *) GetProcAddress (hm,
93                                                        "SetThreadDescription");
94
95   /* On some versions of Windows, this function is only available in
96      KernelBase.dll, not kernel32.dll.  */
97   if (dyn_SetThreadDescription == nullptr)
98     {
99       hm = LoadLibrary (TEXT ("KernelBase.dll"));
100       if (hm)
101         dyn_SetThreadDescription
102           = (SetThreadDescription_ftype *) GetProcAddress (hm,
103                                                            "SetThreadDescription");
104     }
105 }
106
107 static void
108 do_set_thread_name (const wchar_t *name)
109 {
110   if (!initialized)
111     init_windows ();
112
113   if (dyn_SetThreadDescription != nullptr)
114     dyn_SetThreadDescription (GetCurrentThread (), name);
115 }
116
117 #define set_thread_name(NAME) do_set_thread_name (L ## NAME)
118
119 #else /* USE_WIN32API */
120
121 static void
122 set_thread_name (const char *name)
123 {
124 }
125
126 #endif
127
128 #endif /* CXX_STD_THREAD */
129
130 namespace gdb
131 {
132
133 /* The thread pool detach()s its threads, so that the threads will not
134    prevent the process from exiting.  However, it was discovered that
135    if any detached threads were still waiting on a condition variable,
136    then the condition variable's destructor would wait for the threads
137    to exit -- defeating the purpose.
138
139    Allocating the thread pool on the heap and simply "leaking" it
140    avoids this problem.
141 */
142 thread_pool *thread_pool::g_thread_pool = new thread_pool ();
143
144 thread_pool::~thread_pool ()
145 {
146   /* Because this is a singleton, we don't need to clean up.  The
147      threads are detached so that they won't prevent process exit.
148      And, cleaning up here would be actively harmful in at least one
149      case -- see the comment by the definition of g_thread_pool.  */
150 }
151
152 void
153 thread_pool::set_thread_count (size_t num_threads)
154 {
155 #if CXX_STD_THREAD
156   std::lock_guard<std::mutex> guard (m_tasks_mutex);
157
158   /* If the new size is larger, start some new threads.  */
159   if (m_thread_count < num_threads)
160     {
161       /* Ensure that signals used by gdb are blocked in the new
162          threads.  */
163       block_signals blocker;
164       for (size_t i = m_thread_count; i < num_threads; ++i)
165         {
166           try
167             {
168               std::thread thread (&thread_pool::thread_function, this);
169               thread.detach ();
170             }
171           catch (const std::system_error &)
172             {
173               /* libstdc++ may not implement std::thread, and will
174                  throw an exception on use.  It seems fine to ignore
175                  this, and any other sort of startup failure here.  */
176               num_threads = i;
177               break;
178             }
179         }
180     }
181   /* If the new size is smaller, terminate some existing threads.  */
182   if (num_threads < m_thread_count)
183     {
184       for (size_t i = num_threads; i < m_thread_count; ++i)
185         m_tasks.emplace ();
186       m_tasks_cv.notify_all ();
187     }
188
189   m_thread_count = num_threads;
190 #else
191   /* No threads available, simply ignore the request.  */
192 #endif /* CXX_STD_THREAD */
193 }
194
195 #if CXX_STD_THREAD
196
197 void
198 thread_pool::do_post_task (std::packaged_task<void ()> &&func)
199 {
200   std::packaged_task<void ()> t (std::move (func));
201
202   if (m_thread_count != 0)
203     {
204       std::lock_guard<std::mutex> guard (m_tasks_mutex);
205       m_tasks.emplace (std::move (t));
206       m_tasks_cv.notify_one ();
207     }
208   else
209     {
210       /* Just execute it now.  */
211       t ();
212     }
213 }
214
215 void
216 thread_pool::thread_function ()
217 {
218   /* This must be done here, because on macOS one can only set the
219      name of the current thread.  */
220   set_thread_name ("gdb worker");
221
222   /* Ensure that SIGSEGV is delivered to an alternate signal
223      stack.  */
224   gdb::alternate_signal_stack signal_stack;
225
226   while (true)
227     {
228       optional<task_t> t;
229
230       {
231         /* We want to hold the lock while examining the task list, but
232            not while invoking the task function.  */
233         std::unique_lock<std::mutex> guard (m_tasks_mutex);
234         while (m_tasks.empty ())
235           m_tasks_cv.wait (guard);
236         t = std::move (m_tasks.front());
237         m_tasks.pop ();
238       }
239
240       if (!t.has_value ())
241         break;
242       (*t) ();
243     }
244 }
245
246 #endif /* CXX_STD_THREAD */
247
248 } /* namespace gdb */
This page took 0.037079 seconds and 4 git commands to generate.