C++11 async 只使用一个核心

Question

我正在尝试在 C++ 中并行化一个长时间运行的函数并使用 std::async 它只使用一个核心。

不是函数的运行时间太短，因为我目前使用的测试数据需要大约 10 分钟才能运行。

根据我的逻辑，我创建了 NThreads 的 Futures(每个 Futures 都占据循环的一部分而不是一个单独的单元格，因此它是一个很好的长时间运行的线程)，每个都将分派(dispatch)一个异步任务。然后在它们被创建之后，程序自旋锁等待它们完成。然而它总是使用一个核心？!

这也不是我看顶部并说它看起来大致像一个 CPU，我的 ZSH 配置输出最后一个命令的 CPU %，它总是正好 100%，从不超过

auto NThreads = 12;
auto BlockSize = (int)std::ceil((int)(NThreads / PathCountLength));

std::vector<std::future<std::vector<unsigned __int128>>> Futures;

for (auto I = 0; I < NThreads; ++I) {
    std::cout << "HERE" << std::endl;
    unsigned __int128 Min = I * BlockSize;
    unsigned __int128 Max = I * BlockSize + BlockSize;

    if (I == NThreads - 1)
        Max = PathCountLength;

    Futures.push_back(std::async(
        [](unsigned __int128 WMin, unsigned __int128 Min, unsigned__int128 Max,
           std::vector<unsigned __int128> ZeroChildren,
           std::vector<unsigned __int128> OneChildren,
           unsigned __int128 PathCountLength)
           -> std::vector<unsigned __int128> {
           std::vector<unsigned __int128> LocalCount;
           for (unsigned __int128 I = Min; I < Max; ++I)
               LocalCount.push_back(KneeParallel::pathCountOrStatic(
                   WMin, I, ZeroChildren, OneChildren, PathCountLength));
          return LocalCount;
    },
    WMin, Min, Max, ZeroChildInit, OneChildInit, PathCountLength));
}

for (auto &Future : Futures) {
    Future.get();
}

有没有人有什么见解。

我在 Arch Linux 上使用 clang 和 LLVM 进行编译。是否有任何我需要的编译标志，但据我所知，C++11 标准化了线程库？

编辑:如果它能帮助任何人提供任何进一步的线索，当我注释掉它在所有内核上运行时它应该运行的本地 vector ，当我将它放回回滚到一个内核时。

编辑 2:所以我确定了解决方案，但它看起来很奇怪。从 lambda 函数返回 vector 将其固定到一个核心，所以现在我通过将 shared_ptr 传递到输出 vector 并对其进行操作来解决这个问题。嘿，很快，它在核心上启动了!

我认为现在使用 futures 毫无意义，因为我没有返回，我会改用线程，不!，使用具有没有返回的线程也使用一个核心。奇怪吧？

好吧，回到使用 future 的方式，只需返回一个扔掉的东西。是的，您猜对了，即使从线程返回一个 int 也会将程序粘在一个核心上。除了 future 不能有 void lambda 函数。因此，我的解决方案 是将一个指针传递给一个从不返回任何内容的 int lambda 函数，以存储输出。是的，感觉就像胶带，但我找不到更好的解决方案。

看起来很……奇怪？就像编译器以某种方式错误地解释了 lambda。会不会是因为我使用的是 LLVM 的开发版本而不是稳定的分支...？

无论如何我的解决方案，因为我最讨厌在这里找到我的问题却没有答案:

auto NThreads = 4;
auto BlockSize = (int)std::ceil((int)(NThreads / PathCountLength));

auto Futures = std::vector<std::future<int>>(NThreads);
auto OutputVectors =
    std::vector<std::shared_ptr<std::vector<unsigned __int128>>>(
        NThreads, std::make_shared<std::vector<unsigned __int128>>());

for (auto I = 0; I < NThreads; ++I) {
  unsigned __int128 Min = I * BlockSize;
  unsigned __int128 Max = I * BlockSize + BlockSize;

if (I == NThreads - 1)
  Max = PathCountLength;

Futures[I] = std::async(
  std::launch::async,
  [](unsigned __int128 WMin, unsigned __int128 Min, unsigned __int128 Max,
       std::vector<unsigned __int128> ZeroChildren,
       std::vector<unsigned __int128> OneChildren,
       unsigned __int128 PathCountLength,
       std::shared_ptr<std::vector<unsigned __int128>> OutputVector)
        -> int {
      for (unsigned __int128 I = Min; I < Max; ++I) {
        OutputVector->push_back(KneeParallel::pathCountOrStatic(
            WMin, I, ZeroChildren, OneChildren, PathCountLength));
      }
    },
    WMin, Min, Max, ZeroChildInit, OneChildInit, PathCountLength,
    OutputVectors[I]);
}

for (auto &Future : Futures) {
  Future.get();
}

Answer 1

通过为 async 提供第一个参数，您可以将其配置为延迟运行 (std::launch::deferred)，在其自己的线程中运行 (std::launch: :async)，或者让系统在两个选项之间做出决定 (std::launch::async | std::launch::deferred)。后者是默认行为。

因此，要强制它在另一个线程中运行，请将 std::async 的调用调整为 std::async(std::launch::async,/*.. .*/).