在C++中使用openmp进行多线程编程

#pragma omp parallel  for schedule(dynamic)
for (int i = 0; i < 10; ++i)
{
   printf("%d ", i);
}

那么打印的结果则有可能不是局部有序的。  

#pragma omp parallel  for schedule(dynamic，3)
for (int i = 0; i < 10; ++i)
{
   printf("%d ", i);
}

int a,b;
if(GOMP_loop_dynamic_start(0,10,1,3,&a,&b))
{
do{
for(int n=a; n<b;++n) printf(" %d", n);
}while(GOMP_loop_dynamic_next(&a,&b));
}

#pragma  omp parallel for ordered schedule(dynamic)
  

for (int i = 0; i < 10; ++i)
{
    Data data = ReadFile(files[i]);
#pragma omp ordered
    PutDataToDataset(data);
}

int factorial(int number)
{
int fac =1;
#pragma omp parallel for reduction(*:fac)
for(int n=2; n<=number;++n)
     fac *= n;
return fac;
}

• 开始，每个线程会拷贝一份fac；
• parallel块结束之后，每个线程中的fac会利用“*”进行聚合，并将聚合的结果设置回主线程中的fac中。

如果这里我们不用reduction，那么则需用适用atomic指令，代码如下：

int factorial(int number)
{
int fac =1;
#pragma omp parallel for
for(int n=2; n<=number;++n)
{
#pragma omp atomic
     fac *= n;
}
return fac;
}

使用reduction指令的代码事实上类似于以下代码：

int factorial(int number)
{
int fac =1;
#pragma omp parallel
{
int fac_private =1;
#pragma omp for nowait
for(int n=2; n<=number;++n)
       fac_private *= n;
#pragma omp atomic
     fac *= fac_private;
}
return fac;
}

#pragma omp parallel
{
/* All threads execute this. */
   SomeCode();
#pragma omp barrier
/* All threads execute this, but not before
    * all threads have finished executing SomeCode().
    */
   SomeMoreCode();
}

#pragma omp parallel
{
#pragma omp for
for(int n=0; n<10;++n) Work();
// This line is not reached before the for-loop is completely finished
   SomeMoreCode();
}

// This line is reached only after all threads from
// the previous parallel block are finished.
 CodeContinues();

#pragma omp parallel
{
#pragma omp for nowait
for(int n=0; n<10;++n) Work();
// This line may be reached while some threads are still executing the for-loop.
   SomeMoreCode();
}

// This line is reached only after all threads from
// the previous parallel block are finished.
 CodeContinues();

#pragma omp parallel
{
   Work1();
#pragma omp single
{
     Work2();
}
   Work3();
}

master指令则指定其相关的代码块必须在主线程中执行，且其它线程不必在代码块后阻塞。

#pragma omp parallel
{
   Work1();
// This...
#pragma omp master
{
     Work2();
}
// ...is practically identical to this:
if(omp_get_thread_num()==0)
{
     Work2();
}
   
   Work3();
}

#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
     tick(x,y);
}
}

#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp for // ERROR, nesting like this is not allowed.
for(int x=0; x<80;++x)
{
     tick(x,y);
}
}

     
     

      
      

       
       
OpenMP 3.0中的解决方案
       
       

        
        在OpenMP 3.0中，可以利用collapse指令来解决循环嵌套问题，如：
        
        
#pragma omp parallel for collapse(2)
for(int y=0; y<25;++y)
for(int x=0; x<80;++x)
{
     tick(x,y);
}

collapse指令传递的数字就代表了循环嵌套的深度，这里为2层。
       
       
       
       
OpenMP 2.5中正确的做法
       
       

        
        
在OpenMP 2.5中，我们可以通过将多层循环改为单层循环的方法来达到目的，这样便无需循环嵌套:
        
        
#pragma omp parallel for
for(int pos=0; pos<(25*80);++pos)
{
int x = pos%80;
int y = pos/80;
   tick(x,y);
}

然而重写这样的代码也并非易事，另一个办法是采用omp_set_nested方法开启循环嵌套支持，默认是关闭的：
        
        
 omp_set_nested(1);
#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
     tick(x,y);
}
}

现在内层循环中，也会创建一个大小为N的线程组，因此实际上我们将得到N*N个线程，这便会导致频繁的线程切换，会带来较大的性能损失，这也就是为什么循环嵌套默认是关闭的。也许最好的方法就是将外层循环的parallel指令删除，只保留内层循环的parallel：
        
        
for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
     tick(x,y);
}
}


       
       
      
      
      
      
取消线程（退出循环）
     
     
     
     

      
      加入我们想要使用omp多线程来优化如下方法：
      
      
constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
for(size_t p =0; p < size;++p)
if(haystack[p]== needle)
{return haystack+p;    //找到needle，直接退出函数
}
return NULL;
}

我们最直观的想法应该是在for循环外加上“#pragma omp parallel for"，但是让人失望的是这将无法通过编译。因为omp要求必须每个循环迭代都能得到处理，因此不允许直接退出循环，这也就是说在循环中不能使用return、break、goto、throw等能够中断循环的语句。为了能够提前退出循环，我们需要退出时，通知线程组的其他线程，让它们结束运行：
     
     
     
     

      
      
弃用omp，选择其他多线程编程，如pthread
通过共享变量，通知线程组其他线程
      
      
以下为使用布尔标记来通知其他线程的示例：
      
      
constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
constchar* result = NULL;
bool done =false;
#pragma omp parallel for
for(size_t p =0; p < size;++p)
{
#pragma omp flush(done)
if(!done)
{
/* Do work only if no thread has found the needle yet. */
if(haystack[p]== needle)
{
/* Inform the other threads that we found the needle. */
         done =true;
#pragma omp flush(done)
         result = haystack+p;
}
}
}
return result;
}


      
      然而这样写有个缺点就是，即使done标记变为true了，其他线程仍然需要完成每次迭代，即使这些迭代是完全没有意义的。. 当然，我们也可以不用上述的done标记：
      
      
constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
constchar* result = NULL;
#pragma omp parallel for
for(size_t p =0; p < size;++p)
if(haystack[p]== needle)
       result = haystack+p;
return result;
}


      
      但是这也并没有完全解决问题，因为这样当一个线程已经找到需要的结果是，也不能够避免其他线程继续运行，这也就造成了不必要的浪费。
      
      
事实上，omp针对这个问题并没有很好的解决办法，如果确实需要，那只能求助于其他线程库了。
     
     
     
     
延伸阅读
     
     

      
      
The OpenMP 2.5 official specification
The OpenMP 3.0 official specification
Wikipedia article for OpenMP
OpenMP crash course at ARSC — has especially good list of gotchas.