Ist eine Funktion ohne Schleife parallelizable?

stimmen
3

den Code unter Berücksichtigung, können wir es betrachten parallel auch wenn es keine Schleifen sind?

#include <omp.h>

int main(void) {
  #pragma omp parallel
  {
    int a = 1;
    a = 0;
  }
  return 0;
}
Veröffentlicht am 27/11/2018 um 17:58
quelle vom benutzer
In anderen Sprachen...                            


1 antworten

stimmen
6

Direkte Antwort:

Ja, hier ist der Abschnitt des Codes,

int a = 1;
a = 0;

Läuft parallel, P-mal, wobei P die Anzahl der Kerne auf Ihrem Rechner ist.

Beispielsweise auf einer Maschine mit vier Kernen, der folgende Code (mit den entsprechenden Importen),

int main(void) {
    #pragma omp parallel
    {
        printf("Thread number %d", omp_get_thread_num());
    }
    return 0;
}

ausgeben würde:

Thread number 0
Thread number 1
Thread number 2
Thread number 3

Beachten Sie, dass bei parallel laufenden, gibt es keine Garantie für die Reihenfolge der Ausgabe ist, so könnte die Ausgabe genauso wahrscheinlich so etwas wie:

Thread number 1
Thread number 2
Thread number 0
Thread number 3

Außerdem, wenn Sie die Anzahl der Threads , die in dem parallelen Bereich, statt angeben wollte #pragma omp parallelman schreiben konnte, #pragma omp parallel num_threads(4).


Weitere Erläuterung:

Wenn Sie immer noch verwirrt sind, kann es hilfreich sein, um besser auf die Differenz zwischen parallel zum Schleifen und parallele Codebereiche zu verstehen.

#pragma omp parallelweist den Compiler an, der den folgenden Codeblock parallel ausgeführt werden können. Es garantiert, dass die gesamten Code innerhalb der parallelen Region fertiger Ausführung hat, bevor er zu nachfolgendem Code fort.

In dem folgende (Spielzeug) wird beispielsweise der Programmierer gewährleistet, dass nach dem parallelen Bereich, wird die Array alle Einträge auf Null gesetzt.

int *arr = malloc(sizeof(int) * 128); 
const int P = omp_get_max_threads();

#pragma omp parallel num_threads(P)
{
    int local_start = omp_get_thread_num();
    int local_end = local_start + (100 / P);
    for (int i = local_start; i < local_end; ++i) {
        arr[i] = 0;
    }

}
// any code from here onward is guaranteed that arr contains all zeros!

Ignoriert Unterschiede bei der Zeitplanung, kann diese Aufgabe in äquivalenter Weise erreicht werden, um ein parallel zur Schleife wie folgt:

int *arr = malloc(sizeof(int) * 128); 
const int P = omp_get_max_threads();

#pragma omp parallel num_threads(P) for
for (int i = 0; i < 128; ++i) {
    arr[i] = 0;
}
// any code from here onward is guaranteed that arr contains all zeros!

Im Wesentlichen #pragma omp parallelkönnen Sie Codebereiche beschreiben , die parallel ausgeführt werden können - dies ist als ein parallel zur Schleife viel flexibler sein kann. Im Gegensatz dazu #pragma omp parallel forsollte in der Regel parallelisieren Schleifen mit unabhängigen Iterationen verwendet werden.

Ich kann weiter näher auf die Unterschiede in der Leistung, wenn Sie möchten.

Beantwortet am 27/11/2018 um 18:13
quelle vom benutzer

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more