mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-11-16 12:34:43 +00:00
2caf7b1689
This introduces a new file, gdbsupport/cxx-thread.h, which provides stubs for the C++ threading functionality on systems that don't support it. On fully-working ports, this header just supplies a number of aliases in the gdb namespace. So, for instance, gdb::mutex is just an alias for std::mutex. For non-working ports, compatibility stubs are provided for the subset of threading functionality that's used in gdb. These generally do nothing and assume single-threaded operation. The idea behind this is to reduce the number of checks of CXX_STD_THREAD, making the code cleaner. Not all spots using CXX_STD_THREAD could readily be converted. In particular: * Unit tests * --config output * Code manipulating threads themselves * The extension interrupting handling code These all seem fine to me. Note there's also a check in py-dap.c. This one is perhaps slightly subtle: DAP starts threads on the Python side, but it relies on gdb itself being thread-savvy, for instance in gdb.post_event. Approved-By: Simon Marchi <simon.marchi@efficios.com>
127 lines
3.6 KiB
C++
127 lines
3.6 KiB
C++
/* Thread pool
|
|
|
|
Copyright (C) 2019-2025 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef GDBSUPPORT_THREAD_POOL_H
|
|
#define GDBSUPPORT_THREAD_POOL_H
|
|
|
|
#include <queue>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <chrono>
|
|
#include <optional>
|
|
|
|
#include "gdbsupport/cxx-thread.h"
|
|
|
|
namespace gdb
|
|
{
|
|
|
|
/* A thread pool.
|
|
|
|
There is a single global thread pool, see g_thread_pool. Tasks can
|
|
be submitted to the thread pool. They will be processed in worker
|
|
threads as time allows. */
|
|
class thread_pool
|
|
{
|
|
public:
|
|
/* The sole global thread pool. */
|
|
static thread_pool *g_thread_pool;
|
|
|
|
~thread_pool ();
|
|
DISABLE_COPY_AND_ASSIGN (thread_pool);
|
|
|
|
/* Set the thread count of this thread pool. By default, no threads
|
|
are created -- the thread count must be set first. */
|
|
void set_thread_count (size_t num_threads);
|
|
|
|
/* Return the number of executing threads. */
|
|
size_t thread_count () const
|
|
{
|
|
#if CXX_STD_THREAD
|
|
return m_thread_count;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/* Post a task to the thread pool. A future is returned, which can
|
|
be used to wait for the result. */
|
|
future<void> post_task (std::function<void ()> &&func)
|
|
{
|
|
#if CXX_STD_THREAD
|
|
std::packaged_task<void ()> task (std::move (func));
|
|
future<void> result = task.get_future ();
|
|
do_post_task (std::packaged_task<void ()> (std::move (task)));
|
|
return result;
|
|
#else
|
|
func ();
|
|
return {};
|
|
#endif /* CXX_STD_THREAD */
|
|
}
|
|
|
|
/* Post a task to the thread pool. A future is returned, which can
|
|
be used to wait for the result. */
|
|
template<typename T>
|
|
future<T> post_task (std::function<T ()> &&func)
|
|
{
|
|
#if CXX_STD_THREAD
|
|
std::packaged_task<T ()> task (std::move (func));
|
|
future<T> result = task.get_future ();
|
|
do_post_task (std::packaged_task<void ()> (std::move (task)));
|
|
return result;
|
|
#else
|
|
return future<T> (func ());
|
|
#endif /* CXX_STD_THREAD */
|
|
}
|
|
|
|
private:
|
|
|
|
thread_pool () = default;
|
|
|
|
#if CXX_STD_THREAD
|
|
/* The callback for each worker thread. */
|
|
void thread_function ();
|
|
|
|
/* Post a task to the thread pool. A future is returned, which can
|
|
be used to wait for the result. */
|
|
void do_post_task (std::packaged_task<void ()> &&func);
|
|
|
|
/* The current thread count. */
|
|
size_t m_thread_count = 0;
|
|
|
|
/* A convenience typedef for the type of a task. */
|
|
typedef std::packaged_task<void ()> task_t;
|
|
|
|
/* The tasks that have not been processed yet. An optional is used
|
|
to represent a task. If the optional is empty, then this means
|
|
that the receiving thread should terminate. If the optional is
|
|
non-empty, then it is an actual task to evaluate. */
|
|
std::queue<std::optional<task_t>> m_tasks;
|
|
|
|
/* A condition variable and mutex that are used for communication
|
|
between the main thread and the worker threads. */
|
|
std::condition_variable m_tasks_cv;
|
|
std::mutex m_tasks_mutex;
|
|
bool m_sized_at_least_once = false;
|
|
#endif /* CXX_STD_THREAD */
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* GDBSUPPORT_THREAD_POOL_H */
|