【问题标题】:Why multi-threaded code runs slower on faster machines?为什么多线程代码在更快的机器上运行得更慢?
【发布时间】:2018-12-25 16:03:56
【问题描述】:

考虑以下 c++ 代码:

#include "threadpool.hpp"
#include <chrono>
#include <list>
#include <iostream>
#include <cmath>

int loop_size;

void process(int num) {
    double x = 0;
    double sum = 0;
    for(int i = 0; i < loop_size; ++i) {
        x += 0.0001;
        sum += sin(x) / cos(x) + cos(x) * cos(x);
    }
}

int main(int argc, char* argv[]) {
    if(argc < 3) {
        std::cerr << argv[0] << " [thread_pool_size] [threads] [sleep_time]" << std::endl;
        exit(0);
    }
    thread_pool* pool = nullptr;
    int th_count = std::atoi(argv[1]);
    if(th_count != 0) {
        pool = new thread_pool(th_count);
    }
    loop_size = std::stoi(argv[3]);
    int max = std::stoi(argv[2]);
    auto then = std::chrono::steady_clock::now();
    std::list<std::thread> ths;
    if(th_count == 0) {
        for(int i = 0; i < max; ++i) {
            ths.emplace_back(&process, i);
        }
        for(std::thread& t : ths) {
            t.join();
        }
    } else {
        for(int i = 0; i < max; ++i) {
            pool->enqueue(std::bind(&process, i));
        }
        delete pool;
    }
    int diff = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - then).count();
    std::cerr << "Time: " << diff << '\n';
    return 0;
}

"threadpool.hpp"this github repo 的修改版,可以使用here

我在我的机器 (Corei7-6700) 和 88 核服务器 (2x Xeon E5-2696 v4) 上编译了上述代码。结果我无法解释。

这就是我运行代码的方式:

tp <threadpool size> <number of threads> <iterations>

