Commit | Line | Data |
---|---|---|
a0b57563 CB |
1 | /* Thread pool |
2 | ||
11bc5fe4 | 3 | Copyright (C) 2019-2020 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> | |
2e744276 | 28 | #include "diagnostics.h" |
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 TT |
42 | |
43 | DIAGNOSTIC_PUSH | |
44 | DIAGNOSTIC_IGNORE_UNUSED_FUNCTION | |
45 | ||
46 | /* Handle platform discrepancies in pthread_setname_np: macOS uses a | |
47 | single-argument form, while Linux uses a two-argument form. This | |
48 | wrapper handles the difference. */ | |
49 | ||
50 | static void | |
51 | set_thread_name (int (*set_name) (pthread_t, const char *), const char *name) | |
52 | { | |
53 | set_name (pthread_self (), name); | |
54 | } | |
55 | ||
4ae7258e TT |
56 | /* The macOS man page says that pthread_setname_np returns "void", but |
57 | the headers actually declare it returning "int". */ | |
2e744276 | 58 | static void |
4ae7258e | 59 | set_thread_name (int (*set_name) (const char *), const char *name) |
2e744276 TT |
60 | { |
61 | set_name (name); | |
62 | } | |
63 | ||
64 | DIAGNOSTIC_POP | |
65 | ||
66 | #endif /* USE_PTHREAD_SETNAME_NP */ | |
4da8c3a8 | 67 | |
a0b57563 CB |
68 | namespace gdb |
69 | { | |
70 | ||
71 | /* The thread pool detach()s its threads, so that the threads will not | |
72 | prevent the process from exiting. However, it was discovered that | |
73 | if any detached threads were still waiting on a condition variable, | |
74 | then the condition variable's destructor would wait for the threads | |
75 | to exit -- defeating the purpose. | |
76 | ||
77 | Allocating the thread pool on the heap and simply "leaking" it | |
78 | avoids this problem. | |
79 | */ | |
80 | thread_pool *thread_pool::g_thread_pool = new thread_pool (); | |
81 | ||
82 | thread_pool::~thread_pool () | |
83 | { | |
84 | /* Because this is a singleton, we don't need to clean up. The | |
85 | threads are detached so that they won't prevent process exit. | |
86 | And, cleaning up here would be actively harmful in at least one | |
87 | case -- see the comment by the definition of g_thread_pool. */ | |
88 | } | |
89 | ||
90 | void | |
91 | thread_pool::set_thread_count (size_t num_threads) | |
92 | { | |
93 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
94 | ||
95 | /* If the new size is larger, start some new threads. */ | |
96 | if (m_thread_count < num_threads) | |
97 | { | |
98 | /* Ensure that signals used by gdb are blocked in the new | |
99 | threads. */ | |
100 | block_signals blocker; | |
101 | for (size_t i = m_thread_count; i < num_threads; ++i) | |
102 | { | |
103 | std::thread thread (&thread_pool::thread_function, this); | |
104 | thread.detach (); | |
105 | } | |
106 | } | |
107 | /* If the new size is smaller, terminate some existing threads. */ | |
108 | if (num_threads < m_thread_count) | |
109 | { | |
110 | for (size_t i = num_threads; i < m_thread_count; ++i) | |
111 | m_tasks.emplace (); | |
112 | m_tasks_cv.notify_all (); | |
113 | } | |
114 | ||
115 | m_thread_count = num_threads; | |
116 | } | |
117 | ||
118 | std::future<void> | |
119 | thread_pool::post_task (std::function<void ()> func) | |
120 | { | |
121 | std::packaged_task<void ()> t (func); | |
122 | std::future<void> f = t.get_future (); | |
123 | ||
124 | if (m_thread_count == 0) | |
125 | { | |
126 | /* Just execute it now. */ | |
127 | t (); | |
128 | } | |
129 | else | |
130 | { | |
131 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
132 | m_tasks.emplace (std::move (t)); | |
133 | m_tasks_cv.notify_one (); | |
134 | } | |
135 | return f; | |
136 | } | |
137 | ||
138 | void | |
139 | thread_pool::thread_function () | |
140 | { | |
2e744276 TT |
141 | #ifdef USE_PTHREAD_SETNAME_NP |
142 | /* This must be done here, because on macOS one can only set the | |
143 | name of the current thread. */ | |
144 | set_thread_name (pthread_setname_np, "gdb worker"); | |
145 | #endif | |
146 | ||
a0b57563 CB |
147 | /* Ensure that SIGSEGV is delivered to an alternate signal |
148 | stack. */ | |
149 | gdb::alternate_signal_stack signal_stack; | |
150 | ||
151 | while (true) | |
152 | { | |
153 | optional<task> t; | |
154 | ||
155 | { | |
156 | /* We want to hold the lock while examining the task list, but | |
157 | not while invoking the task function. */ | |
158 | std::unique_lock<std::mutex> guard (m_tasks_mutex); | |
159 | while (m_tasks.empty ()) | |
160 | m_tasks_cv.wait (guard); | |
161 | t = std::move (m_tasks.front()); | |
162 | m_tasks.pop (); | |
163 | } | |
164 | ||
165 | if (!t.has_value ()) | |
166 | break; | |
167 | (*t) (); | |
168 | } | |
169 | } | |
170 | ||
171 | } | |
172 | ||
173 | #endif /* CXX_STD_THREAD */ |