Commit | Line | Data |
---|---|---|
a0b57563 CB |
1 | /* Thread pool |
2 | ||
3 | Copyright (C) 2019 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 | ||
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> | |
28 | ||
4da8c3a8 TT |
29 | /* On the off chance that we have the pthread library on a Windows |
30 | host, but std::thread is not using it, avoid calling | |
31 | pthread_setname_np on Windows. */ | |
32 | #ifndef _WIN32 | |
33 | #ifdef HAVE_PTHREAD_SETNAME_NP | |
34 | #define USE_PTHREAD_SETNAME_NP | |
35 | #endif | |
36 | #endif | |
37 | ||
38 | #ifdef USE_PTHREAD_SETNAME_NP | |
39 | #include <pthread.h> | |
40 | #endif | |
41 | ||
a0b57563 CB |
42 | namespace gdb |
43 | { | |
44 | ||
45 | /* The thread pool detach()s its threads, so that the threads will not | |
46 | prevent the process from exiting. However, it was discovered that | |
47 | if any detached threads were still waiting on a condition variable, | |
48 | then the condition variable's destructor would wait for the threads | |
49 | to exit -- defeating the purpose. | |
50 | ||
51 | Allocating the thread pool on the heap and simply "leaking" it | |
52 | avoids this problem. | |
53 | */ | |
54 | thread_pool *thread_pool::g_thread_pool = new thread_pool (); | |
55 | ||
56 | thread_pool::~thread_pool () | |
57 | { | |
58 | /* Because this is a singleton, we don't need to clean up. The | |
59 | threads are detached so that they won't prevent process exit. | |
60 | And, cleaning up here would be actively harmful in at least one | |
61 | case -- see the comment by the definition of g_thread_pool. */ | |
62 | } | |
63 | ||
64 | void | |
65 | thread_pool::set_thread_count (size_t num_threads) | |
66 | { | |
67 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
68 | ||
69 | /* If the new size is larger, start some new threads. */ | |
70 | if (m_thread_count < num_threads) | |
71 | { | |
72 | /* Ensure that signals used by gdb are blocked in the new | |
73 | threads. */ | |
74 | block_signals blocker; | |
75 | for (size_t i = m_thread_count; i < num_threads; ++i) | |
76 | { | |
77 | std::thread thread (&thread_pool::thread_function, this); | |
4da8c3a8 TT |
78 | #ifdef USE_PTHREAD_SETNAME_NP |
79 | pthread_setname_np (thread.native_handle (), "gdb worker"); | |
80 | #endif | |
a0b57563 CB |
81 | thread.detach (); |
82 | } | |
83 | } | |
84 | /* If the new size is smaller, terminate some existing threads. */ | |
85 | if (num_threads < m_thread_count) | |
86 | { | |
87 | for (size_t i = num_threads; i < m_thread_count; ++i) | |
88 | m_tasks.emplace (); | |
89 | m_tasks_cv.notify_all (); | |
90 | } | |
91 | ||
92 | m_thread_count = num_threads; | |
93 | } | |
94 | ||
95 | std::future<void> | |
96 | thread_pool::post_task (std::function<void ()> func) | |
97 | { | |
98 | std::packaged_task<void ()> t (func); | |
99 | std::future<void> f = t.get_future (); | |
100 | ||
101 | if (m_thread_count == 0) | |
102 | { | |
103 | /* Just execute it now. */ | |
104 | t (); | |
105 | } | |
106 | else | |
107 | { | |
108 | std::lock_guard<std::mutex> guard (m_tasks_mutex); | |
109 | m_tasks.emplace (std::move (t)); | |
110 | m_tasks_cv.notify_one (); | |
111 | } | |
112 | return f; | |
113 | } | |
114 | ||
115 | void | |
116 | thread_pool::thread_function () | |
117 | { | |
118 | /* Ensure that SIGSEGV is delivered to an alternate signal | |
119 | stack. */ | |
120 | gdb::alternate_signal_stack signal_stack; | |
121 | ||
122 | while (true) | |
123 | { | |
124 | optional<task> t; | |
125 | ||
126 | { | |
127 | /* We want to hold the lock while examining the task list, but | |
128 | not while invoking the task function. */ | |
129 | std::unique_lock<std::mutex> guard (m_tasks_mutex); | |
130 | while (m_tasks.empty ()) | |
131 | m_tasks_cv.wait (guard); | |
132 | t = std::move (m_tasks.front()); | |
133 | m_tasks.pop (); | |
134 | } | |
135 | ||
136 | if (!t.has_value ()) | |
137 | break; | |
138 | (*t) (); | |
139 | } | |
140 | } | |
141 | ||
142 | } | |
143 | ||
144 | #endif /* CXX_STD_THREAD */ |