線程無法影響性能

Question

下面是一個小程序，用於並行化1 /（n ^ 2）級數的逼近。 注意全局參數NUM_THREADS 。

我的問題是，將線程數從1增加到4（計算機擁有的處理器數量是4）不會顯着影響時序實驗的結果。 您是否在ThreadFunction看到邏輯缺陷？ 是否存在錯誤的共享或放錯位置的阻止，最終導致執行序列化？

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <string>
#include <future>
#include <chrono>

std::mutex sum_mutex;           // This mutex is for the sum vector
std::vector<double> sum_vec;    // This is the sum vector
int NUM_THREADS = 1;
int UPPER_BD = 1000000;

/* Thread function */
void ThreadFunction(std::vector<double> &l, int beg, int end, int thread_num)
{
    double sum = 0;
    for(int i = beg; i < end; i++) sum += (1 / ( l[i] * l[i]) );
    std::unique_lock<std::mutex> lock1 (sum_mutex, std::defer_lock);
    lock1.lock();
    sum_vec.push_back(sum);
    lock1.unlock();
}

void ListFill(std::vector<double> &l, int z)
{
    for(int i = 0; i < z; ++i) l.push_back(i);
}

int main() 
{
    std::vector<double> l;
    std::vector<std::thread> thread_vec;

    ListFill(l, UPPER_BD);
    int len = l.size();

    int lower_bd = 1;
    int increment = (UPPER_BD - lower_bd) / NUM_THREADS;
    for (int j = 0; j < NUM_THREADS; ++j)
    {
        thread_vec.push_back(std::thread(ThreadFunction, std::ref(l), lower_bd, lower_bd + increment, j));
        lower_bd += increment;
    }

    for (auto &t : thread_vec) t.join();
    double big_sum;
    for (double z : sum_vec) big_sum += z;

    std::cout << big_sum << std::endl;

    return 0;
}

Answer 1

通過查看您的代碼，我懷疑ListFill比ThreadFunction花費的時間更長。 為什么將值列表傳遞給線程，而不是將每個線程應循環通過的界限傳遞給線程？ 就像是：

void ThreadFunction( int beg, int end ) {
    double sum = 0.0;
    for(double i = beg; i < end; i++) 
         sum += (1.0 / ( i * i) );
    std::unique_lock<std::mutex> lock1 (sum_mutex);
    sum_vec.push_back(sum);
}

為了最大化並行性，您需要將盡可能多的工作推到線程上。 見阿姆達爾定律

Answer 2

除了dohashi的出色改進之外，您還可以通過預先在主線程中填充sum_vec來消除對互斥鎖的需要：

sum_vec.resize(4);

然后直接在ThreadFunction寫入：

sum_vec[thread_num] = sum;

由於每個線程都寫入一個不同的元素，並且不修改向量本身，因此無需鎖定任何內容。