多线程减慢程序：没有错误共享，没有互斥体，没有缓存未命中，没有小的工作量

Question

尽管我关注了这些帖子，但多线程会减慢我的代码速度：

Multi-threaded GEMM slower than single threaded one?

Why is this OpenMP program slower than single-thread?

---

我认为所有的预防措施都得到了照顾：

1. 我的 CPU 是 4 核 + 超线程（8 个有效），我运行的线程不超过 4 个

2. 每个线程处理的向量条目数似乎足够大（每个线程 200 万个）。 因此任何错误共享（缓存行问题）都可以忽略，因为大多数数据不会与其他线程的数据重叠。

3. 内存中的条目是连续的，缓存未命中的可能性很小。

4. 使用tmp 变量进行连续操作，而不是直接将值分配到数组中。

5. 在发布模式下构建，Visual Studio

6. 线程之间没有临界点（它们不使用互斥体，也不共享数据）

在测量时间时，我包括创建一个线程。当然，启动 4 个线程不会那么昂贵？

1 个线程：大约 140 毫秒

4 个线程：大约 155 毫秒

主要：

struct MyStruct {
   double val = 0;
};


size_t numEntries = 100e4;
size_t numThreads = 4;
std::vector<MyStruct> arr;


void main(){
    arr.reserve(numEntries);
    for(size_t i=0; i<numEntries; ++i){
        MyStruct m{ i };
        arr.push_back(m);
    }

    //run several times 
    float avgTime=0;
    for(size_t n=0; n<100; ++n){
        launchThreads(avgTime);
        //space out to make avgTime more even:
        std::this_thread::sleep_for(std::chrono::milliseconds(10));

    }

    avgTime /= 100;

    std::cout << "finished in " << avgTime <<"milliseconds\n";
    system("pause");
}

启动和运行线程：

//ran by each thread
void threadWork(size_t threadId){
    size_t numPerThread = (numEntries+numThreads -1) / numThreads;

    size_t start_ix = threadId * numPerThread;

    size_t endIx;
    if (threadId == numThreads - 1) {
        endIx = numEntries-1;//we are the last thread
    }
    else {
        endIx = start_ix + numPerThread;
    }

    for(size_t i=5; i<endIx-5; ++i){
        double tmp = arr[i].val; 

        tmp += arr[i-1].val;
        tmp += arr[i-3].val;
        tmp += arr[i-4].val;
        tmp += arr[i-5].val;
        tmp += arr[i-2].val;

        tmp += arr[i+1].val;
        tmp += arr[i+3].val;
        tmp += arr[i+4].val;
        tmp += arr[i+5].val;
        tmp += arr[i+2].val;

        if(tmp > 0){ tmp *= 0.5f;}
        else{ tmp *= 0.3f; }

        arr[i].val = tmp;
    }
}//end()


//measures time
void launchThreads(float &avgTime){

    using namespace std::chrono;
    typedef std::chrono::milliseconds ms;

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

    std::vector<std::thread> threads;
    for (int i = 0; i <numThreads; ++i) {
        std::thread t = std::thread(threadWork, i);
        threads.push_back(std::move(t));
    }

    for (size_t i = 0; i < numThreads; ++i) {
        threads[i].join();
    }
    high_resolution_clock::time_point t2 = high_resolution_clock::now();
    ms timespan = duration_cast<ms>(t2 - t1);
    avgTime += timespan.count();
}

Answer 1

以下是你的问题：

for(size_t i=5; i<endIx-5; ++i){
           ^^^

应该是：

for(size_t i=start_ix + 5; i<endIx-5; ++i){
           ^^^^^^^^^^^^^^