blob: 85f2348eb74a72b390a64bfa6d0a4719f4942e72 [file] [log] [blame]
/* Thread pool
Copyright (C) 2019-2024 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>
#if CXX_STD_THREAD
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#endif
#include <optional>
namespace gdb
{
#if CXX_STD_THREAD
/* Simply use the standard future. */
template<typename T>
using future = std::future<T>;
/* ... and the standard future_status. */
using future_status = std::future_status;
#else /* CXX_STD_THREAD */
/* A compatibility enum for std::future_status. This is just the
subset needed by gdb. */
enum class future_status
{
ready,
timeout,
};
/* A compatibility wrapper for std::future. Once <thread> and
<future> are available in all GCC builds -- should that ever happen
-- this can be removed. GCC does not implement threading for
MinGW, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93687.
Meanwhile, in this mode, there are no threads. Tasks submitted to
the thread pool are invoked immediately and their result is stored
here. The base template here simply wraps a T and provides some
std::future compatibility methods. The provided methods are chosen
based on what GDB needs presently. */
template<typename T>
class future
{
public:
explicit future (T value)
: m_value (std::move (value))
{
}
future () = default;
future (future &&other) = default;
future (const future &other) = delete;
future &operator= (future &&other) = default;
future &operator= (const future &other) = delete;
void wait () const { }
template<class Rep, class Period>
future_status wait_for (const std::chrono::duration<Rep,Period> &duration)
const
{
return future_status::ready;
}
T get () { return std::move (m_value); }
private:
T m_value;
};
/* A specialization for void. */
template<>
class future<void>
{
public:
void wait () const { }
template<class Rep, class Period>
future_status wait_for (const std::chrono::duration<Rep,Period> &duration)
const
{
return future_status::ready;
}
void get () { }
};
#endif /* CXX_STD_THREAD */
/* 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 */