标签: openmp

我在使用Linux上的OpenMP指令编译C代码时收到此警告:

warning: ignoring #pragma omp parallel

Gcc版本是4.4.

这只是一个我不应该关心的警告吗？执行是否会并行？我想要一个有一些解释的解决方案.

我已经提供-fopenmp了make命令,但是gcc不接受,否则对于单个文件编译,即gcc -fopenmp工作正常.

根据我的理解,#pragma omp parallel它的变化基本上在许多并发线程中执行以下块,这对应于CPU的数量.当嵌套并行化时 - 并行为并行,并行函数内的并行函数等 - 内部并行化会发生什么？

我是OpenMP的新手,我想到的情况可能相当简单 - 将矢量与矩阵相乘.这是在两个嵌套的for循环中完成的.假设CPU的数量小于向量中的元素数量,那么尝试并行运行内部循环是否有任何好处？线程总数是否会大于CPU数量,还是内部循环会顺序执行？

我有内置OpenMP pragma的C++代码.我想测试这个代码的多线程模式(使用OpenMP)和单线程模式(没有OpenMP).

现在,要在模式之间切换,我需要评论#pragma omp(或至少parallel).

启用/禁用OpenMP的最简洁或最默认的方法是什么？

我想用OpenMP在C++中编写并行程序,所以我开始使用OpenMP.换句话说,我是初学者,我需要良好的OpenMP指南,告诉他们如何安装它.有人知道如何在Windows上安装OpenMP,然后编译并运行该程序吗？

主程序:

program main                                                                                                                                                    
  use omp_lib                                                                                                                                                   
  use my_module                                                                                                                                                 
  implicit none                                                                                                                                                 

  integer, parameter :: nmax = 202000                                                                                                                           
  real(8) :: e_in(nmax) = 0.D0                                                                                                                                  
  integer i                                                                                                                                                     

call omp_set_num_threads(2)                                                                                                                                     
!$omp parallel default(firstprivate)                                                                                                                            
!$omp do                                                                                                                                                        
  do i=1,2                                                                                                                                                      
     print *, e_in(i)                                                                                                                                           
     print *, eTDSE(i)                                                                                                                                          
  end do                                                                                                                                                        
!$omp end do                                                                                                                                                    
!$omp end parallel                                                                                                                                              
end program main

模块:

module my_module                                                                                                                                                
  implicit none                                                                                                                                                 

  integer, parameter, private :: ntmax = 202000                                                                                                  
  double complex :: eTDSE(ntmax) = (0.D0,0.D0)                                                                                                                  
!$omp threadprivate(eTDSE)                                                                                                                                      

end module my_module

编译使用:

ifort -openmp main.f90 my_module.f90

它在执行时给出Segmentation故障.如果删除主程序中的一个打印命令,它运行正常.另外如果删除omp函数并在没有-openmp选项的情况下编译,它也运行正常.

我正在尝试使用OpenMP并行化C程序.

我想了解更多:

1. threadprivate指令和private子句之间的区别
2. 在哪些情况下,我们必须使用其中任何一个.

据我所知,区别在于threadprivate的全局范围以及跨并行区域的保留值.我在几个例子中发现,当一段代码包含一些必须私有化的全局/静态变量时,这些变量包含在threadprivate列表中,并且使用copyin将它们的初始值复制到私有副本中.

但是,是否有任何规则阻止我们使用private子句来处理全局/静态变量？也许任何实施细节？

我在OpenMP3.0规范中找不到任何解释.

我有一些看起来有点像这样的代码:

std::random_device rd;

#pragma omp parallel
{
    std::mt19937 gen(rd());
    #pragma omp for
    for(int i=0; i < N; i++)
    {
        /* Do stuff with random numbers from gen() */
    }
}

我有几个问题:

• 是std::random_device线程安全的？也就是说当几个线程立刻调用它时,它会做一些无用的事情吗？
• 这通常是个好主意吗？我应该担心重叠的随机数流吗？
• 有没有更好的方法来实现我想要的(每个线程中的独立随机数流 - 我现在不太担心可重复性)？

如果它对std::random_device我主要在Windows上运行的工作有任何影响,尽管我希望代码在Linux和OSX上同样运行良好.

我一直在开发一个应用程序来计算圆形物体,如图片中的细菌菌落.

容易的是这些物体通常与背景明显不同.

但是,很少有困难使分析变得棘手:

1. 背景将呈现渐变和快速的强度变化.
2. 在容器的边缘,对象将是椭圆形而不是圆形.
3. 物体的边缘有时相当模糊.
4. 对象将聚集.
5. 物体可以很小(直径6px)
6. 最终,算法将由不熟悉图像分析的人使用(通过GUI),因此参数必须直观且极少.

