Botan::Thread_Pool Class Reference

#include <thread_pool.h>

Public Member Functions
Thread_Pool &	operator= (const Thread_Pool &)=delete
Thread_Pool &	operator= (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_Pool &	global_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_size

number 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.

                                                          {
   m_shutdown = false;
   // On Linux, it is 16 length max, including terminator
   const std::string tname = "Botan thread";
 
   if(!opt_pool_size.has_value()) {
      return;
   }
 
   size_t pool_size = opt_pool_size.value();
 
   if(pool_size == 0) {
      pool_size = OS::get_cpu_available();
 
      // Unclear if this can happen, but be defensive
      if(pool_size == 0) {
         pool_size = 2;
      }
 
      /*
      * For large machines don't create too many threads, unless
      * explicitly asked to by the caller.
      */
      if(pool_size > 16) {
         pool_size = 16;
      }
   }
 
   m_workers.resize(pool_size);
 
   for(size_t i = 0; i != pool_size; ++i) {
      m_workers[i] = std::thread(&Thread_Pool::worker_thread, this);
      OS::set_thread_name(m_workers[i], tname);
   }
}

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_size

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

Definition at line 46 of file thread_pool.h.

: 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.

{ 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.

                                          {
   static Thread_Pool g_thread_pool(global_thread_pool_size());
   return g_thread_pool;
}

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.

                                                           {
   std::unique_lock<std::mutex> lock(m_mutex);
 
   if(m_shutdown) {
      throw Invalid_State("Cannot add work after thread pool has shut down");
   }
 
   if(m_workers.empty()) {
      return fn();
   }
 
   m_tasks.push_back(fn);
   m_more_tasks.notify_one();
}

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.

                                                                                              {
         using return_type = typename std::invoke_result<F, Args...>::type;
 
         auto future_work = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
         auto task = std::make_shared<std::packaged_task<return_type()>>(future_work);
         auto future_result = task->get_future();
         queue_thunk([task]() { (*task)(); });
         return future_result;
      }

References queue_thunk().

shutdown()

void Botan::Thread_Pool::shutdown

(

)

Definition at line 96 of file thread_pool.cpp.

                           {
   {
      std::unique_lock<std::mutex> lock(m_mutex);
 
      if(m_shutdown == true) {
         return;
      }
 
      m_shutdown = true;
 
      m_more_tasks.notify_all();
   }
 
   for(auto&& thread : m_workers) {
      thread.join();
   }
   m_workers.clear();
}

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.

{ return m_workers.size(); }

---

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

• src/lib/utils/thread_utils/thread_pool.h
• src/lib/utils/thread_utils/thread_pool.cpp