c++ - 如何在所有线程中同步一个变量的值？

Question

如果我有以下情况:

bool cond_var;

#pragma omp parallel shared(cond_var)
{
    bool some_private_var;
    // ...
    do {
       #pragma omp single
       {
           cond_var = true;
       }

       // do something, calculate some_private_var;
       // ...

       #pragma omp atomic update
       cond_var &= some_private_var;

       // Syncing step
       // (???)

    } while(cond_var);

    // ... (other parallel stuff)
}

我希望我的 do-while 循环对我的所有线程具有相同的迭代次数，但是当我尝试将 #pragma omp barrier 作为同步步骤时(就在循环结束之前) ，我以僵局告终。打印 cond_var 的值显示一些线程将其视为 true 而其他线程将其视为 false，因此循环完成了一些，留下了其他人僵持在屏障上。然后我尝试了 barrier 和 flush 的各种组合和顺序，但没有成功(通过某些组合，僵局被推迟了)。

如何在线程之间正确组合和同步循环条件，以便所有循环都具有相同的迭代次数？

更新

我还尝试使用 #pragma atomic read 将 cond_var 的值加载到另一个私有(private)变量，并测试该条件。它也没有用。显然，原子读取保证我有一个一致的值(旧的或新的)，但不保证它是最新的。

更新 2

基于代码 Jonathan Dursi 的代码，这是一个看起来更像我正在尝试的 MVCE做:

#include <omp.h>
#include <cstdio>
#include <random>
#include <chrono>
#include <thread>

int main() {

    bool cond_var;
    const int nthreads = omp_get_max_threads();

    #pragma omp parallel default(none) shared(cond_var)
    {
        bool some_private_var;
        std::random_device rd;
        std::mt19937 rng(rd());
        unsigned iter_count = 0;

        /* chance of having to end: 1 in 6**nthreads; all threads must choose 0 */
        std::uniform_int_distribution<int> dice(0,5);

        const int tid = omp_get_thread_num();
        printf("Thread %d started.\n", tid);
        do {
            ++iter_count;

            #pragma omp once shared(cond_var)
            {
                // cond_var must be reset to 'true' because it is the
                // neutral element of &
                // For the loop to end, all threads must choose the
                // same random value 0
                cond_var = true;
            }

            some_private_var = (dice(rng) == 0);

            // If all threads choose 0, cond_var will remain 'true', ending the loop
            #pragma omp atomic update
            cond_var &= some_private_var;

            #pragma omp barrier
        } while(!cond_var);
        printf("Thread %d finished with %u iterations.\n", tid, iter_count);
    }

    return 0;
}

在一台有足够逻辑内核同时运行所有线程的机器上运行 8 个线程，大多数运行死锁在第一次迭代中，尽管有一个运行在第二次迭代中正确完成(不符合 1 in 的机会1679616 (6**8) 所有线程都选择 0)。

Answer 1

问题在于，在 while 循环中，您正在更新 cond_var 两次并第三次使用它，您需要确保这些操作不会相互干扰。每次循环迭代，代码:

1. 设置 cond_var = true(使用不存在的 OpenMP pragma，“一次”，它被忽略并被每个线程完成)
2. 通过使用本地条件变量 &ing 更新 cond_var；
3. 使用 updated-by-everyone cond_var 来测试是否退出循环。

因此，需要确保一个线程没有将 cond_var 设置为真 (1) 而其他线程正在设置它 (2)；在使用它测试循环外 (3) 时，没有线程仍在运行 (2)；并且没有线程正在测试它 (3) 而线程正在将它设置为 true (1)。

做到这一点的明显方法是设置障碍，在这三种情况中的每一种之间设置障碍 - 所以是三个障碍。所以这有效:

#include <omp.h>
#include <random>
#include <chrono>
#include <thread>
#include <iostream>

int main() {

    bool cond_var;

    #pragma omp parallel default(none) shared(cond_var,std::cout)
    {
        bool some_private_var;
        std::random_device rd;
        std::mt19937 rng(rd());
        unsigned iter_count = 0;

        std::uniform_int_distribution<int> dice(0,1);

        const int tid = omp_get_thread_num();
        printf("Thread %d started.\n", tid);
        do {
            ++iter_count;

            #pragma omp barrier
            #pragma omp single 
            cond_var = true;
            // implicit barrier here after the single; turned off with a nowait clause.

            some_private_var = (dice(rng) == 0);

            // If all threads choose 0, cond_var will remain 'true', ending the loop
            #pragma omp atomic update
            cond_var &= some_private_var;

            #pragma omp barrier
        } while(!cond_var);

        #pragma omp critical
        std::cout << "Thread " << tid << " finished with " << iter_count << " iterations." << std::endl;
    }

    return 0;
}

你可以做得更好一点，让每个线程只在共享数组中设置一个局部变量，然后让一个线程执行与操作；所以你仍然需要两个障碍，一个是确保每个人都在安定之前完成，另一个是确保在测试完成之前完成安定:

#include <omp.h>
#include <random>
#include <chrono>
#include <thread>
#include <iostream>

int main() {

    bool cond_var;

    const int num_threads = omp_get_max_threads();
    const unsigned int spacing=64/sizeof(bool);  /* to avoid false sharing */
    bool local_cond_var[num_threads*spacing];

    #pragma omp parallel default(none) shared(cond_var,std::cout,local_cond_var)
    {
        std::random_device rd;
        std::mt19937 rng(rd());
        unsigned iter_count = 0;

        std::uniform_int_distribution<int> dice(0,1);

        const int tid = omp_get_thread_num();
        printf("Thread %d started.\n", tid);
        do {
            ++iter_count;

            local_cond_var[tid*spacing] = (dice(rng) == 0);

            #pragma omp barrier
            #pragma omp single
            {
                cond_var = true;
                for (int i=0; i<num_threads; i++)
                    cond_var &= local_cond_var[i*spacing];
            }
            // implicit barrier here after the single; turned off with a nowait clause.
        } while(!cond_var);

        #pragma omp critical
        std::cout << "Thread " << tid << " finished with " << iter_count << " iterations." << std::endl;
    }

    return 0;
}

请注意，障碍，无论是显式的还是隐式的，都意味着刷新共享变量，并且向单例添加 nowait 子句会导致间歇性死锁。