标签: openmp

我有一个Java项目,我必须通过OpenMP技术实现并行化(也就是说,我必须以某种方式在C/C++和Java之间建立桥梁).到目前为止,我被告知使用JNI在Java中集成C/C++代码,但是,我也建议使用JaMP代替.我对这些技术/框架知之甚少,所以我的问题是,使用起来不那么痛苦,而且,一般来说,我如何在Java代码中实现OpenMP？我是否可以仅使用Java线程(不使用OpenMP)实现相同的功能？我是这个领域的初学者,所以绝对非常感谢任何帮助.

提示:该项目是建立一个协作图形编辑器,通过将一个核心"放"到服务器和客户端之间的交互,并"将"放到另一个核心上进行有效的图形处理.

有人能告诉我如何将 OpenMP 堆栈大小设置为无限制吗？
像这个链接：为什么在这个 openmp 代码中发生分段错误？

我也有一个Fortran写的项目（客户的复杂代码），如果我设置了OMP_STACKSIZE，项目运行正常。如果我取消设置，项目就会失败。

但是，不同的输入数据有不同的OMP_STACKSIZE，所以我必须为每个输入数据尝试它，（因为我必须节省内存）。

我可以像 pthread ( ulimit -s unlimited)一样设置 OpenMP 堆栈吗？或者有什么方法可以动态设置 omp 堆栈大小？

我使用的是 RHEL 6.1 和英特尔编译器。

非常感谢！

我需要实现归约操作（对于每个线程，值应该存储在不同的数组条目中）。但是，对于更多线程，它运行得更慢。有什么建议？

double local_sum[16];.
//Initializations....
#pragma omp parallel for shared(h,n,a) private(x, thread_id) 
for (i = 1; i < n; i++) {
    thread_id = omp_get_thread_num();
    x = a  + i* h;
    local_sum[thread_id] += f(x);
}

我考虑过哪些因素会影响 OpenMP 中的静态调度开销。在我看来，它受到以下因素的影响：

• CPU性能
• OpenMP 运行时库的具体实现
• 线程数

但我是否错过了进一步的因素？也许任务的大小，...？

此外：开销是否与迭代次数线性相关？在这种情况下，我希望使用静态调度和 4 个内核，开销会随着 4*i 次迭代而线性增加。到目前为止正确吗？

编辑：我只对静态（！）调度开销本身感兴趣。我不是在谈论线程启动开销和花费在同步和临界区开销上的时间。

我正在尝试使用英特尔TBB parallel_reduce来获取由双精度组成的数组元素的总和.但是,与OpenMP减少实现相比,结果是不同的.

这是OpenMP的一个:

double dAverageTemp = 0.0;
#pragma omp parallel for reduction(+:dAverageTemp)
for (int i = 0; i < sCartesianSize; i++)
    dAverageTemp += pdTempCurr[i];

此代码返回正确的值"317.277 493 "; 但是这个TBB代码:

double dAverageTemp = tbb::parallel_reduce(tbb::blocked_range<double*>(pdTempCurr, pdTempCurr + sCartesianSize - 1),
                                        0.0,
                                        [](const tbb::blocked_range<double*> &r, double value) -> double {
                                            return std::accumulate(r.begin(), r.end(), value);
                                        },
                                        std::plus<double>()
                                        );

坚持认为结果是"317.277 193 ".

我在这里错过了什么？

我只是按照这里的说明更新我的gcc。现在，我正在尝试安装FFTW。所以我在这里下载了文件。解压缩并导航到该目录后，运行以下命令：

./configure  --enable-mpi --enable-threads --enable-openmp

但是我收到以下错误：

checking for OpenMP flag of C compiler... unknown
configure: error: don't know how to enable OpenMP

我知道OpenMP在更新GCC之前不起作用，但是如果我这样做，现在它可以工作：

export PATH=/usr/local/gcc-6.1.0/bin:$PATH
gcc-6.1.0 main.c -o main

所以我猜测问题是，当我尝试配置FFTW时，它使用的是默认gcc，但我需要使用gcc-6.1.0。我怎样才能做到这一点？

我正在使用C ++和GMP开发小型Collat​​z猜想计算器，并且正在尝试使用OpenMP在其上实现并行性，但是遇到了有关线程安全性的问题。就目前而言，尝试运行代码将产生以下结果：

*** Error in `./collatz': double free or corruption (fasttop): 0x0000000001140c40 ***
*** Error in `./collatz': double free or corruption (fasttop): 0x00007f4d200008c0 ***
[1]    28163 abort (core dumped)  ./collatz

这是重现该行为的代码。

 #include <iostream>
 #include <gmpxx.h>

 mpz_class collatz(mpz_class n) {
     if (mpz_odd_p(n.get_mpz_t())) {
         n *= 3;
         n += 1;
     } else {
         n /= 2;
     }
     return n;
 }

 int main() {
     mpz_class x = 1;
 #pragma  omp parallel
     while (true) {
         //std::cout << x.get_str(10);
         while (true) {
             if …

我在一台机器上有64个内核,运行排序总计1GB的数据.它们每个排序156,250项,不应共享任何数据结构(即总共有64个单独的数组被排序).但是,我运行的核心越多,每个核心在其自己的排序任务中的速度就越慢.

时间测量正在这样做:

void sort_ranges(std::vector<std::vector<std::vector<int> > > & range_partitions, int num_workers, std::string filename, std::string outfile)
{
  #pragma omp parallel default(none) shared(range_partitions, outfile, num_workers)
  {
    int i = omp_get_thread_num();
    std::vector<int> data_vec; //Data copied into separate data structure for each thread
    for(int x = 0; x < num_workers; x ++) {
      data_vec.reserve(data_vec.size() + (range_partitions[x][i]).size());
      data_vec.insert(data_vec.end(), range_partitions[x][i].begin(), range_partitions[x][i].end());
    }
    int n = data_vec.size();
    int * data = &data_vec[0];
    double start = omp_get_wtime();
    std::sort(data, data + n); //Measure sort function call
    double sort_done = omp_get_wtime() …

我一直在使用OpenMP测试并行排序。我实现了比没有OpenMP快3倍的奇偶排序算法。但是，std :: sort仍然要快得多：seq-100s，并行-20s，std :: sort-0.05s

我尝试将#pragma omp并行移动到i-cycle，但效果更糟，并且没有对向量进行排序

for (int i = 0; i < 100000; i++) {
        #pragma omp parallel for
        for (int j = (i % 2) ? 0 : 1; j < 100000 - 1; j += 2) {
            if (vec_[j] > vec_[j + 1]) {
                std::swap(vec_[j], vec_[j + 1]);
            }
        }
    }

TBH，我期望并行奇偶排序是最快的，但现在我想知道-我做错什么了吗，或者只是std :: sort如此有效？

I am reading an array in parallel using openmp. Below is a minimal reproducible example:

#include <cstdint>
#include <cstdlib>
#include <immintrin.h>
#include <iostream>
#include <memory>
#include <omp.h>

int main(int argc, char* argv[]){
  // align to cache line, which is 512 bits or 64 bytes
  size_t actualSize = 2048;

  uint8_t* array = static_cast<uint8_t *>(aligned_alloc(64, actualSize));
  for(size_t i = 0; i < actualSize; i++){
    // initialize values
    array[i] = rand() % 256;
  }

  __m256i sum_v = _mm256_setzero_si256 ();
  #pragma omp parallel for …