gdbsupport/thread-pool.cc

   1 /* Thread pool
   2
   3    Copyright (C) 2019-2024 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   m_sized_at_least_once = true;
 158
 159   /* If the new size is larger, start some new threads.  */
 160   if (m_thread_count < num_threads)
 161     {
 162       /* Ensure that signals used by gdb are blocked in the new
 163          threads.  */
 164       block_signals blocker;
 165       for (size_t i = m_thread_count; i < num_threads; ++i)
 166         {
 167           try
 168             {
 169               std::thread thread (&thread_pool::thread_function, this);
 170               thread.detach ();
 171             }
 172           catch (const std::system_error &)
 173             {
 174               /* libstdc++ may not implement std::thread, and will
 175                  throw an exception on use.  It seems fine to ignore
 176                  this, and any other sort of startup failure here.  */
 177               num_threads = i;
 178               break;
 179             }
 180         }
 181     }
 182   /* If the new size is smaller, terminate some existing threads.  */
 183   if (num_threads < m_thread_count)
 184     {
 185       for (size_t i = num_threads; i < m_thread_count; ++i)
 186         m_tasks.emplace ();
 187       m_tasks_cv.notify_all ();
 188     }
 189
 190   m_thread_count = num_threads;
 191 #else
 192   /* No threads available, simply ignore the request.  */
 193 #endif /* CXX_STD_THREAD */
 194 }
 195
 196 #if CXX_STD_THREAD
 197
 198 void
 199 thread_pool::do_post_task (std::packaged_task<void ()> &&func)
 200 {
 201   /* This assert is here to check that no tasks are posted to the pool between
 202      its initialization and sizing.  */
 203   gdb_assert (m_sized_at_least_once);
 204   std::packaged_task<void ()> t (std::move (func));
 205
 206   if (m_thread_count != 0)
 207     {
 208       std::lock_guard<std::mutex> guard (m_tasks_mutex);
 209       m_tasks.emplace (std::move (t));
 210       m_tasks_cv.notify_one ();
 211     }
 212   else
 213     {
 214       /* Just execute it now.  */
 215       t ();
 216     }
 217 }
 218
 219 void
 220 thread_pool::thread_function ()
 221 {
 222   /* This must be done here, because on macOS one can only set the
 223      name of the current thread.  */
 224   set_thread_name ("gdb worker");
 225
 226   /* Ensure that SIGSEGV is delivered to an alternate signal
 227      stack.  */
 228   gdb::alternate_signal_stack signal_stack;
 229
 230   while (true)
 231     {
 232       std::optional<task_t> t;
 233
 234       {
 235         /* We want to hold the lock while examining the task list, but
 236            not while invoking the task function.  */
 237         std::unique_lock<std::mutex> guard (m_tasks_mutex);
 238         while (m_tasks.empty ())
 239           m_tasks_cv.wait (guard);
 240         t = std::move (m_tasks.front());
 241         m_tasks.pop ();
 242       }
 243
 244       if (!t.has_value ())
 245         break;
 246       (*t) ();
 247     }
 248 }
 249
 250 #endif /* CXX_STD_THREAD */
 251
 252 } /* namespace gdb */