Botan 3.8.1
Crypto and TLS for C&
Botan::Thread_Pool Class Referencefinal

#include <thread_pool.h>

Public Member Functions

Thread_Pooloperator= (const Thread_Pool &)=delete
 
Thread_Pooloperator= (Thread_Pool &&)=delete
 
void queue_thunk (const std::function< void()> &)
 
template<class F, class... Args>
auto run (F &&f, Args &&... args) -> std::future< typename std::invoke_result< F, Args... >::type >
 
void shutdown ()
 
 Thread_Pool (const Thread_Pool &)=delete
 
 Thread_Pool (size_t pool_size=0)
 
 Thread_Pool (std::optional< size_t > pool_size)
 
 Thread_Pool (Thread_Pool &&)=delete
 
size_t worker_count () const
 
 ~Thread_Pool ()
 

Static Public Member Functions

static Thread_Poolglobal_instance ()
 

Detailed Description

Definition at line 25 of file thread_pool.h.

Constructor & Destructor Documentation

◆ Thread_Pool() [1/4]

Botan::Thread_Pool::Thread_Pool ( std::optional< size_t > pool_size)

Initialize a thread pool with some number of threads

Parameters
pool_sizenumber of threads in the pool, if 0 then some default value is chosen. If the optional is nullopt then the thread pool is disabled; all work is executed immediately when queued.

Definition at line 60 of file thread_pool.cpp.

60 {
61 m_shutdown = false;
62 // On Linux, it is 16 length max, including terminator
63 const std::string tname = "Botan thread";
64
65 if(!opt_pool_size.has_value()) {
66 return;
67 }
68
69 size_t pool_size = opt_pool_size.value();
70
71 if(pool_size == 0) {
72 pool_size = OS::get_cpu_available();
73
74 // Unclear if this can happen, but be defensive
75 if(pool_size == 0) {
76 pool_size = 2;
77 }
78
79 /*
80 * For large machines don't create too many threads, unless
81 * explicitly asked to by the caller.
82 */
83 if(pool_size > 16) {
84 pool_size = 16;
85 }
86 }
87
88 m_workers.resize(pool_size);
89
90 for(size_t i = 0; i != pool_size; ++i) {
91 m_workers[i] = std::thread(&Thread_Pool::worker_thread, this);
92 OS::set_thread_name(m_workers[i], tname);
93 }
94}
size_t BOTAN_TEST_API get_cpu_available()
Definition os_utils.cpp:232

References Botan::OS::get_cpu_available().

Referenced by global_instance(), operator=(), operator=(), Thread_Pool(), Thread_Pool(), and Thread_Pool().

◆ Thread_Pool() [2/4]

Botan::Thread_Pool::Thread_Pool ( size_t pool_size = 0)
inline

Initialize a thread pool with some number of threads

Parameters
pool_sizenumber of threads in the pool, if 0 then some default value is chosen.

Definition at line 46 of file thread_pool.h.

46: Thread_Pool(std::optional<size_t>(pool_size)) {}
Thread_Pool(std::optional< size_t > pool_size)

References Thread_Pool().

◆ ~Thread_Pool()

Botan::Thread_Pool::~Thread_Pool ( )
inline

Definition at line 48 of file thread_pool.h.

48{ shutdown(); }

References shutdown().

◆ Thread_Pool() [3/4]

Botan::Thread_Pool::Thread_Pool ( const Thread_Pool & )
delete

References Thread_Pool().

◆ Thread_Pool() [4/4]

Botan::Thread_Pool::Thread_Pool ( Thread_Pool && )
delete

References Thread_Pool().

Member Function Documentation

◆ global_instance()

Thread_Pool & Botan::Thread_Pool::global_instance ( )
static

Return an instance to a shared thread pool

Definition at line 55 of file thread_pool.cpp.

55 {
56 static Thread_Pool g_thread_pool(global_thread_pool_size());
57 return g_thread_pool;
58}

References Thread_Pool().

◆ operator=() [1/2]

Thread_Pool & Botan::Thread_Pool::operator= ( const Thread_Pool & )
delete

References Thread_Pool().

◆ operator=() [2/2]

Thread_Pool & Botan::Thread_Pool::operator= ( Thread_Pool && )
delete

References queue_thunk(), and Thread_Pool().

◆ queue_thunk()

void Botan::Thread_Pool::queue_thunk ( const std::function< void()> & fn)

Definition at line 115 of file thread_pool.cpp.

115 {
116 std::unique_lock<std::mutex> lock(m_mutex);
117
118 if(m_shutdown) {
119 throw Invalid_State("Cannot add work after thread pool has shut down");
120 }
121
122 if(m_workers.empty()) {
123 return fn();
124 }
125
126 m_tasks.push_back(fn);
127 m_more_tasks.notify_one();
128}
secure_vector< T > lock(const std::vector< T > &in)
Definition secmem.h:77

References Botan::lock().

Referenced by operator=(), and run().

◆ run()

template<class F, class... Args>
auto Botan::Thread_Pool::run ( F && f,
Args &&... args ) -> std::future<typename std::invoke_result<F, Args...>::type>
inline

Definition at line 66 of file thread_pool.h.

66 {
67 using return_type = typename std::invoke_result<F, Args...>::type;
68
69 auto future_work = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
70 auto task = std::make_shared<std::packaged_task<return_type()>>(future_work);
71 auto future_result = task->get_future();
72 queue_thunk([task]() { (*task)(); });
73 return future_result;
74 }
void queue_thunk(const std::function< void()> &)

References queue_thunk().

◆ shutdown()

void Botan::Thread_Pool::shutdown ( )

Definition at line 96 of file thread_pool.cpp.

96 {
97 {
98 std::unique_lock<std::mutex> lock(m_mutex);
99
100 if(m_shutdown == true) {
101 return;
102 }
103
104 m_shutdown = true;
105
106 m_more_tasks.notify_all();
107 }
108
109 for(auto&& thread : m_workers) {
110 thread.join();
111 }
112 m_workers.clear();
113}

References Botan::lock().

Referenced by ~Thread_Pool().

◆ worker_count()

size_t Botan::Thread_Pool::worker_count ( ) const
inline

Definition at line 52 of file thread_pool.h.

52{ return m_workers.size(); }

The documentation for this class was generated from the following files: