Dela via

3. Körtidsbiblioteksfunktioner

I det här avsnittet beskrivs funktionerna för OpenMP C- och C++-körningsbibliotek. Rubriken <omp.h> deklarerar två typer, flera funktioner som kan användas för att styra och göra förfrågningar i den parallella körningsmiljön, och låsfunktioner som kan användas för att synkronisera åtkomst till data.

Typen omp_lock_t är en objekttyp som kan representera att ett lås är tillgängligt eller att en tråd äger ett lås. Dessa lås kallas enkla lås.

Typen omp_nest_lock_t är en objekttyp som kan representera antingen att ett lås är tillgängligt eller både identiteten för tråden som äger låset och ett kapslingsantal (beskrivs nedan). Dessa lås kallas ihopsättbara lås.

Biblioteksfunktionerna är externa funktioner med "C"-länkning.

Beskrivningarna i det här kapitlet är indelade i följande avsnitt:

3.1 Körningsmiljöfunktioner

Funktionerna som beskrivs i det här avsnittet påverkar och övervakar trådar, processorer och den parallella miljön:

3.1.1 omp_set_num_threads funktion

Funktionen omp_set_num_threads anger standardantalet trådar som ska användas för senare parallella regioner som inte anger någon num_threads sats. Formatet är följande:

#include <omp.h>
void omp_set_num_threads(int num_threads);

Värdet för parametern num_threads måste vara ett positivt heltal. Dess effekt beror på om dynamisk justering av antalet trådar är aktiverat. En omfattande uppsättning regler om interaktionen omp_set_num_threads mellan funktionen och dynamisk justering av trådar finns i avsnitt 2.3.

Den här funktionen har de effekter som beskrivs ovan när den omp_in_parallel anropas från en del av programmet där funktionen returnerar noll. Om den anropas från en del av programmet där omp_in_parallel funktionen returnerar ett icke-nollvärde är funktionens beteende odefinierat.

OMP_NUM_THREADS Det här anropet har företräde framför miljövariabeln. Standardvärdet för antalet trådar, som kan fastställas genom att anropa omp_set_num_threads eller genom att ange en miljövariabel som OMP_NUM_THREADS, kan uttryckligen åsidosättas i ett enda parallel-direktiv genom att anges num_threads-satsen.

Mer information finns i omp_set_dynamic.

Korsreferenser

3.1.2 omp_get_num_threads-funktionen

Funktionen omp_get_num_threads returnerar antalet trådar som för närvarande finns i teamet som kör den parallella region som den anropas från. Formatet är följande:

#include <omp.h>
int omp_get_num_threads(void);

Satsen num_threads , omp_set_num_threads funktionen och OMP_NUM_THREADS miljövariabeln styr antalet trådar i ett team.

Om antalet trådar inte uttryckligen har angetts av användaren är standardinställningen implementeringsdefinierad. Den här funktionen binder till det närmast omslutande parallel-direktivet. Om den anropas från en seriedel av ett program, eller från en kapslad parallell region som serialiseras, returnerar den här funktionen 1.

Mer information finns i omp_set_dynamic.

Korsreferenser

3.1.3 omp_get_max_threads-funktion

Funktionen omp_get_max_threads returnerar ett heltal som garanterat är minst lika stort som antalet trådar som skulle användas för att bilda ett team om en parallell region utan en num_threads sats skulle visas vid den tidpunkten i koden. Formatet är följande:

#include <omp.h>
int omp_get_max_threads(void);

Följande uttrycker en lägre gräns för värdet för omp_get_max_threads.

trådar-används-för-nästa-lag<= omp_get_max_threads

Observera att om en annan parallell region använder num_threads -satsen för att begära ett visst antal trådar, gäller inte längre garantin på den nedre gränsen för resultatet.omp_get_max_threads

Funktionens omp_get_max_threads returvärde kan användas för att dynamiskt allokera tillräckligt med lagringsutrymme för alla trådar i teamet som bildas i nästa parallella region.

