thread.h

Go to the documentation of this file.

#pragma once
 
#include <BS_thread_pool.hpp>
#include <cstddef>
#include <optional>
#include <thread>
 
namespace clustering::math {

inline std::size_t clampedJobCount(std::size_t nJobs) noexcept {
  if (nJobs == 0) {
    const std::size_t hw = std::thread::hardware_concurrency();
    return hw == 0 ? std::size_t{1} : hw;
  }
  return nJobs;
}

inline bool shouldSpawnPool(std::size_t totalOps, std::size_t nJobs,
                            std::size_t minOpsPerWorker = std::size_t{1} << 15) noexcept {
  if (nJobs <= 1) {
    return false;
  }
  return (totalOps / nJobs) >= minOpsPerWorker;
}

struct Pool {
  BS::light_thread_pool *pool = nullptr;

  [[nodiscard]] std::size_t workerCount() const noexcept {
    return (pool != nullptr) ? pool->get_thread_count() : std::size_t{1};
  }

  [[nodiscard]] static std::size_t workerIndex() noexcept {
    return BS::this_thread::get_index().value_or(std::size_t{0});
  }

  [[nodiscard]] bool shouldParallelize(std::size_t totalWork, std::size_t minChunk,
                                       std::size_t minTasksPerWorker = 2) const noexcept {
    if (pool == nullptr || minChunk == 0) {
      return false;
    }
    return (totalWork / minChunk) >= (workerCount() * minTasksPerWorker);
  }

  [[nodiscard]] bool shouldParallelizeWork(std::size_t totalOps,
                                           std::size_t minOpsPerWorker = std::size_t{1}
                                                                         << 15) const noexcept {
    if (pool == nullptr) {
      return false;
    }
    return (totalOps / workerCount()) >= minOpsPerWorker;
  }
};
 
} // namespace clustering::math