c++ - 每个线程的理想任务时间？

Question

我想调查根据任务大小，与单线程相比，使用多线程完成任务的速度有多快

我画了一个图表显示:

• x_axis:单线程完成任务的速度。
• y 轴:同一任务在两个线程上完成的速度有多快。

我期望发生的事情:

• 如果任务变长，创建线程的开销就变得不那么重要了。所以比率 (t_single/t_multi) 增加了
• 因为我使用了两个线程，所以我会将比率 (t_single/t_multi) 收敛到 2(两个线程 => 是一个线程的两倍)

我得到的:

• 在 10e-2 秒的单线程任务时间达到峰值
• 峰值为 2.5(多线程比单线程快 2.5 倍)

这怎么解释？

该图是用超过 10 次测量的平均值创建的。我在 24 核 linux 机器上运行它。

代码:

#include <string>
#include <iostream>
#include <thread>
#include <vector>
#include <ctime>
#include <math.h>
#include <chrono>

using namespace std;
using namespace std::chrono;

// function searches through vector and adds 1
// to the first element that equals 0
void task(int number)
{
    int s = 0;
    for(int i=0; i<number; i++){
        s = s + i;
    }
    // cout << "the sum is " << s << endl;
}

double get_time_single(int m){

    // init
    int n_threads = 2;
    int n = pow(10, m);

    high_resolution_clock::time_point start = high_resolution_clock::now();

    for(int jobs = 0; jobs < n_threads; jobs++){
        task(n);
    }

    high_resolution_clock::time_point end = high_resolution_clock::now();
    double time_single = duration<double, std::milli>(end - start).count();

    return time_single;
}

double get_time_multi(int m){

    // init
    int n_threads = 2;
    int n = pow(10, m);
    vector<thread> threads;

    high_resolution_clock::time_point start = high_resolution_clock::now();

        // execute threads
        for( int i = 1; i < n_threads + 1; i++ ){
            threads.push_back(thread(task, n));
        }

        // joint threads
        for( int i = 0; i < n_threads; i++ ){
            threads.at(i).join();
        }

        high_resolution_clock::time_point end = high_resolution_clock::now();
        double time_multi = duration<double, std::milli>(end - start).count();

    return time_multi;
}


int main()
{

    // print header of magnitude - multi-proc-time - single-proc-time table
    cout << "mag" << "\t" << "time multi" << "  \t" << "time single" << endl;
    cout << "-------------------------------------" << endl;

    // iterate through different task magnitudes
    for(int m = 3; m<10; m++){

        double t_single = 0;
        double t_multi  = 0;

        // get the mean over 10 runs
        for(int i = 0; i < 10; i++){
            t_multi = t_multi + get_time_multi(m);
            t_single = t_single + get_time_single(m);
        }

        t_multi = t_multi / 10;
        t_single = t_single / 10;

        cout << m << "\t" << t_multi << "  \t" << t_single << endl;

    }
}

输出:

mag     time multi      time single
-------------------------------------
3       0.133946        0.0082684
4       0.0666891       0.0393378
5       0.30651         0.681517
6       1.92084         5.19607
7       18.8701         41.1431
8       195.002         381.745
9       1866.32         3606.08

Answer 1

那么，当您的任务在 5 毫秒内完成时，您是否获得了 MT 的最高性能？在 Linux 中，最大。时间片是sysctl_sched_latency，一般是6ms，可能有关系。

关于您的设置的更多信息。

在进行微基准测试时，人们通常使用最快的值，而不是平均值。

另外，用 C++ 编写这些外部循环也是个坏主意，因为 CPU 缓存(数据缓存和微操作缓存)。更好的是，在命令行参数中传递参数，编写脚本多次调用您的应用程序并在某处收集结果。

更新:一般来说，理想的每个线程任务时间是在始终使用所有 CPU 内核并满足其他要求(例如延迟)的情况下您可以承受的最长时间。