Einfache aufgabenbasierte OpenMP-Anwendung hängt

Question

Das folgende kleine Programm (online version) versucht, die Fläche eines 64 x 64-Quadrats durch rekursives Aufteilen in vier Quadrate zu berechnen, bis das kleinste Quadrat die Einheitslänge hat (kaum optimal). Aber aus irgendeinem Grund hängt das Programm. Was mache ich falsch?

#include <iostream> 

unsigned compute(unsigned length) 
{ 
    if(length == 1) return length * length; 

    unsigned a[4] , area = 0 , len = length/2; 

    for(unsigned i = 0; i < 4; ++i) 
    { 
     #pragma omp task 
     { 
      a[i] = compute(len); 
     } 

     #pragma omp single 
     { 
      area += a[i]; 
     } 
    } 

    return area; 
} 

int main() 
{ 
    unsigned area , length = 64; 

    #pragma omp parallel 
    { 
     area = compute(length); 
    } 

    std::cout << area << std::endl; 
} 

Answer 1

Die single Konstrukt dient als eine implizite Barriere für alle Threads im Team. Allerdings treffen nicht alle Threads im Team auf diesen einzelnen Block, da verschiedene Threads in unterschiedlichen Rekursionstiefen arbeiten. Aus diesem Grund hängt Ihre Anwendung.

In jedem Fall ist Ihr Code nicht korrekt. Nach Ihrer Aufgabenblockierung ist a[i] noch nicht zugewiesen, Sie können sie also nicht sofort verwenden! Sie müssen warten, bis die Aufgabe abgeschlossen ist. Natürlich sollten Sie das nicht innerhalb der Schleife tun, sonst würde das Tasking keine Parallelität ausnutzen. Die Lösung besteht darin, dies am Ende der Schleife zu tun. Auch müssen Sie a als Shared angeben, für die Ausgabe sichtbar werden:

for(unsigned i = 0; i < 4; ++i) 
{ 
    #pragma omp task shared(a) 
    { 
     a[i] = compute(len); 
    } 
} 
#pragma omp taskwait 
for(unsigned i = 0; i < 4; ++i) 
{ 
    area += a[i]; 
} 

Beachten Sie, dass die Reduktion nicht single Konstrukt gewickelt! Compute wird von einer Task ausgeführt, daher sollte nur ein Thread eine eigene lokale area haben. Allerdings müssen Sie ein single Konstrukt, bevor Sie zunächst alle Aufgaben laichen:

#pragma omp parallel 
#pragma omp single 
{ 
    area = compute(length); 
} 

Einfach gesagt dies eröffnet eine parallele Region mit einem Team von Fäden, und nur ein Thread beginnt die anfängliche Berechnung. Die anderen Threads greifen die Aufgaben auf, die später von diesem ersten Thread mit dem task-Konstrukt erzeugt werden. Darum geht es bei Tasking.

Answer 2

Motiviert durch die Diskussion über die Aufgabe und wie es vermieden werden kann, zeige ich unten eine leicht modifizierte Version des ursprünglichen Codes. Bitte beachten Sie, dass die implizite Barriere am Ende des einzelnen Konstrukts in diesem Fall wirklich notwendig ist.

unsigned tp_area = 0; 
#pragma omp threadprivate(tp_area) 

void compute (unsigned length) 
{ 
    if (length == 1) 
    { 
     tp_area += 1; 
     return; 
    } 

    unsigned len = length/2; 

    for (unsigned i = 0; i < 4; ++i) 
    { 
#pragma omp task 
     { 
     compute (len); 
     } 
    } 
} 

int main() 
{ 
    unsigned area, length = 64; 

#pragma omp parallel 
    { 
#pragma omp single 
    { 
     compute (length); 
    } 
#pragma omp atomic 
    area += tp_area; 
    } 

    std::cout << area << std::endl; 
}