Korsreferenser

3.1.4 omp_get_thread_num funktion

Funktionen omp_get_thread_num returnerar trådnumret i sitt team för den tråd som kör funktionen. Trådnumret ligger mellan 0 och omp_get_num_threads()-1, inklusive. Huvudtråden i teamet är tråd 0.

Formatet är följande:

#include <omp.h>
int omp_get_thread_num(void);

Om det anropas från en serieregion omp_get_thread_num returnerar 0. Om den anropas inifrån en kapslad parallell region som serialiseras returnerar den här funktionen 0.

Korsreferenser

3.1.5 omp_get_num_procs funktion

Funktionen omp_get_num_procs returnerar antalet processorer som är tillgängliga för programmet när funktionen anropas. Formatet är följande:

#include <omp.h>
int omp_get_num_procs(void);

3.1.6 omp_in_parallel funktion

Funktionen omp_in_parallel returnerar ett icke-nollvärde om det anropas inom den dynamiska omfattningen för en parallell region som körs parallellt. Annars returneras 0. Formatet är följande:

#include <omp.h>
int omp_in_parallel(void);

Den här funktionen returnerar ett icke-nollvärde när det anropas inifrån en region som körs parallellt, inklusive kapslade regioner som serialiseras.

3.1.7 omp_set_dynamic funktion

Funktionen omp_set_dynamic aktiverar eller inaktiverar dynamisk justering av antalet trådar som är tillgängliga för körning av parallella regioner. Formatet är följande:

#include <omp.h>
void omp_set_dynamic(int dynamic_threads);

Om dynamic_threads utvärderas till ett icke-nollvärde kan antalet trådar som används för att köra kommande parallella regioner justeras automatiskt av körningsmiljön för att använda systemresurser på bästa sätt. Därför är antalet trådar som anges av användaren det maximala antalet trådar. Antalet trådar i teamet som kör en parallell region förblir fast under hela den parallella regionen och rapporteras av omp_get_num_threads funktionen.

Om dynamic_threads utvärderas till 0 inaktiveras dynamisk justering.

Den här funktionen har de effekter som beskrivs ovan när den omp_in_parallel anropas från en del av programmet där funktionen returnerar noll. Om den anropas från en del av programmet där omp_in_parallel funktionen returnerar ett icke-nollvärde är funktionens beteende odefinierat.

Ett anrop till omp_set_dynamic har företräde framför OMP_DYNAMIC miljövariabeln.

Standardvärdet för dynamisk justering av trådar är implementeringsdefinierad. Därför bör användarkoder som är beroende av ett visst antal trådar för korrekt körning uttryckligen inaktivera dynamiska trådar. Implementeringar krävs inte för att ge möjlighet att dynamiskt justera antalet trådar, men de krävs för att tillhandahålla gränssnittet för att stödja portabilitet på alla plattformar.

Microsoft-specifik

Det aktuella stödet för omp_get_dynamic och omp_set_dynamic är följande:

Indataparametern till omp_set_dynamic påverkar inte trådningsprincipen och ändrar inte antalet trådar. omp_get_num_threads returnerar alltid antingen det användardefinierade talet, om det är inställt eller standardtrådsnumret. I den aktuella Microsoft-implementeringen omp_set_dynamic(0) inaktiverar du dynamisk trådning så att den befintliga uppsättningen trådar kan återanvändas för följande parallella region. omp_set_dynamic(1) aktiverar dynamisk trådning genom att ta bort den befintliga uppsättningen trådar och skapa en ny uppsättning för den kommande parallella regionen. Antalet trådar i den nya uppsättningen är samma som den gamla uppsättningen och baseras på returvärdet omp_get_num_threadsför . Använd därför för bästa prestanda omp_set_dynamic(0) för att återanvända befintliga trådar.

Korsreferenser

3.1.8 omp_get_dynamic funktion

Funktionen omp_get_dynamic returnerar ett icke-nollvärde om dynamisk justering av trådar är aktiverad och returnerar 0 annars. Formatet är följande:

