parallel.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>  // for std::min
#include <cmath>  // for std::ceil
#include <future>
#include <iterator>
#include <numeric>  // for std::accumulate (in reduce example)
#include <stdexcept>  // for exceptions
#include <vector>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
 
#include "cpp-toolbox/base/thread_pool_singleton.hpp"  // 需要线程池/Thread pool required
 
namespace toolbox::concurrent
{
 
inline base::thread_pool_singleton_t& default_pool()
{
  return base::thread_pool_singleton_t::instance();
}
 
//--------------------------------------------------------------------------
// parallel_for_each
//--------------------------------------------------------------------------
 
template<typename Iterator, typename Function>
CPP_TOOLBOX_EXPORT void parallel_for_each(Iterator begin,
                                          Iterator end,
                                          Function func);
 
template<typename T, typename Alloc, typename Function>
CPP_TOOLBOX_EXPORT void parallel_for_each(std::vector<T, Alloc>& vec,
                                          Function func)
{
  parallel_for_each(vec.begin(), vec.end(), std::move(func));
}
 
template<typename T, typename Alloc, typename Function>
CPP_TOOLBOX_EXPORT void parallel_for_each(const std::vector<T, Alloc>& vec,
                                          Function func)
{
  parallel_for_each(vec.cbegin(), vec.cend(), std::move(func));
}
 
template<typename T, size_t N, typename Function>
CPP_TOOLBOX_EXPORT void parallel_for_each(std::array<T, N>& arr, Function func)
{
  parallel_for_each(arr.begin(), arr.end(), std::move(func));
}
 
template<typename T, size_t N, typename Function>
CPP_TOOLBOX_EXPORT void parallel_for_each(const std::array<T, N>& arr,
                                          Function func)
{
  parallel_for_each(arr.cbegin(), arr.cend(), std::move(func));
}
 
//--------------------------------------------------------------------------
// parallel_transform
//--------------------------------------------------------------------------
 
template<typename InputIt, typename OutputIt, typename UnaryOperation>
CPP_TOOLBOX_EXPORT void parallel_transform(InputIt first1,
                                           InputIt last1,
                                           OutputIt d_first,
                                           UnaryOperation unary_op);
 
template<typename T, typename Alloc, typename Function>
CPP_TOOLBOX_EXPORT void parallel_transform(std::vector<T, Alloc>& vec,
                                           Function func)
{
  parallel_transform(vec.begin(), vec.end(), std::move(func));
}
 
template<typename T, typename Alloc, typename Function>
CPP_TOOLBOX_EXPORT void parallel_transform(const std::vector<T, Alloc>& vec,
                                           Function func)
{
  parallel_transform(vec.cbegin(), vec.cend(), std::move(func));
}
 
template<typename T, size_t N, typename Function>
CPP_TOOLBOX_EXPORT void parallel_transform(std::array<T, N>& arr, Function func)
{
  parallel_transform(arr.begin(), arr.end(), std::move(func));
}
 
template<typename T, size_t N, typename Function>
CPP_TOOLBOX_EXPORT void parallel_transform(const std::array<T, N>& arr,
                                           Function func)
{
  parallel_transform(arr.cbegin(), arr.cend(), std::move(func));
}
 
//--------------------------------------------------------------------------
// parallel_reduce
//--------------------------------------------------------------------------
 
template<typename Iterator, typename T, typename BinaryOperation>
CPP_TOOLBOX_EXPORT T parallel_reduce(Iterator begin,
                                     Iterator end,
                                     T identity,
                                     BinaryOperation reduce_op);
 
template<typename T, typename Alloc, typename BinaryOperation>
CPP_TOOLBOX_EXPORT T parallel_reduce(std::vector<T, Alloc>& vec,
                                     T identity,
                                     BinaryOperation reduce_op)
{
  return parallel_reduce(
      vec.begin(), vec.end(), identity, std::move(reduce_op));
}
 
template<typename T, typename Alloc, typename BinaryOperation>
CPP_TOOLBOX_EXPORT T parallel_reduce(const std::vector<T, Alloc>& vec,
                                     T identity,
                                     BinaryOperation reduce_op)
{
  return parallel_reduce(
      vec.cbegin(), vec.cend(), identity, std::move(reduce_op));
}
 
template<typename T, size_t N, typename BinaryOperation>
CPP_TOOLBOX_EXPORT T parallel_reduce(std::array<T, N>& arr,
                                     T identity,
                                     BinaryOperation reduce_op)
{
  return parallel_reduce(
      arr.begin(), arr.end(), identity, std::move(reduce_op));
}
 
template<typename T, size_t N, typename BinaryOperation>
CPP_TOOLBOX_EXPORT T parallel_reduce(const std::array<T, N>& arr,
                                     T identity,
                                     BinaryOperation reduce_op)
{
  return parallel_reduce(
      arr.cbegin(), arr.cend(), identity, std::move(reduce_op));
}
 
//--------------------------------------------------------------------------
// parallel_inclusive_scan
//--------------------------------------------------------------------------
 
template<typename InputIt,
         typename OutputIt,
         typename T,
         typename BinaryOperation>
CPP_TOOLBOX_EXPORT void parallel_inclusive_scan(InputIt first,
                                                InputIt last,
                                                OutputIt d_first,
                                                T init,
                                                BinaryOperation binary_op,
                                                T identity = T {});
 
template<typename T, typename Alloc, typename BinaryOperation>
CPP_TOOLBOX_EXPORT void parallel_inclusive_scan(
    const std::vector<T, Alloc>& input,
    std::vector<T, Alloc>& out,
    T init,
    BinaryOperation binary_op,
    T identity = T {})
{
  if (out.size() < input.size()) {
    out.resize(input.size());
  }
  parallel_inclusive_scan(input.cbegin(),
                          input.cend(),
                          out.begin(),
                          init,
                          std::move(binary_op),
                          identity);
}
 
//--------------------------------------------------------------------------
// parallel_merge_sort
//--------------------------------------------------------------------------
 
template<typename RandomIt, typename Compare = std::less<>>
CPP_TOOLBOX_EXPORT void parallel_merge_sort(RandomIt begin,
                                            RandomIt end,
                                            Compare comp = Compare());
 
//--------------------------------------------------------------------------
// parallel_tim_sort
//--------------------------------------------------------------------------
 
template<typename RandomIt, typename Compare = std::less<>>
CPP_TOOLBOX_EXPORT void parallel_tim_sort(RandomIt begin,
                                          RandomIt end,
                                          Compare comp = Compare());
 
}  // namespace toolbox::concurrent
 
// 包含实现文件
#if defined(CPP_TOOLBOX_USE_TBB)
#  include "impl/parallel_tbb.hpp"
#else
#  include "impl/parallel_raw.hpp"
#endif