C 17 并行算法是否已经实现？

Question

我试图使用 C++17 标准中提出的新并行库功能，但我无法让它工作。 I tried compiling with the up-to-date versions of g++ 8.1.1 and clang++-6.0 and -std=c++17 , but neither seemed to support #include <execution> , std::execution::par 或类似的东西。

在查看并行算法的 cppreference 时，有一长串算法，声称

技术规范从 algorithm 、 numeric 和 memory 中提供了以下 69 种算法的并行版本： （…长列表…）

听起来算法已经 “在纸上” 准备好了，但还没有准备好使用？

在一年多前的 这个 SO 问题 中，答案声称这些功能尚未实现。但到现在为止，我预计会看到某种实现。有什么我们可以使用的吗？

原文由 Romeo Valentin 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

您可以参考 https://en.cppreference.com/w/cpp/compiler_support 查看所有 C++ 功能实现状态。对于您的情况，只需搜索“ Standardization of Parallelism TS ”，您会发现只有 MSVC 和 Intel C++ 编译器现在支持此功能。

原文由 Nan Xiao 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

GCC 9 有它们，但你必须单独安装 TBB

在 Ubuntu 19.10 中，所有组件终于对齐：

• GCC 9 是默认 版本，也是 TBB 所需的最低版本
• TBB（Intel Thread Building Blocks）在2019~U8-1，所以满足2018的最低要求

所以你可以简单地做：

 sudo apt install gcc libtbb-dev
g++ -ggdb3 -O3 -std=c++17 -Wall -Wextra -pedantic -o main.out main.cpp -ltbb
./main.out

并用作：

 #include <execution>
#include <algorithm>

std::sort(std::execution::par_unseq, input.begin(), input.end());

另请参阅下面的完整可运行基准。

GCC 9 和 TBB 2018 是第一个工作的版本，如发行说明中所述： https ://gcc.gnu.org/gcc-9/changes.html

并行算法和 <execution> （需要 Thread Building Blocks 2018 或更高版本）。

相关话题：

• 如何在 Linux 上从源代码安装 TBB 并使其工作
• 链接 INTEL tbb 库的问题

Ubuntu 18.04 安装

Ubuntu 18.04 涉及更多：

• GCC 9 可以从值得信赖的 PPA 获得，所以还不错
• TBB 是 2017 版本，它不起作用，我找不到值得信赖的 PPA。从源代码编译很容易，但是没有烦人的安装目标…

以下是 Ubuntu 18.04 的全自动测试命令：

 # Install GCC 9
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install gcc-9 g++-9

# Compile libtbb from source.
sudo apt-get build-dep libtbb-dev
git clone https://github.com/intel/tbb
cd tbb
git checkout 2019_U9
make -j `nproc`
TBB="$(pwd)"
TBB_RELEASE="${TBB}/build/linux_intel64_gcc_cc7.4.0_libc2.27_kernel4.15.0_release"

# Use them to compile our test program.
g++-9 -ggdb3 -O3 -std=c++17 -Wall -Wextra -pedantic -I "${TBB}/include" -L
"${TBB_RELEASE}" -Wl,-rpath,"${TBB_RELEASE}" -o main.out main.cpp -ltbb
./main.out

测试程序分析

我已经用这个比较并行和串行排序速度的程序进行了测试。

主文件

#include <algorithm>
#include <cassert>
#include <chrono>
#include <execution>
#include <random>
#include <iostream>
#include <vector>

int main(int argc, char **argv) {
    using clk = std::chrono::high_resolution_clock;
    decltype(clk::now()) start, end;
    std::vector<unsigned long long> input_parallel, input_serial;
    unsigned int seed;
    unsigned long long n;

    // CLI arguments;
    std::uniform_int_distribution<uint64_t> zero_ull_max(0);
    if (argc > 1) {
        n = std::strtoll(argv[1], NULL, 0);
    } else {
        n = 10;
    }
    if (argc > 2) {
        seed = std::stoi(argv[2]);
    } else {
        seed = std::random_device()();
    }

    std::mt19937 prng(seed);
    for (unsigned long long i = 0; i < n; ++i) {
        input_parallel.push_back(zero_ull_max(prng));
    }
    input_serial = input_parallel;

    // Sort and time parallel.
    start = clk::now();
    std::sort(std::execution::par_unseq, input_parallel.begin(), input_parallel.end());
    end = clk::now();
    std::cout << "parallel " << std::chrono::duration<float>(end - start).count() << " s" << std::endl;

    // Sort and time serial.
    start = clk::now();
    std::sort(std::execution::seq, input_serial.begin(), input_serial.end());
    end = clk::now();
    std::cout << "serial " << std::chrono::duration<float>(end - start).count() << " s" << std::endl;

    assert(input_parallel == input_serial);
}

在 Ubuntu 19.10 上，带有 CPU 的 Lenovo ThinkPad P51 笔记本电脑：Intel Core i7-7820HQ CPU（4 核 / 8 线程，2.90 GHz 基础，8 MB 缓存），RAM：2x Samsung M471A2K43BB1-CRC（2x 16GiB，2400 Mbps）典型输出对于要排序的 1 亿个数字的输入：

 ./main.out 100000000

曾是：

 parallel 2.00886 s
serial 9.37583 s

所以并行版本快了大约 4.5 倍！另请参阅： 术语“CPU 限制”和“I/O 限制”是什么意思？

我们可以通过 strace 确认该进程正在生成线程：

 strace -f -s999 -v ./main.out 100000000 |& grep -E 'clone'

它显示了几行类型：

 [pid 25774] clone(strace: Process 25788 attached
[pid 25774] <... clone resumed> child_stack=0x7fd8c57f4fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fd8c57f59d0, tls=0x7fd8c57f5700, child_tidptr=0x7fd8c57f59d0) = 25788

另外，如果我注释掉串行版本并运行：

 time ./main.out 100000000

我得到：

 real    0m5.135s
user    0m17.824s
sys     0m0.902s

这 再次证实了该算法自 real < user 以来是并行化的，并给出了它在我的系统中并行化的效率（大约 8 核的 3.5 倍）。

错误信息

谷歌，请索引这个。

如果您没有安装 tbb，则错误是：

 In file included from /usr/include/c++/9/pstl/parallel_backend.h:14,
                 from /usr/include/c++/9/pstl/algorithm_impl.h:25,
                 from /usr/include/c++/9/pstl/glue_execution_defs.h:52,
                 from /usr/include/c++/9/execution:32,
                 from parallel_sort.cpp:4:
/usr/include/c++/9/pstl/parallel_backend_tbb.h:19:10: fatal error: tbb/blocked_range.h: No such file or directory
   19 | #include <tbb/blocked_range.h>
      |          ^~~~~~~~~~~~~~~~~~~~~
compilation terminated.

所以我们看到 <execution> 依赖于一个未安装的 TBB 组件。

如果 TBB 太旧，例如默认的 Ubuntu 18.04，它会失败并显示：

 #error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.

原文由 Ciro Santilli OurBigBook.com 发布，翻译遵循 CC BY-SA 4.0 许可协议