#include <omp.h>
int omp_get_dynamic(void);

Om implementeringen inte implementerar dynamisk justering av antalet trådar returnerar den här funktionen alltid 0. Mer information finns i omp_set_dynamic.

Korsreferenser

3.1.9 omp_set_nested funktion

Funktionen omp_set_nested aktiverar eller inaktiverar kapslad parallellitet. Formatet är följande:

#include <omp.h>
void omp_set_nested(int nested);

Om kapslade utvärderas till 0 inaktiveras kapslad parallellitet, vilket är standard, och kapslade parallella regioner serialiseras och körs av den aktuella tråden. Annars aktiveras kapslad parallellitet och parallella regioner som är kapslade kan distribuera ytterligare trådar för att bilda kapslade team.

Den här funktionen har de effekter som beskrivs ovan när den omp_in_parallel anropas från en del av programmet där funktionen returnerar noll. Om den anropas från en del av programmet där omp_in_parallel funktionen returnerar ett icke-nollvärde är funktionens beteende odefinierat.

OMP_NESTED Det här anropet har företräde framför miljövariabeln.

När kapslad parallellitet är aktiverad är antalet trådar som används för att köra kapslade parallella regioner implementeringsdefinierade. Därför tillåts OpenMP-kompatibla implementeringar serialisera kapslade parallella regioner även när kapslad parallellitet är aktiverad.

Korsreferenser

3.1.10 omp_get_nested-funktionen

Funktionen omp_get_nested returnerar ett icke-nollvärde om kapslad parallellitet är aktiverat och 0 om det är inaktiverat. Mer information om kapslad parallellitet finns i omp_set_nested. Formatet är följande:

#include <omp.h>
int omp_get_nested(void);

Om en implementering inte implementerar kapslad parallellitet returnerar den här funktionen alltid 0.

3.2 Låsfunktioner

Funktionerna som beskrivs i det här avsnittet manipulerar lås som används för synkronisering.

För följande funktioner måste låsvariabeln ha typen omp_lock_t. Den här variabeln får endast nås via dessa funktioner. Alla låsfunktioner kräver ett argument som har en pekare av omp_lock_t typ.

För följande funktioner måste låsvariabeln ha typen omp_nest_lock_t. Den här variabeln får endast nås via dessa funktioner. Alla kapslade låsfunktioner kräver ett argument som har en pekare till typ omp_nest_lock_t.

OpenMP-låsfunktionerna har åtkomst till låsvariabeln på ett sådant sätt att de alltid läser och uppdaterar det senaste värdet för låsvariabeln. Därför är det inte nödvändigt för ett OpenMP-program att inkludera explicita flush direktiv för att se till att låsvariabelns värde är konsekvent mellan olika trådar. (Det kan finnas ett behov av direktiv för att göra värdena för flush andra variabler konsekventa.)

3.2.1 Funktionen omp_init_lock och omp_init_nest_lock

De här funktionerna är det enda sättet att initiera ett lås. Varje funktion initierar låset som är associerat med parameterlåset för användning i kommande anrop. Formatet är följande:

#include <omp.h>
void omp_init_lock(omp_lock_t *lock);
void omp_init_nest_lock(omp_nest_lock_t *lock);

Det ursprungliga tillståndet är olåst (det vill säga att ingen tråd äger låset). För ett kapslingsbart lås är det första kapslingsantalet noll. Det är inkompatibelt att anropa någon av dessa rutiner med en låsvariabel som redan har initierats.

3.2.2 funktionerna omp_destroy_lock och omp_destroy_nest_lock

Dessa funktioner ser till att den pekade låsvariabeln lock är oinitialiserad. Formatet är följande:

#include <omp.h>
void omp_destroy_lock(omp_lock_t *lock);
void omp_destroy_nest_lock(omp_nest_lock_t *lock);

Det är inkompatibelt att anropa någon av dessa rutiner med en låsvariabel som är oinitierad eller olåst.

