Clauses OpenMP
Fournit des liens vers des clauses utilisées dans l’API OpenMP.
Visual C++ prend en charge les clauses OpenMP suivantes.
Pour les attributs généraux :
| Clause | Description |
|---|---|
| if | Spécifie si une boucle doit être exécutée en parallèle ou en série. |
| num_threads | Définit le nombre de threads dans une équipe de threads. |
| Commandé | Obligatoire sur une instruction parallèle si une directive ordonnée doit être utilisée dans la boucle. |
| schedule | S’applique à la directive. |
| nowait | Remplace la barrière implicite dans une directive. |
Pour les attributs de partage de données :
| Clause | Description |
|---|---|
| private | Spécifie que chaque thread doit avoir sa propre instance d’une variable. |
| firstprivate | Spécifie que chaque thread doit avoir sa propre instance d’une variable et que la variable doit être initialisée avec la valeur de la variable, car elle existe avant la construction parallèle. |
| lastprivate | Spécifie que la version du contexte englobant de la variable est définie sur la version privée de laquelle le thread exécute l’itération finale (construction de boucle for) ou la dernière section (sections #pragma). |
| Partagé | Spécifie qu’une ou plusieurs variables doivent être partagées entre tous les threads. |
| default | Spécifie le comportement des variables non portées dans une région parallèle. |
| reduction | Spécifie qu’une ou plusieurs variables privées à chaque thread font l’objet d’une opération de réduction à la fin de la région parallèle. |
| copyin | Permet aux threads d’accéder à la valeur du thread principal, pour une variable threadprivate . |
| copyprivate | Spécifie qu’une ou plusieurs variables doivent être partagées entre tous les threads. |
copyin
Permet aux threads d’accéder à la valeur du thread principal, pour une variable threadprivate .
copyin(var)
Paramètres
var
Variable threadprivate qui sera initialisée avec la valeur de la variable dans le thread principal, telle qu’elle existe avant la construction parallèle.
Notes
copyin s’applique aux directives suivantes :
Pour plus d’informations, consultez la copie 2.7.2.7.
Exemple
Consultez threadprivate pour obtenir un exemple d’utilisation copyin.
copyprivate
Spécifie qu’une ou plusieurs variables doivent être partagées entre tous les threads.
copyprivate(var)
Paramètres
var
Une ou plusieurs variables à partager. Si plusieurs variables sont spécifiées, séparez les noms de variables avec une virgule.
Notes
copyprivate s’applique à la directive unique .
Pour plus d’informations, consultez la version 2.7.2.8 copyprivate.
Exemple
// omp_copyprivate.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>
float x, y, fGlobal = 1.0;
#pragma omp threadprivate(x, y)
float get_float() {
fGlobal += 0.001;
return fGlobal;
}
void use_float(float f, int t) {
printf_s("Value = %f, thread = %d\n", f, t);
}
void CopyPrivate(float a, float b) {
#pragma omp single copyprivate(a, b, x, y)
{
a = get_float();
b = get_float();
x = get_float();
y = get_float();
}
use_float(a, omp_get_thread_num());
use_float(b, omp_get_thread_num());
use_float(x, omp_get_thread_num());
use_float(y, omp_get_thread_num());
}
int main() {
float a = 9.99, b = 123.456;
printf_s("call CopyPrivate from a single thread\n");
CopyPrivate(9.99, 123.456);
printf_s("call CopyPrivate from a parallel region\n");
#pragma omp parallel
{
CopyPrivate(a, b);
}
}
call CopyPrivate from a single thread
Value = 1.001000, thread = 0
Value = 1.002000, thread = 0
Value = 1.003000, thread = 0
Value = 1.004000, thread = 0
call CopyPrivate from a parallel region
Value = 1.005000, thread = 0
Value = 1.005000, thread = 1
Value = 1.006000, thread = 0
Value = 1.006000, thread = 1
Value = 1.007000, thread = 0
Value = 1.007000, thread = 1
Value = 1.008000, thread = 0
Value = 1.008000, thread = 1
default
Spécifie le comportement des variables non portées dans une région parallèle.
default(shared | none)
Notes
shared, qui est en vigueur si la default clause n’est pas spécifiée, signifie que toute variable d’une région parallèle sera traitée comme si elle a été spécifiée avec la clause partagée . none signifie que toutes les variables utilisées dans une région parallèle qui ne sont pas étendues avec la clause privée, partagée, réduction, firstprivate ou lastprivate entraînent une erreur du compilateur.
default s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.7.2.5 par défaut.
Exemple
Voir privé pour obtenir un exemple d’utilisation default.
firstprivate
Spécifie que chaque thread doit avoir sa propre instance d’une variable et que la variable doit être initialisée avec la valeur de la variable, car elle existe avant la construction parallèle.
firstprivate(var)
Paramètres
var
Variable à avoir des instances dans chaque thread et qui seront initialisées avec la valeur de la variable, car elle existe avant la construction parallèle. Si plusieurs variables sont spécifiées, séparez les noms de variables avec une virgule.
Notes
firstprivate s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.7.2.2 firstprivate.
Exemple
Pour obtenir un exemple d’utilisation firstprivate, consultez l’exemple en privé.
if (OpenMP)
Spécifie si une boucle doit être exécutée en parallèle ou en série.
if(expression)
Paramètres
expression
Expression intégrale qui, si elle prend la valeur true (différent de zéro), provoque l’exécution du code dans la région parallèle. Si l’expression a la valeur false (zéro), la région parallèle est exécutée en série (par un thread unique).
Notes
if s’applique aux directives suivantes :
Pour plus d’informations, consultez la construction parallèle 2.3.
Exemple
// omp_if.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>
void test(int val)
{
#pragma omp parallel if (val)
if (omp_in_parallel())
{
#pragma omp single
printf_s("val = %d, parallelized with %d threads\n",
val, omp_get_num_threads());
}
else
{
printf_s("val = %d, serialized\n", val);
}
}
int main( )
{
omp_set_num_threads(2);
test(0);
test(2);
}
val = 0, serialized
val = 2, parallelized with 2 threads
lastprivate
Spécifie que la version du contexte englobant de la variable est définie sur la version privée de laquelle le thread exécute l’itération finale (construction de boucle for) ou la dernière section (sections #pragma).
lastprivate(var)
Paramètres
var
Variable définie égale à la version privée du thread qui exécute l’itération finale (construction de boucle for) ou dernière section (sections #pragma).
Notes
lastprivate s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.7.2.3 lastprivate.
Exemple
Consultez la planification pour obtenir un exemple de clause Using lastprivate .
nowait
Remplace la barrière implicite dans une directive.
nowait
Notes
nowait s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.4.1 pour la construction, la construction de sections 2.4.2 et la construction unique 2.4.3.
Exemple
// omp_nowait.cpp
// compile with: /openmp /c
#include <stdio.h>
#define SIZE 5
void test(int *a, int *b, int *c, int size)
{
int i;
#pragma omp parallel
{
#pragma omp for nowait
for (i = 0; i < size; i++)
b[i] = a[i] * a[i];
#pragma omp for nowait
for (i = 0; i < size; i++)
c[i] = a[i]/2;
}
}
int main( )
{
int a[SIZE], b[SIZE], c[SIZE];
int i;
for (i=0; i<SIZE; i++)
a[i] = i;
test(a,b,c, SIZE);
for (i=0; i<SIZE; i++)
printf_s("%d, %d, %d\n", a[i], b[i], c[i]);
}
0, 0, 0
1, 1, 0
2, 4, 1
3, 9, 1
4, 16, 2
num_threads
Définit le nombre de threads dans une équipe de threads.
num_threads(num)
Paramètres
num
Nombre de threads
Notes
La num_threads clause a la même fonctionnalité que la fonction omp_set_num_threads .
num_threads s’applique aux directives suivantes :
Pour plus d’informations, consultez la construction parallèle 2.3.
Exemple
Consultez le parallèle pour obtenir un exemple de clause using num_threads .
ordered
Obligatoire sur une instruction parallèle si une directive ordonnée doit être utilisée dans la boucle.
ordered
Notes
ordereds’applique à la directive.
Pour plus d’informations, consultez la version 2.4.1 pour la construction.
Exemple
Consultez trié pour obtenir un exemple de clause using ordered .
private
Spécifie que chaque thread doit avoir sa propre instance d’une variable.
private(var)
Paramètres
var
Variable à avoir des instances dans chaque thread.
Notes
private s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.7.2.1 privée.
Exemple
// openmp_private.c
// compile with: /openmp
#include <windows.h>
#include <assert.h>
#include <stdio.h>
#include <omp.h>
#define NUM_THREADS 4
#define SLEEP_THREAD 1
#define NUM_LOOPS 2
enum Types {
ThreadPrivate,
Private,
FirstPrivate,
LastPrivate,
Shared,
MAX_TYPES
};
int nSave[NUM_THREADS][MAX_TYPES][NUM_LOOPS] = {{0}};
int nThreadPrivate;
#pragma omp threadprivate(nThreadPrivate)
#pragma warning(disable:4700)
int main() {
int nPrivate = NUM_THREADS;
int nFirstPrivate = NUM_THREADS;
int nLastPrivate = NUM_THREADS;
int nShared = NUM_THREADS;
int nRet = 0;
int i;
int j;
int nLoop = 0;
nThreadPrivate = NUM_THREADS;
printf_s("These are the variables before entry "
"into the parallel region.\n");
printf_s("nThreadPrivate = %d\n", nThreadPrivate);
printf_s(" nPrivate = %d\n", nPrivate);
printf_s(" nFirstPrivate = %d\n", nFirstPrivate);
printf_s(" nLastPrivate = %d\n", nLastPrivate);
printf_s(" nShared = %d\n\n", nShared);
omp_set_num_threads(NUM_THREADS);
#pragma omp parallel copyin(nThreadPrivate) private(nPrivate) shared(nShared) firstprivate(nFirstPrivate)
{
#pragma omp for schedule(static) lastprivate(nLastPrivate)
for (i = 0 ; i < NUM_THREADS ; ++i) {
for (j = 0 ; j < NUM_LOOPS ; ++j) {
int nThread = omp_get_thread_num();
assert(nThread < NUM_THREADS);
if (nThread == SLEEP_THREAD)
Sleep(100);
nSave[nThread][ThreadPrivate][j] = nThreadPrivate;
nSave[nThread][Private][j] = nPrivate;
nSave[nThread][Shared][j] = nShared;
nSave[nThread][FirstPrivate][j] = nFirstPrivate;
nSave[nThread][LastPrivate][j] = nLastPrivate;
nThreadPrivate = nThread;
nPrivate = nThread;
nShared = nThread;
nLastPrivate = nThread;
--nFirstPrivate;
}
}
}
for (i = 0 ; i < NUM_LOOPS ; ++i) {
for (j = 0 ; j < NUM_THREADS ; ++j) {
printf_s("These are the variables at entry of "
"loop %d of thread %d.\n", i + 1, j);
printf_s("nThreadPrivate = %d\n",
nSave[j][ThreadPrivate][i]);
printf_s(" nPrivate = %d\n",
nSave[j][Private][i]);
printf_s(" nFirstPrivate = %d\n",
nSave[j][FirstPrivate][i]);
printf_s(" nLastPrivate = %d\n",
nSave[j][LastPrivate][i]);
printf_s(" nShared = %d\n\n",
nSave[j][Shared][i]);
}
}
printf_s("These are the variables after exit from "
"the parallel region.\n");
printf_s("nThreadPrivate = %d (The last value in the "
"main thread)\n", nThreadPrivate);
printf_s(" nPrivate = %d (The value prior to "
"entering parallel region)\n", nPrivate);
printf_s(" nFirstPrivate = %d (The value prior to "
"entering parallel region)\n", nFirstPrivate);
printf_s(" nLastPrivate = %d (The value from the "
"last iteration of the loop)\n", nLastPrivate);
printf_s(" nShared = %d (The value assigned, "
"from the delayed thread, %d)\n\n",
nShared, SLEEP_THREAD);
}
These are the variables before entry into the parallel region.
nThreadPrivate = 4
nPrivate = 4
nFirstPrivate = 4
nLastPrivate = 4
nShared = 4
These are the variables at entry of loop 1 of thread 0.
nThreadPrivate = 4
nPrivate = 1310720
nFirstPrivate = 4
nLastPrivate = 1245104
nShared = 3
These are the variables at entry of loop 1 of thread 1.
nThreadPrivate = 4
nPrivate = 4488
nFirstPrivate = 4
nLastPrivate = 19748
nShared = 0
These are the variables at entry of loop 1 of thread 2.
nThreadPrivate = 4
nPrivate = -132514848
nFirstPrivate = 4
nLastPrivate = -513199792
nShared = 4
These are the variables at entry of loop 1 of thread 3.
nThreadPrivate = 4
nPrivate = 1206
nFirstPrivate = 4
nLastPrivate = 1204
nShared = 2
These are the variables at entry of loop 2 of thread 0.
nThreadPrivate = 0
nPrivate = 0
nFirstPrivate = 3
nLastPrivate = 0
nShared = 0
These are the variables at entry of loop 2 of thread 1.
nThreadPrivate = 1
nPrivate = 1
nFirstPrivate = 3
nLastPrivate = 1
nShared = 1
These are the variables at entry of loop 2 of thread 2.
nThreadPrivate = 2
nPrivate = 2
nFirstPrivate = 3
nLastPrivate = 2
nShared = 2
These are the variables at entry of loop 2 of thread 3.
nThreadPrivate = 3
nPrivate = 3
nFirstPrivate = 3
nLastPrivate = 3
nShared = 3
These are the variables after exit from the parallel region.
nThreadPrivate = 0 (The last value in the main thread)
nPrivate = 4 (The value prior to entering parallel region)
nFirstPrivate = 4 (The value prior to entering parallel region)
nLastPrivate = 3 (The value from the last iteration of the loop)
nShared = 1 (The value assigned, from the delayed thread, 1)
réduction
Spécifie qu’une ou plusieurs variables privées à chaque thread font l’objet d’une opération de réduction à la fin de la région parallèle.
reduction(operation:var)
Paramètres
opération
Opérateur de l’opération à effectuer sur les variables var à la fin de la région parallèle.
var
Une ou plusieurs variables sur lesquelles effectuer une réduction scalaire. Si plusieurs variables sont spécifiées, séparez les noms de variables avec une virgule.
Notes
reduction s’applique aux directives suivantes :
Pour plus d’informations, consultez la réduction 2.7.2.6.
Exemple
// omp_reduction.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>
#define NUM_THREADS 4
#define SUM_START 1
#define SUM_END 10
#define FUNC_RETS {1, 1, 1, 1, 1}
int bRets[5] = FUNC_RETS;
int nSumCalc = ((SUM_START + SUM_END) * (SUM_END - SUM_START + 1)) / 2;
int func1( ) {return bRets[0];}
int func2( ) {return bRets[1];}
int func3( ) {return bRets[2];}
int func4( ) {return bRets[3];}
int func5( ) {return bRets[4];}
int main( )
{
int nRet = 0,
nCount = 0,
nSum = 0,
i,
bSucceed = 1;
omp_set_num_threads(NUM_THREADS);
#pragma omp parallel reduction(+ : nCount)
{
nCount += 1;
#pragma omp for reduction(+ : nSum)
for (i = SUM_START ; i <= SUM_END ; ++i)
nSum += i;
#pragma omp sections reduction(&& : bSucceed)
{
#pragma omp section
{
bSucceed = bSucceed && func1( );
}
#pragma omp section
{
bSucceed = bSucceed && func2( );
}
#pragma omp section
{
bSucceed = bSucceed && func3( );
}
#pragma omp section
{
bSucceed = bSucceed && func4( );
}
#pragma omp section
{
bSucceed = bSucceed && func5( );
}
}
}
printf_s("The parallel section was executed %d times "
"in parallel.\n", nCount);
printf_s("The sum of the consecutive integers from "
"%d to %d, is %d\n", 1, 10, nSum);
if (bSucceed)
printf_s("All of the functions, func1 through "
"func5 succeeded!\n");
else
printf_s("One or more of the functions, func1 "
"through func5 failed!\n");
if (nCount != NUM_THREADS)
{
printf_s("ERROR: For %d threads, %d were counted!\n",
NUM_THREADS, nCount);
nRet |= 0x1;
}
if (nSum != nSumCalc)
{
printf_s("ERROR: The sum of %d through %d should be %d, "
"but %d was reported!\n",
SUM_START, SUM_END, nSumCalc, nSum);
nRet |= 0x10;
}
if (bSucceed != (bRets[0] && bRets[1] &&
bRets[2] && bRets[3] && bRets[4]))
{
printf_s("ERROR: The sum of %d through %d should be %d, "
"but %d was reported!\n",
SUM_START, SUM_END, nSumCalc, nSum);
nRet |= 0x100;
}
}
The parallel section was executed 4 times in parallel.
The sum of the consecutive integers from 1 to 10, is 55
All of the functions, func1 through func5 succeeded!
schedule
S’applique à la directive.
schedule(type[,size])
Paramètres
type
Type de planification, soit dynamic, , guided, runtimeou static.
size
(Facultatif) Spécifie la taille des itérations. la taille doit être un entier. Non valide lorsque le type est runtime.
Notes
Pour plus d’informations, consultez la version 2.4.1 pour la construction.
Exemple
// omp_schedule.cpp
// compile with: /openmp
#include <windows.h>
#include <stdio.h>
#include <omp.h>
#define NUM_THREADS 4
#define STATIC_CHUNK 5
#define DYNAMIC_CHUNK 5
#define NUM_LOOPS 20
#define SLEEP_EVERY_N 3
int main( )
{
int nStatic1[NUM_LOOPS],
nStaticN[NUM_LOOPS];
int nDynamic1[NUM_LOOPS],
nDynamicN[NUM_LOOPS];
int nGuided[NUM_LOOPS];
omp_set_num_threads(NUM_THREADS);
#pragma omp parallel
{
#pragma omp for schedule(static, 1)
for (int i = 0 ; i < NUM_LOOPS ; ++i)
{
if ((i % SLEEP_EVERY_N) == 0)
Sleep(0);
nStatic1[i] = omp_get_thread_num( );
}
#pragma omp for schedule(static, STATIC_CHUNK)
for (int i = 0 ; i < NUM_LOOPS ; ++i)
{
if ((i % SLEEP_EVERY_N) == 0)
Sleep(0);
nStaticN[i] = omp_get_thread_num( );
}
#pragma omp for schedule(dynamic, 1)
for (int i = 0 ; i < NUM_LOOPS ; ++i)
{
if ((i % SLEEP_EVERY_N) == 0)
Sleep(0);
nDynamic1[i] = omp_get_thread_num( );
}
#pragma omp for schedule(dynamic, DYNAMIC_CHUNK)
for (int i = 0 ; i < NUM_LOOPS ; ++i)
{
if ((i % SLEEP_EVERY_N) == 0)
Sleep(0);
nDynamicN[i] = omp_get_thread_num( );
}
#pragma omp for schedule(guided)
for (int i = 0 ; i < NUM_LOOPS ; ++i)
{
if ((i % SLEEP_EVERY_N) == 0)
Sleep(0);
nGuided[i] = omp_get_thread_num( );
}
}
printf_s("------------------------------------------------\n");
printf_s("| static | static | dynamic | dynamic | guided |\n");
printf_s("| 1 | %d | 1 | %d | |\n",
STATIC_CHUNK, DYNAMIC_CHUNK);
printf_s("------------------------------------------------\n");
for (int i=0; i<NUM_LOOPS; ++i)
{
printf_s("| %d | %d | %d | %d |"
" %d |\n",
nStatic1[i], nStaticN[i],
nDynamic1[i], nDynamicN[i], nGuided[i]);
}
printf_s("------------------------------------------------\n");
}
------------------------------------------------
| static | static | dynamic | dynamic | guided |
| 1 | 5 | 1 | 5 | |
------------------------------------------------
| 0 | 0 | 0 | 2 | 1 |
| 1 | 0 | 3 | 2 | 1 |
| 2 | 0 | 3 | 2 | 1 |
| 3 | 0 | 3 | 2 | 1 |
| 0 | 0 | 2 | 2 | 1 |
| 1 | 1 | 2 | 3 | 3 |
| 2 | 1 | 2 | 3 | 3 |
| 3 | 1 | 0 | 3 | 3 |
| 0 | 1 | 0 | 3 | 3 |
| 1 | 1 | 0 | 3 | 2 |
| 2 | 2 | 1 | 0 | 2 |
| 3 | 2 | 1 | 0 | 2 |
| 0 | 2 | 1 | 0 | 3 |
| 1 | 2 | 2 | 0 | 3 |
| 2 | 2 | 2 | 0 | 0 |
| 3 | 3 | 2 | 1 | 0 |
| 0 | 3 | 3 | 1 | 1 |
| 1 | 3 | 3 | 1 | 1 |
| 2 | 3 | 3 | 1 | 1 |
| 3 | 3 | 0 | 1 | 3 |
------------------------------------------------
shared
Spécifie qu’une ou plusieurs variables doivent être partagées entre tous les threads.
shared(var)
Paramètres
var
Une ou plusieurs variables à partager. Si plusieurs variables sont spécifiées, séparez les noms de variables avec une virgule.
Notes
Une autre façon de partager des variables entre des threads est avec la clause copyprivate .
shared s’applique aux directives suivantes :
Pour plus d’informations, consultez la version 2.7.2.4 partagée.
Exemple
Voir privé pour obtenir un exemple d’utilisation shared.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour