c++ - 通过c++ 11的omp单个模拟

我有多个std :: threads，但其中只有一个应该执行某些任务（例如printf）（类似于pragma omp single）。

我试图修改semaphore code，但是它没有按我预期的那样工作。

#ifndef SEMAPHORE_H
#define SEMAPHORE_H

#include <mutex>
#include <condition_variable>
using namespace std;

class semaphore {
private:
    mutex mtx;
    condition_variable cv;
    int count, countMax;

public:
    semaphore(int count_ = 0):count(count_), countMax(count_){;}
    void notify()
    {
        unique_lock<mutex> lck(mtx);
        ++count;
        cv.notify_one();
    }
    void notifyAll()
    {
        unique_lock<mutex> lck(mtx);
        count = countMax;
        cv.notify_all();
    }

    bool wait()
    {
        unique_lock<mutex> lck(mtx);
        if (--count == 0) {
            return true;
        } else {
            cv.wait(lck, [this]() { return count > 0; });
            return false;
        }
    }
};

#endif // SEMAPHORE_H

和主程序：

#include <iostream>
#include <vector>
#include <thread>
#include "semaphore.h"

semaphore sem(2);
int sum = 0;
std::mutex sumMutex;
int sumPrintAndReturn(int i)
{
    {
        std::lock_guard<std::mutex> lock(sumMutex);
        sum += i;
    }
    if (sem.wait()) {
        std::cout << "Sum (ONCE): " << sum << std::endl;
        sem.notifyAll();
    }
    std::cout << "Sum (EVERY): " << sum << std::endl;
    return sum;
}

int main()
{
    std::vector<std::thread> threads;
    for (int i = 0; i < 2; i++) {
        threads.push_back(std::thread(sumPrintAndReturn, i));
    }
    for (auto& thread: threads)
        thread.join();
    return 0;
}

问题在于最终的总和是不同的。

Sum (EVERY): 0
Sum (ONCE): 1
Sum (EVERY): 1

那么，为什么我要谈论omp single？这是我期望的示例和输出。

#include <iostream>
#include <omp.h>

int main()
{
    int sum = 0;
    int global_i = 0;
    #pragma omp parallel num_threads(2)
    {
        int i;
        #pragma omp critical
        i = global_i++;
        #pragma omp atomic
        sum += i;
        #pragma omp single
        printf("Sum (ONCE): %d\n", sum);
        printf("Sum (EVERY): %d\n", sum);
    }
}

并输出：

Sum (ONCE): 1
Sum (EVERY): 1
Sum (EVERY): 1

我无法回答主题，因此我将在此处发布最终版本和工作版本

#ifndef SEMAPHORE_H
#define SEMAPHORE_H

#include <mutex>
#include <condition_variable>
#include <atomic>
#include <functional>

class semaphore {
private:
    std::mutex mtx;
    std::condition_variable cv;
    std::atomic<int> count;
    const int countMax;
    bool flag;

    void releaseAll()
    {
        std::unique_lock<std::mutex> lck(mtx);
        flag = true;
        cv.notify_all();
        cv.wait(lck, [this]() { return !flag; });
    }

    bool wait()
    {
        std::unique_lock<std::mutex> lck(mtx);
        if (--count == 0) {
            count++;
            return false;
        }
        else {
            cv.wait(lck, [this]() { return flag; });
            count++;
            if (count == countMax) {
                flag = false;
                cv.notify_all();
            }
            cv.wait(lck, [this]() { return !flag; });
            return true;
        }
    }

public:
    semaphore(int count_ = 0) :count(count_), countMax(count_), flag(false){ }
    void runOnce(std::function<void()> func) {
        if (!wait()) {
            func();
            releaseAll();
        }
    }


};

#endif // SEMAPHORE_H

最佳答案

问题出在wait函数的实现中。问题是您处理条件变量的方式...当信号量的初始计数为2并且您运行两个线程时，[this]() { return count > 0; }将始终返回true。

我在下面做了一个小更改，在其中添加了一个新的布尔变量，该变量保留“成功”状态，该状态在最终的“获胜”线程调用sem.wait()时设置。我不保证此代码的安全性或功能性；它仅对我有效；）（VS2013 express）。

class semaphore {
private:
  mutex mtx;
  condition_variable cv;
  int count, countMax;
  bool flag;

public:
  semaphore(int count_ = 0) :count(count_), countMax(count_), flag(false){ ; }
  void notify()
  {
    unique_lock<mutex> lck(mtx);
    ++count;
    cv.notify_one();
  }
  void notifyAll()
  {
    unique_lock<mutex> lck(mtx);
    count = countMax;
    cv.notify_all();
  }

  bool wait()
  {
    unique_lock<mutex> lck(mtx);
    if (--count == 0) {
      flag = true;
      return true;
    }
    else {
      cv.wait(lck, [this]() { return flag; });
      return false;
    }
  }
};

样本输出：
    总和（一次）：1
    总和（每）：1
    总和（每）：1

注意：自从我回答这个问题以来，问题中的原始代码已更改。为了完整起见，我的原始答案保留在下面。



此功能看起来非常可疑：

bool wait()
{
    unique_lock<mutex> lck(mtx);
    if (--count == 0) {
        return true;
    } else {
        cv.wait(lck, [this]() { return count > 0; });
    }
}

只有一个返回值！密切注意您的编译器警告会发现这一点。

$ g++ --std=c++11 -Wall semaphore.cpp
semaphore.cpp: In function ‘int sumPrintAndReturn(int)’:
semaphore.cpp:19:1: warning: no return statement in function returning non-void [-Wreturn-type]
In file included from semaphore.cpp:4:0:
semaphore.h: In member function ‘bool semaphore::wait()’:
semaphore.h:37:5: warning: control reaches end of non-void function [-Wreturn-type]

关于c++ - 通过c++ 11的omp单个模拟，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/23594591/