1 /* Thread pool 2 3 Copyright (C) 2019-2023 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 */ 249