并行验证谓词，线程池中的线程返回 true 时立即返回

Question

我想写一个函数anyElementSatisfiesPredicate，它接受一个谓词函数p的输入（它接受一个给定类型T的对象并返回一个布尔值）和一个std::vector v T 类型的对象，当且仅当它在 v s.t. 中存在一个元素时返回 true。 p(v) == true。

这可以通过 for 循环轻松完成：

bool anyElementSatisfiesPredicate(std::function<bool(T&)> p, std::vector<T> v) {
  for (auto it=v.begin(); it!=v.end(); ++it)
    if (p(*it))
      return true;
  return false;
}

这工作正常（给定正确定义的类型 T），但我想并行化此代码，同时在向量 v 的不同元素上测试谓词函数 p。我的想法是将工作分配给固定（取决于机器）数量的内核。每个线程都应该在原始向量的不同部分评估谓词，并在发现谓词 p 在其部分中的元素上成立时立即返回 true。一旦任何给定线程返回 true，核心函数 anyElementSatisfiesPredicate 应该杀死剩余的线程并返回 true，如果所有线程最终返回 false，它应该返回 false。

由于此代码将在具有不同内核数量的不同机器上运行，我不想引入任何定义要使用的内核数量的常量，我宁愿让系统为我选择最佳值。

效率是我最关心的问题。有没有简单的方法来完成这个（也许使用 boost 线程库）？

Answer 1

不是世界上最优雅的解决方案，但这样的解决方案应该可以工作：（没有提升，但需要 c++ 11）

#include <thread>
#include <atomic>

template <typename T>
struct pred_evaluator
{
    static void any_element_satisfies(const std::function<bool(const T&)> & pred, const typename std::vector<T>::iterator & begin, const typename std::vector<T>::iterator & end, std::atomic<bool> & result) 
    {
        for (const auto & it=begin; it!=end; ++it)
        {
            if (result || pred(*it))
            {
                result= true;
                return;
            }
       }
    }

    static bool is_predicate_true_parallel(const std::function<bool(const T&)> & pred, const std::vector<T> & input, size_t num_threads)
    {
        size_t chunk_size = input.size() / 4;
        std::atomic<bool> result(false);
        std::vector<std::thread> threads;
        for (size_t i = 0; i < num_threads; ++i)
        {
            const auto & begin = input.begin() + i *chunk_size;
            const auto & end = input.begin() + std::min((i+1) * chunk_size, input.size());
            threads.emplace_back(any_element_satisfies,pred,begin,end,result);
        }

        for (auto & thread : threads)
            thread.join();

        return result;
    }
};

然后，您将调用pred_evaluator<T>::is_predicate_true_parallel，并将您的谓词、向量和线程数作为输入。