同样的代码在更快的机器上运行得更慢!我的本地机器上有 8 个核心,远程服务器上有 88 个核心,这些是结果:(最后两列表示每台机器上的平均完成时间(以毫秒为单位)

+============+=========+============+=============+====================+
| Threadpool | Threads | Iterations | Corei7-6700 | 2x Xeon E5-2696 v4 |
+============+=========+============+=============+====================+
|        100 |  100000 |       1000 |        1300 |               6000 |
+------------+---------+------------+-------------+--------------------+
|       1000 |  100000 |       1000 |        1400 |               5000 |
+------------+---------+------------+-------------+--------------------+
|      10000 |  100000 |       1000 |        1470 |               3400 |
+------------+---------+------------+-------------+--------------------+

似乎拥有更多内核会使代码运行速度变慢。所以我将服务器 (taskset) 上的 CPU 亲和性降低到 8 个内核并再次运行代码:

taskset 0-7 tp <threadpool size> <number of threads> <iterations>

这是新数据:

+============+=========+============+=============+====================+
| Threadpool | Threads | Iterations | Corei7-6700 | 2x Xeon E5-2696 v4 |
+============+=========+============+=============+====================+
|        100 |  100000 |       1000 |        1300 |                900 |
+------------+---------+------------+-------------+--------------------+
|       1000 |  100000 |       1000 |        1400 |               1000 |
+------------+---------+------------+-------------+--------------------+
|      10000 |  100000 |       1000 |        1470 |               1070 |
+------------+---------+------------+-------------+--------------------+

我在 32 核 Xeon 和 22 核旧 Xeon 机器上测试了相同的代码,模式相似:内核越少,多线程代码运行速度越快。但为什么呢?

重要提示:这是为了解决我原来的问题:

Why having more and faster cores makes my multithreaded software slower?

注意事项:

  1. 所有机器上的操作系统和编译器都相同:debian 9.0 amd64 running kernel 4.0.9-3, 6.3.0 20170516
  2. 没有额外的flasg,默认优化:g++ ./threadpool.cpp -o ./tp -lpthread

【问题讨论】:

  • 未优化程序的测速有何意义?
  • 您的“进程”似乎是编译器可以完全优化掉的代码。
  • 哦,2x Xeon 将是 NUMA,这意味着您将在 QPI 上处理该互斥体。看看如果你numactl -m 0 -N 0(或类似的)将你的线程限制在单个物理套接字并且它是附加内存会发生什么
  • 是的,理想情况下线程数与内核数相似,否则您只是在调度程序中花费额外的时间而没有任何好处。
  • Relevant discussion @Useless 点

标签: c++ multithreading scheduling


【解决方案1】:

一般来说,对于像这样受 CPU 限制的代码,您不应期望在池中运行的线程多于执行它们的内核数会带来任何好处。

例如,将池与 N 核套接字的 1, 2, ... N/2 ... N ... N*2 线程进行比较可能会很有趣。具有 10*N 个线程的池实际上只是在测试调度程序在负载下的行为。

然后,一般来说,您还需要了解每个任务的开销:您将工作分成的任务越多,创建、销毁和同步对这些任务的访问所花费的时间就越多。为固定的工作量改变子任务的大小是一种很好的观察方式。

最后,了解您正在使用的物理架构会有所帮助。 NUMA 服务器平台使用其两个插槽可以完成的工作量正好是同一个 CPU 单独可以完成的工作量的两倍 - 如果每个插槽访问它自己的直接连接的内存。一旦您通过 QPI 传输数据,性能就会下降。在 QPI 上反弹一个竞争激烈的高速缓存行,比如你的互斥体,可能会减慢整个过程。

同样,如果您有 N 个内核并希望在池中运行 N 个线程 - 您知道它们是物理内核还是超线程逻辑内核?如果它们是 HT,您是否知道您的线程是否能够全速运行,或者它们是否会争夺有限的共享资源?

【讨论】:

【解决方案2】:

您正在将大量工作人员排入线程池,这需要很少的时间来执行。因此,线程池的实现(不是实际工作),特别是它的互斥体处理争用的方式会成为瓶颈。我尝试用folly::CPUThreadPoolExecutor 替换thread_pool,这很有帮助:

thread_pool version:
2180 ms | thread_pool_size=100   num_workers=100000 loop_size=1000 affinity=0-23
2270 ms | thread_pool_size=1000  num_workers=100000 loop_size=1000 affinity=0-23
2400 ms | thread_pool_size=10000 num_workers=100000 loop_size=1000 affinity=0-23
 530 ms | thread_pool_size=100   num_workers=100000 loop_size=1000 affinity=0-7
1930 ms | thread_pool_size=1000  num_workers=100000 loop_size=1000 affinity=0-7
2300 ms | thread_pool_size=10000 num_workers=100000 loop_size=1000 affinity=0-7
folly::CPUThreadPoolExecutor version:
 830 ms | thread_pool_size=100   num_workers=100000 loop_size=1000 affinity=0-23
 780 ms | thread_pool_size=1000  num_workers=100000 loop_size=1000 affinity=0-23
 800 ms | thread_pool_size=10000 num_workers=100000 loop_size=1000 affinity=0-23
 880 ms | thread_pool_size=100   num_workers=100000 loop_size=1000 affinity=0-7
1130 ms | thread_pool_size=1000  num_workers=100000 loop_size=1000 affinity=0-7
1120 ms | thread_pool_size=10000 num_workers=100000 loop_size=1000 affinity=0-7

我建议您(1) 在每个线程中做更多的工作; (2) 使用与 CPU 一样多的线程; (3) 使用更好的线程池。 让我们将thread_pool_size 设置为CPU 的数量,然后将loop_size 乘以10:

thread_pool version:
1880 ms | thread_pool_size=24 num_workers=100000 loop_size=10000 affinity=0-23
4100 ms | thread_pool_size=8  num_workers=100000 loop_size=10000 affinity=0-7
folly::CPUThreadPoolExecutor version:
1520 ms | thread_pool_size=24 num_workers=100000 loop_size=10000 affinity=0-23
2310 ms | thread_pool_size=8  num_workers=100000 loop_size=10000 affinity=0-7

请注意,通过将每个线程的工作量增加 10 倍,我们实际上使thread_pool 版本更快,而folly::CPUThreadPoolExecutor 版本只花费了 2 倍的时间。让我们将loop_size 再乘以 10 倍:

thread_pool version:
28695 ms | thread_pool_size=24 num_workers=100000 loop_size=100000 affinity=0-23
81600 ms | thread_pool_size=8  num_workers=100000 loop_size=100000 affinity=0-7
folly::CPUThreadPoolExecutor version:
 6830 ms | thread_pool_size=24 num_workers=100000 loop_size=100000 affinity=0-23
14400 ms | thread_pool_size=8  num_workers=100000 loop_size=100000 affinity=0-7

对于folly::CPUThreadPoolExecutor,结果不言自明:在每个线程中做更多的工作让您更接近真正从并行性中获得的线性收益。而thread_pool 似乎无法胜任这项任务;它无法正确处理这种规模的互斥争用。

这是我用来测试的代码(用gcc 5.5编译,完全优化):

#include <chrono>
#include <cmath>
#include <iostream>
#include <memory>
#include <vector>

#define USE_FOLLY 1

#if USE_FOLLY
#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/futures/Future.h>
#else
#include "threadpool.hpp"
#endif

int loop_size;
thread_local double dummy = 0.0;

void process(int num) {
  double x = 0;
  double sum = 0;
  for (int i = 0; i < loop_size; ++i) {
    x += 0.0001;
    sum += sin(x) / cos(x) + cos(x) * cos(x);
  }
  dummy += sum; // prevent optimization
}

int main(int argc, char* argv[]) {
  if (argc < 3) {
    std::cerr << argv[0] << " [thread_pool_size] [threads] [sleep_time]"
              << std::endl;
    exit(0);
  }
  int th_count = std::atoi(argv[1]);
#if USE_FOLLY
  auto executor = std::make_unique<folly::CPUThreadPoolExecutor>(th_count);
#else
  auto pool = std::make_unique<thread_pool>(th_count);
#endif
  loop_size = std::stoi(argv[3]);
  int max = std::stoi(argv[2]);

  auto then = std::chrono::steady_clock::now();
#if USE_FOLLY
  std::vector<folly::Future<folly::Unit>> futs;
  for (int i = 0; i < max; ++i) {
    futs.emplace_back(folly::via(executor.get()).then([i]() { process(i); }));
  }
  folly::collectAll(futs).get();
#else
  for (int i = 0; i < max; ++i) {
    pool->enqueue([i]() { process(i); });
  }
  pool = nullptr;
#endif

  int diff = std::chrono::duration_cast<std::chrono::milliseconds>(
                 std::chrono::steady_clock::now() - then)
                 .count();
  std::cerr << "Time: " << diff << '\n';
  return 0;
}

【讨论】:

    猜你喜欢
    • 2023-03-15
    • 2012-02-13
    • 2012-06-29
    • 1970-01-01
    • 2019-01-31
    相关资源
    最近更新 更多