这个问题已在科学文献中多次解决并"解决",例如,使用圆形Hough变换或分水岭方法,但我从未对结果感到满意.

这是描述的一个简单的方法是通过获得自适应阈值和分裂前景(如我在描述这个交使用距离变换)的群集对象.

我已经成功地实现了这种方法,但它并不总能处理强度的突然变化.此外,同行们也要求我提出更"新颖"的方法.

因此,我正在寻找一种新方法来提取前景.

因此,我研究了其他阈值/斑点检测方法.我尝试了MSER但发现它们不是很强大而且在我的情况下非常慢.

我最终提出了一种算法,到目前为止,它给了我很好的结果:

1. 我将图像的三个通道分开并降低噪点(模糊/中值模糊).对于每个频道:
2. 我通过计算原始通道和卷积(通过大内核模糊)之间的绝对差异来应用自适应阈值处理的第一步的手动实现.然后,对于阈值的所有相关值:
3. 我对结果应用了一个阈值2)
4. 找到轮廓
5. 在授予其形状(尺寸,面积,凸度......)时验证或使轮廓无效
6. 然后,仅在累加器(每个通道1个累加器)中重新绘制有效的连续区域(即由轮廓分隔).
7. 在累积超过阈值的连续区域之后,我最终得到"地区分数"的映射.强度最高的区域是最常满足形态学过滤标准的区域.
8. 然后将三个映射(每个通道一个)转换为灰度和阈值(阈值由用户控制)

只是为了向您展示我必须使用的图像类型: 该图片代表顶部3个样本图像的一部分,以及底部各个部分的算法结果(蓝色=前景).

这是我的C++实现:3-7

/*
 * cv::Mat dst[3] is the result of the absolute difference between original and convolved channel.
 * MCF(std::vector<cv::Point>, int, int) is a filter function that returns an positive int only if the input contour is valid.
 */

/* Allocate 3 matrices (1 per channel)*/
cv::Mat accu[3];

/* We define the …

我想知道是否有人可以告诉我如何有效地使用循环平铺/循环阻塞来进行大密集矩阵乘法.我正在使用1000x1000矩阵进行C = AB.我已经按照维基百科上的示例进行循环平铺,但是使用平铺比使用平铺更糟糕.

http://en.wikipedia.org/wiki/Loop_tiling

http://software.intel.com/en-us/articles/how-to-use-loop-blocking-to-optimize-memory-use-on-32-bit-intel-architecture

我在下面提供了一些代码.由于缓存未命中,天真的方法非常慢.转置方法在缓冲区中创建B的转置.这种方法给出了最快的结果(矩阵乘法为O(n ^ 3)并且转置为O(n ^ 2),因此转置至少快1000倍).没有阻塞的wiki方法也很快,不需要缓冲区.阻塞方法较慢.阻塞的另一个问题是它必须多次更新块.这对线程/ OpenMP来说是一个挑战,因为如果不小心它会导致竞争条件.

我应该指出,使用AVX修改转置方法,我得到的结果比Eigen快.但是,我的SSE结果比Eigen慢一点,所以我想我可以更好地使用缓存.

编辑:我想我知道自己想做什么.它来自1969年的Cannon算法.http:
//en.wikipedia.org/wiki/Matrix_multiplication#Communication-avoiding_and_distributed_algorithms

我需要做的块矩阵乘法,并具有每个线程处理的一个子矩阵C ^而非阿和乙.例如,如果我将矩阵分成四个块.我会做:

+-+      +-+     +-+      +-+   +-+      +-+
|          |     |          |   |          |
| C1    C2 |     | A1    A2 |   | B1    B2 |
|          |  =  |          | x |          |
| C3    C4 |     | A3    A4 |   | B3    B4 |
|          |     |          |   |          |
+-+      +-+     +-+      +-+ …

我正在测试台式机和服务器上的内存带宽。

Sklyake desktop 4 cores/8 hardware threads
Skylake server Xeon 8168 dual socket 48 cores (24 per socket) / 96 hardware threads

系统的峰值带宽为

Peak bandwidth desktop = 2-channels*8*2400 = 38.4 GB/s
Peak bandwidth server  = 6-channels*2-sockets*8*2666 = 255.94 GB/s

我正在使用自己的STREAM三合一函数来测量带宽（稍后将提供完整代码）

void triad(double *a, double *b, double *c, double scalar, size_t n) {
  #pragma omp parallel for
  for(int i=0; i<n; i++) a[i] = b[i] + scalar*c[i];
}

这是我得到的结果

         Bandwidth (GB/s)
threads  Desktop  Server         
1             28      16
2(24)         29     146 …