global_pool_backend.hpp

Go to the documentation of this file.

#pragma once
 
#include "thread_pool_backend_base.hpp"
#include "work_stealing_pool_backend.hpp"
#include "worker_count.hpp"
 
#include <cstddef>
#include <mutex>
#include <thread>
#include <utility>
 
namespace threadschedule::detail
{
 
// ---------------------------------------------------------------------------
// global_pool_backend
// ---------------------------------------------------------------------------
 
template <typename PoolType>
class global_pool_backend
{
public:
  static void
  init(size_t num_threads)
  {
    std::call_once(init_flag(), [num_threads] { thread_count() = num_threads; });
  }
 
  static auto
  instance() -> PoolType&
  {
    static PoolType pool(thread_count());
    return pool;
  }
 
 
  template <typename F, typename... Args>
  static auto
  submit(F&& f, Args&&... args)
  {
    return instance().submit(std::forward<F>(f), std::forward<Args>(args)...);
  }
 
  template <typename F, typename... Args>
  static auto
  try_submit(F&& f, Args&&... args)
  {
    return instance().try_submit(std::forward<F>(f), std::forward<Args>(args)...);
  }
 
  template <typename F, typename... Args>
  static void
  post(F&& f, Args&&... args)
  {
    instance().post(std::forward<F>(f), std::forward<Args>(args)...);
  }
 
  template <typename F, typename... Args>
  static auto
  try_post(F&& f, Args&&... args)
  {
    return instance().try_post(std::forward<F>(f), std::forward<Args>(args)...);
  }
 
  template <typename Iterator>
  static auto
  submit_batch(Iterator begin, Iterator end)
  {
    return instance().submit_batch(begin, end);
  }
 
  template <typename Iterator>
  static auto
  try_submit_batch(Iterator begin, Iterator end)
  {
    return instance().try_submit_batch(begin, end);
  }
 
  template <typename Iterator, typename F>
  static void
  parallel_for_each(Iterator begin, Iterator end, F&& func)
  {
    instance().parallel_for_each(begin, end, std::forward<F>(func));
  }
 
 
private:
  global_pool_backend() = default;
 
  static auto
  init_flag() -> std::once_flag&
  {
    static std::once_flag flag;
    return flag;
  }
 
  static auto
  thread_count() -> size_t&
  {
    static size_t count = default_worker_count();
    return count;
  }
};
 
using global_thread_pool_backend = global_pool_backend<thread_pool_backend>;
 
using global_work_stealing_pool_backend = global_pool_backend<work_stealing_pool_backend>;
 
template <typename Container, typename F>
void
parallel_for_each(Container& container, F&& func)
{
  global_thread_pool_backend::parallel_for_each(container.begin(), container.end(), std::forward<F>(func));
}
 
} // namespace threadschedule::detail