3.2.3 funktionerna omp_set_lock och omp_set_nest_lock

Var och en av dessa funktioner blockerar tråden som kör funktionen tills det angivna låset är tillgängligt och anger sedan låset. Ett enkelt lås kan användas om det är upplåst. Ett kapslingsbart lås är tillgängligt om det är olåst eller om det redan innehas av den tråd som exekverar funktionen. Formatet är följande:

#include <omp.h>
void omp_set_lock(omp_lock_t *lock);
void omp_set_nest_lock(omp_nest_lock_t *lock);

För ett enkelt lås måste argumentet till omp_set_lock funktionen peka på en initierad låsvariabel. Ägarskapet för låset beviljas till den tråd som kör funktionen.

För ett kapslat lås måste argumentet till omp_set_nest_lock funktionen peka på en initierad låsvariabel. Antalet kapslingar ökas, och tråden får, eller behåller, ägarskapet för låset.

3.2.4 omp_unset_lock- och omp_unset_nest_lock funktioner

Dessa funktioner ger möjlighet att frigöra ägarskapet för ett lås. Formatet är följande:

#include <omp.h>
void omp_unset_lock(omp_lock_t *lock);
void omp_unset_nest_lock(omp_nest_lock_t *lock);

Argumentet för var och en av dessa funktioner måste peka på en initierad låsvariabel som ägs av tråden som kör funktionen. Beteendet är odefinierat om tråden inte äger låset.

För ett enkelt lås släpper funktionen omp_unset_lock tråden som kör funktionen från ägarskapet av låset.

För ett kapslat lås omp_unset_nest_lock minskar funktionen antalet kapslingar och släpper tråden som kör funktionen från ägarskapet för låset om det resulterande antalet är noll.

3.2.5 omp_test_lock- och omp_test_nest_lock-funktioner

Dessa funktioner försöker ange ett lås men blockerar inte körningen av tråden. Formatet är följande:

#include <omp.h>
int omp_test_lock(omp_lock_t *lock);
int omp_test_nest_lock(omp_nest_lock_t *lock);

Argumentet måste peka på en initierad låsvariabel. Dessa funktioner försöker ange ett lås på samma sätt som omp_set_lock och omp_set_nest_lock, förutom att de inte blockerar körningen av tråden.

Funktionen omp_test_lock returnerar ett värde som inte är noll om låset lyckas sättas; annars returneras noll.

För ett kapslingsbart lås omp_test_nest_lock returnerar funktionen det nya kapslingsantalet om låset har angetts. Annars returneras noll.

3.3 Tidsrutiner

Funktionerna som beskrivs i det här avsnittet stöder en portabel timer för väggklockan:

  • Funktionen omp_get_wtime returnerar förfluten tid på väggklockan.
  • Funktionen omp_get_wtick returnerar sekunder mellan efterföljande klocktickningar.

3.3.1 omp_get_wtime funktion

Funktionen omp_get_wtime returnerar ett flyttal med dubbel precision som är lika med den förflutna väggklocktiden i sekunder sedan en viss "tidpunkt i det förflutna". Den faktiska "tiden i det förflutna" är godtycklig, men garanteras att inte förändras under programmets körning. Formatet är följande:

#include <omp.h>
double omp_get_wtime(void);

Funktionen förväntas användas för att mäta förflutna tider enligt följande exempel:

double start;
double end;
start = omp_get_wtime();
... work to be timed ...
end = omp_get_wtime();
printf_s("Work took %f sec. time.\n", end-start);

De tider som returneras är "per tråd-tider", vilket innebär att de inte behöver vara globalt enhetliga över alla trådar som deltar i en applikation.

3.3.2 omp_get_wtick-funktion

Funktionen omp_get_wtick returnerar ett flyttal med dubbel precision som är lika med antalet sekunder mellan efterföljande klocktick. Formatet är följande:

#include <omp.h>
double omp_get_wtick(void);