Question

我正在尝试在我的程序中使用OpenMP（我是使用OpenMP的新手），程序返回错误。

以下是一个示例代码：

#include <iostream>
#include <cstdint>
#include <vector>
#include <boost/multi_array.hpp>
#include <omp.h>

class CNachbarn {
public:
    CNachbarn () { a = 0; }
    uint32_t Get_Next_Neighbor() { return a++; }

private:
    uint32_t a;
};

class CNetwork {
public:
    CNetwork ( uint32_t num_elements_ );
    ~CNetwork();
    void Validity();
    void Clean();

private:
    uint32_t num_elements;
    uint32_t nachbar;

    std::vector<uint32_t> remove_node_v;
    CNachbarn *Nachbar;
};

CNetwork::CNetwork( uint32_t num_elements_  ) {
    num_elements = num_elements_;
    Nachbar = new CNachbarn();

    remove_node_v.reserve( num_elements );
}

CNetwork::~CNetwork() {
    delete Nachbar;
}

inline void CNetwork::Validity() {
    #pragma omp parallel for 
    for ( uint32_t i = 0 ; i < num_elements ; i++ ) {
        #pragma omp critical
        remove_node_v.push_back(i);
    }
}

void CNetwork::Clean () {
    #pragma omp parallel for
    for ( uint8_t j = 0 ; j < 2 ; j++ ) {
        nachbar = Nachbar->Get_Next_Neighbor();
        std::cout << "i: " << i << ", neighbor: " << nachbar << std::endl;
    }

    remove_node_v.clear();
}

int main() {
    uint32_t num_elements = 1u << 3;
    uint32_t i            = 0;
    CNetwork Network( num_elements );

    do {
        Network.Validity();
        Network.Clean();
    } while (++i < 2);

    return 0;
}

我想知道

如果#pragma omp critical是push_back()的一个很好的解决方案吗？（解决了这个问题吗？）为每个线程定义自己的向量然后将它们组合起来（使用insert（））会更好吗？或某种lock？
在原始代码中，我在nachbar = Nachbar->Get_Next_Neighbor( &remove_node_v[i] );处遇到了运行错误，但在此示例中没有。更少，我希望OpenMP用作核心CNachbarn类的数量，因为CNachbarn是递归计算，不应受其他线程的影响。问题是如何巧妙地做到这一点？（我不认为每次启动for循环时定义CNachbarn是明智的，因为我在模拟中将此函数调用了数百万次并且时间很重要。

Answer 1

关于你的第一个问题：您的功能有效性是在并行循环中实现低于串行性能的完美方式。但是，您已经给出了正确的答案。你应该为每个线程填充独立的向量，然后将它们合并。

inline void CNetwork::Validity() {
#pragma omp parallel for 
for ( uint32_t i = 0 ; i < num_elements ; i++ ) {
    #pragma omp critical
    remove_node_v.push_back(i);
}
}

编辑：可能的补救措施可能如下所示（如果您需要对元素进行串行访问，则需要稍微更改循环）

inline void CNetwork::Validity() {
remove_node_v.reserve(num_elements);
#pragma omp parallel 
{
  std::vector<uint32_t> remove_node_v_thread_local;
  uint32_t thread_id=omp_get_thread_num();
  uint32_t n_threads=omp_get_num_threads();
  for ( uint32_t i = thread_id ; i < num_elements ; i+=n_threads ) 
    remove_node_v_thread_local.push_back(i);

  #pragma omp critical
  remove_node_v.insert(remove_node_v.end(), remove_node_v_thread_local.begin(), remove_node_v_thread_local.end()); 
}
}

你的第二个问题可以通过定义一个CNachbarn数组来解决，该数组的大小可能是OMP线程的最大数量，并从每个线程访问数组的不同元素，如：

CNachbarn* meine_nachbarn=alle_meine_nachbarn[omp_get_thread_num()]

使用OpenMP的指针

1 个答案: