OpenMP függvények

Az OpenMP API-ban használt függvényekre mutató hivatkozásokat tartalmaz.

Az OpenMP standard Visual C++ implementációja az alábbi függvényeket és adattípusokat tartalmazza.

Környezeti végrehajtás esetén:

Funkció	Description
omp_set_num_threads (szálak számának beállítása)	Beállítja a következő párhuzamos régiókban lévő szálak számát, kivéve, ha egy num_threads záradék felülírja.
omp_get_num_threads	A párhuzamos régióban lévő szálak számát adja vissza.
omp_get_max_threads	Olyan egész számot ad vissza, amely egyenlő vagy nagyobb, mint azoknak a szálaknak a száma, amelyek akkor lennének elérhetők, ha a kód ezen pontján num_threads nélküli párhuzamos régiót határoznának meg.
omp_get_thread_num	A szálcsoporton belül végrehajtó szál számát adja vissza.
omp_get_num_procs	A függvény meghívásakor elérhető processzorok számát adja vissza.
omp_in_parallel	A nemzero értéket adja vissza, ha egy párhuzamos régióból hívjuk meg.
omp_set_dynamic	Azt jelzi, hogy a közelgő párhuzamos régiókban elérhető szálak száma a futási idő alapján módosítható.
omp_get_dynamic	Olyan értéket ad vissza, amely jelzi, hogy a közelgő párhuzamos régiókban elérhető szálak száma módosítható-e a futási idő alapján.
omp_set_nested	Engedélyezi a beágyazott párhuzamosságot.
omp_get_nested	Olyan értéket ad vissza, amely jelzi, hogy engedélyezve van-e a beágyazott párhuzamosság.

Zárolás esetén:

Funkció	Description
omp_init_lock	Inicializál egy egyszerű zárolást.
omp_init_nest_lock	Inicializál egy zárolást.
omp_destroy_lock	Felold egy zárat.
omp_destroy_nest_lock	Nem inicializál egy beágyazott zárolást.
omp_set_lock	Megakadályozza a szál végrehajtását, amíg nem elérhető egy zár.
omp_set_nest_lock	Blokkolja a szálvégrehajtást, amíg egy zárolás el nem érhető.
omp_unset_lock	Feloldja a zárolást.
omp_unset_nest_lock	Felold egy beágyazható zárolást.
omp_test_lock	Megpróbálja beállítani a zárolást, de nem blokkolja a szál végrehajtását.
omp_test_nest_lock	Beágyazott zárolást próbál beállítani, de nem blokkolja a szál végrehajtását.

Adattípus	Description
`omp_lock_t`	A zárolás állapotát tartalmazó típus, függetlenül attól, hogy a zárolás elérhető-e, vagy egy szál rendelkezik-e zárolással.
`omp_nest_lock_t`	A zárolással kapcsolatos alábbi információk egyikét tartalmazó típus: a zárolás elérhetősége, a zárolást birtokló szál identitása, és a beágyazási szám értéke.

Időzítési rutinok esetén:

Funkció	Description
omp_get_wtime	Egy értéket ad vissza másodpercben az idő egy bizonyos pontból való eltelte után.
omp_get_wtick	A processzor órajelei közötti másodpercek számát adja vissza.

omp_destroy_lock

Nem inicializál egy zárat.

void omp_destroy_lock(
   omp_lock_t *lock
);

Paraméterek

zár
Egy omp_lock_t típusú változó, amelyet omp_init_lock segítségével inicializáltak.

Megjegyzések

További információ: 3.2.2 omp_destroy_lock és omp_destroy_nest_lock függvények.

Example

Lásd az omp_init_lock példáját a omp_destroy_lock használatáról.

omp_destroy_nest_lock

Nem inicializál egy beágyazott zárolást.

void omp_destroy_nest_lock(
   omp_nest_lock_t *lock
);

Paraméterek

zár
Egy omp_nest_lock_t típusú változó, amelyet az omp_init_nest_lock-kal inicializáltak.

Megjegyzések

További információ: 3.2.2 omp_destroy_lock és omp_destroy_nest_lock függvények.

Example

A omp_init_nest_lock példaként szolgál a omp_destroy_nest_lock használatára.

omp_get_dynamic

Olyan értéket ad vissza, amely jelzi, hogy a közelgő párhuzamos régiókban elérhető szálak száma módosítható-e a futási idő alapján.

int omp_get_dynamic();

Visszaadott érték

A nemero érték azt jelenti, hogy a szálak dinamikusan lesznek igazítva.

Megjegyzések

A szálak dinamikus beállítása omp_set_dynamic és OMP_DYNAMIC van megadva.

További információ: 3.1.7 omp_set_dynamic függvény.

Example

Nézze meg a omp_set_dynamic példát omp_get_dynamic használatáról.

omp_get_max_threads

Olyan egész számot ad vissza, amely egyenlő vagy nagyobb, mint azoknak a szálaknak a száma, amelyek akkor lennének elérhetők, ha a kód ezen pontján num_threads nélküli párhuzamos régiót határoznának meg.

int omp_get_max_threads( )

Megjegyzések

További információ: 3.1.3 omp_get_max_threads függvény.

Example

// omp_get_max_threads.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main( )
{
    omp_set_num_threads(8);
    printf_s("%d\n", omp_get_max_threads( ));
    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_get_max_threads( ));
        }

    printf_s("%d\n", omp_get_max_threads( ));

    #pragma omp parallel num_threads(3)
        #pragma omp master
        {
            printf_s("%d\n", omp_get_max_threads( ));
        }

    printf_s("%d\n", omp_get_max_threads( ));
}

omp_get_nested

Olyan értéket ad vissza, amely jelzi, hogy engedélyezve van-e a beágyazott párhuzamosság.

int omp_get_nested( );

Visszaadott érték

A nemero érték azt jelenti, hogy a beágyazott párhuzamosság engedélyezve van.

Megjegyzések

A beágyazott párhuzamosság a omp_set_nested és az OMP_NESTED segítségével kerül megadásra.

További információ: 3.1.10 omp_get_nested függvény.

Example

Lásd a omp_set_nested, példaként a omp_get_nested használatára.

omp_get_num_procs

A függvény meghívásakor elérhető processzorok számát adja vissza.

int omp_get_num_procs();

Megjegyzések

További információ: 3.1.5 omp_get_num_procs függvény.

Example

// omp_get_num_procs.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main( )
{
    printf_s("%d\n", omp_get_num_procs( ));
    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_get_num_procs( ));
        }
}

// Expect the following output when the example is run on a two-processor machine:
2
2

omp_get_num_threads

A párhuzamos régióban lévő szálak számát adja vissza.

int omp_get_num_threads( );

Megjegyzések

További információ: 3.1.2 omp_get_num_threads függvény.

Example

// omp_get_num_threads.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main()
{
    omp_set_num_threads(4);
    printf_s("%d\n", omp_get_num_threads( ));
    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_get_num_threads( ));
        }

    printf_s("%d\n", omp_get_num_threads( ));

    #pragma omp parallel num_threads(3)
        #pragma omp master
        {
            printf_s("%d\n", omp_get_num_threads( ));
        }

    printf_s("%d\n", omp_get_num_threads( ));
}

omp_get_thread_num

A szálcsoporton belül végrehajtó szál számát adja vissza.

int omp_get_thread_num( );

Megjegyzések

További információ: 3.1.4 omp_get_thread_num függvény.

Example

Lásd a párhuzamos példát omp_get_thread_num használatára.

omp_get_wtick

A processzor órajelei közötti másodpercek számát adja vissza.

double omp_get_wtick( );

Megjegyzések

További információ: 3.3.2 omp_get_wtick függvény.

Example

Lásd az omp_get_wtime-et példaként a omp_get_wtick használatára.

omp_get_wtime

Egy értéket ad vissza másodpercben az idő egy bizonyos pontból való eltelte után.

double omp_get_wtime( );

Visszaadott érték

Egy tetszőleges, de konzisztens pontból eltelt idő másodpercében megadott értéket ad vissza.

Megjegyzések

Ez a pont továbbra is konzisztens marad a program végrehajtása során, így a közelgő összehasonlítások lehetségesek lesznek.

További információ: 3.3.1 omp_get_wtime függvény.

Example

// omp_get_wtime.cpp
// compile with: /openmp
#include "omp.h"
#include <stdio.h>
#include <windows.h>

int main() {
    double start = omp_get_wtime( );
    Sleep(1000);
    double end = omp_get_wtime( );
    double wtick = omp_get_wtick( );

    printf_s("start = %.16g\nend = %.16g\ndiff = %.16g\n",
             start, end, end - start);

    printf_s("wtick = %.16g\n1/wtick = %.16g\n",
             wtick, 1.0 / wtick);
}

start = 594255.3671159324
end = 594256.3664474116
diff = 0.9993314791936427
wtick = 2.793651148400146e-007
1/wtick = 3579545

omp_in_parallel

A nemzero értéket adja vissza, ha egy párhuzamos régióból hívjuk meg.

int omp_in_parallel( );

Megjegyzések

További információ: 3.1.6 omp_in_parallel függvény.

Example

// omp_in_parallel.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main( )
{
    omp_set_num_threads(4);
    printf_s("%d\n", omp_in_parallel( ));

    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_in_parallel( ));
        }
}

0
1

omp_init_lock

Inicializál egy egyszerű zárolást.

void omp_init_lock(
   omp_lock_t *lock
);

Paraméterek

zár
Típusváltozó omp_lock_t.

Megjegyzések

További információ: 3.2.1 omp_init_lock és omp_init_nest_lock függvények.

Example

// omp_init_lock.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

omp_lock_t my_lock;

int main() {
   omp_init_lock(&my_lock);

   #pragma omp parallel num_threads(4)
   {
      int tid = omp_get_thread_num( );
      int i, j;

      for (i = 0; i < 5; ++i) {
         omp_set_lock(&my_lock);
         printf_s("Thread %d - starting locked region\n", tid);
         printf_s("Thread %d - ending locked region\n", tid);
         omp_unset_lock(&my_lock);
      }
   }

   omp_destroy_lock(&my_lock);
}

Thread 0 - starting locked region
Thread 0 - ending locked region
Thread 0 - starting locked region
Thread 0 - ending locked region
Thread 0 - starting locked region
Thread 0 - ending locked region
Thread 0 - starting locked region
Thread 0 - ending locked region
Thread 0 - starting locked region
Thread 0 - ending locked region
Thread 1 - starting locked region
Thread 1 - ending locked region
Thread 1 - starting locked region
Thread 1 - ending locked region
Thread 1 - starting locked region
Thread 1 - ending locked region
Thread 1 - starting locked region
Thread 1 - ending locked region
Thread 1 - starting locked region
Thread 1 - ending locked region
Thread 2 - starting locked region
Thread 2 - ending locked region
Thread 2 - starting locked region
Thread 2 - ending locked region
Thread 2 - starting locked region
Thread 2 - ending locked region
Thread 2 - starting locked region
Thread 2 - ending locked region
Thread 2 - starting locked region
Thread 2 - ending locked region
Thread 3 - starting locked region
Thread 3 - ending locked region
Thread 3 - starting locked region
Thread 3 - ending locked region
Thread 3 - starting locked region
Thread 3 - ending locked region
Thread 3 - starting locked region
Thread 3 - ending locked region
Thread 3 - starting locked region
Thread 3 - ending locked region

omp_init_nest_lock

Inicializál egy zárolást.

void omp_init_nest_lock(
   omp_nest_lock_t *lock
);

Paraméterek

zár
Típusváltozó omp_nest_lock_t.

Megjegyzések

A kezdeti beágyazási szám nulla.

További információ: 3.2.1 omp_init_lock és omp_init_nest_lock függvények.

Example

// omp_init_nest_lock.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

omp_nest_lock_t my_lock;

void Test() {
   int tid = omp_get_thread_num( );
   omp_set_nest_lock(&my_lock);
   printf_s("Thread %d - starting nested locked region\n", tid);
   printf_s("Thread %d - ending nested locked region\n", tid);
   omp_unset_nest_lock(&my_lock);
}

int main() {
   omp_init_nest_lock(&my_lock);

   #pragma omp parallel num_threads(4)
   {
      int i, j;

      for (i = 0; i < 5; ++i) {
         omp_set_nest_lock(&my_lock);
            if (i % 3)
               Test();
            omp_unset_nest_lock(&my_lock);
        }
    }

    omp_destroy_nest_lock(&my_lock);
}

Thread 0 - starting nested locked region
Thread 0 - ending nested locked region
Thread 0 - starting nested locked region
Thread 0 - ending nested locked region
Thread 3 - starting nested locked region
Thread 3 - ending nested locked region
Thread 3 - starting nested locked region
Thread 3 - ending nested locked region
Thread 3 - starting nested locked region
Thread 3 - ending nested locked region
Thread 2 - starting nested locked region
Thread 2 - ending nested locked region
Thread 2 - starting nested locked region
Thread 2 - ending nested locked region
Thread 2 - starting nested locked region
Thread 2 - ending nested locked region
Thread 1 - starting nested locked region
Thread 1 - ending nested locked region
Thread 1 - starting nested locked region
Thread 1 - ending nested locked region
Thread 1 - starting nested locked region
Thread 1 - ending nested locked region
Thread 0 - starting nested locked region
Thread 0 - ending nested locked region

omp_set_dynamic

Azt jelzi, hogy a közelgő párhuzamos régiókban elérhető szálak száma a futási idő alapján módosítható.

void omp_set_dynamic(
   int val
);

Paraméterek

val
Egy érték, amely azt jelzi, hogy a futtatókörnyezet által módosítható-e a közelgő párhuzamos régiókban elérhető szálak száma. Nonzero esetén a futtatókörnyezet módosíthatja a szálak számát, ha nulla, akkor a futtatókörnyezet nem módosítja dinamikusan a szálak számát.

Megjegyzések

A szálak száma soha nem lépi túl a omp_set_num_threads vagy OMP_NUM_THREADS által beállított értéket.

A omp_get_dynamic használatával jelenítse meg a omp_set_dynamic aktuális beállítását.

A beállítás omp_set_dynamic felülírja a OMP_DYNAMIC környezeti változó beállításait.

További információ: 3.1.7 omp_set_dynamic függvény.

Example

// omp_set_dynamic.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main()
{
    omp_set_dynamic(9);
    omp_set_num_threads(4);
    printf_s("%d\n", omp_get_dynamic( ));
    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_get_dynamic( ));
        }
}

1
1

omp_set_lock

Blokkolja a szálvégrehajtást, amíg egy zárolás el nem érhető.

void omp_set_lock(
   omp_lock_t *lock
);

Paraméterek

zár
Egy omp_lock_t típusú változó, amelyet omp_init_lock segítségével inicializáltak.

Megjegyzések

További információ: 3.2.3 omp_set_lock és omp_set_nest_lock függvények.

Példák

Lásd az omp_init_lock példáját a omp_set_lock használatáról.

omp_set_nest_lock

Blokkolja a szálvégrehajtást, amíg egy zárolás el nem érhető.

void omp_set_nest_lock(
   omp_nest_lock_t *lock
);

Paraméterek

zár
Egy omp_nest_lock_t típusú változó, amelyet az omp_init_nest_lock-kal inicializáltak.

Megjegyzések

További információ: 3.2.3 omp_set_lock és omp_set_nest_lock függvények.

Példák

A omp_init_nest_lock példaként szolgál a omp_set_nest_lock használatára.

omp_set_nested

Engedélyezi a beágyazott párhuzamosságot.

void omp_set_nested(
   int val
);

Paraméterek

val
A nemero értékek lehetővé teszik a beágyazott párhuzamosságot, míg a nulla letiltja a beágyazott párhuzamosságot.

Megjegyzések

Az OMP beágyazott párhuzamossága bekapcsolható a omp_set_nested környezeti változó beállításával.

A beállítás omp_set_nested felülírja a OMP_NESTED környezeti változó beállításait.

A környezeti változó engedélyezése megszakíthatja az egyébként működő programokat, mivel a szálak száma exponenciálisan nő párhuzamos régiók beágyazásakor. Ha például egy függvény hatszor ismétlődik a 4-re beállított OMP-szálak számával, 4096 -ot (4-et 6) igényel. Az I/O-kötött alkalmazások kivételével az alkalmazások teljesítménye általában csökken, ha több szál van, mint a processzorok.

omp_get_nested használja, hogy megjelenítse omp_set_nested aktuális beállítását.

További információ: 3.1.9 omp_set_nested függvény.

Example

// omp_set_nested.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

int main( )
{
    omp_set_nested(1);
    omp_set_num_threads(4);
    printf_s("%d\n", omp_get_nested( ));
    #pragma omp parallel
        #pragma omp master
        {
            printf_s("%d\n", omp_get_nested( ));
        }
}

1
1

omp_set_num_threads

Beállítja a következő párhuzamos régiókban lévő szálak számát, kivéve, ha egy num_threads záradék felülírja.

void omp_set_num_threads(
   int num_threads
);

Paraméterek

num_threads
A párhuzamos régióban lévő szálak száma.

Megjegyzések

További információ: 3.1.1 omp_set_num_threads függvény.

Example

Példa a omp_get_num_threads használatára omp_set_num_threads.

omp_test_lock

Megpróbálja beállítani a zárolást, de nem blokkolja a szál végrehajtását.

int omp_test_lock(
   omp_lock_t *lock
);

Paraméterek

zár
Egy omp_lock_t típusú változó, amelyet omp_init_lock segítségével inicializáltak.

Megjegyzések

További információ: 3.2.5 omp_test_lock és omp_test_nest_lock függvények.

Example

// omp_test_lock.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

omp_lock_t simple_lock;

int main() {
    omp_init_lock(&simple_lock);

    #pragma omp parallel num_threads(4)
    {
        int tid = omp_get_thread_num();

        while (!omp_test_lock(&simple_lock))
            printf_s("Thread %d - failed to acquire simple_lock\n",
                     tid);

        printf_s("Thread %d - acquired simple_lock\n", tid);

        printf_s("Thread %d - released simple_lock\n", tid);
        omp_unset_lock(&simple_lock);
    }

    omp_destroy_lock(&simple_lock);
}

Thread 1 - acquired simple_lock
Thread 1 - released simple_lock
Thread 0 - failed to acquire simple_lock
Thread 3 - failed to acquire simple_lock
Thread 0 - failed to acquire simple_lock
Thread 3 - failed to acquire simple_lock
Thread 2 - acquired simple_lock
Thread 0 - failed to acquire simple_lock
Thread 3 - failed to acquire simple_lock
Thread 0 - failed to acquire simple_lock
Thread 3 - failed to acquire simple_lock
Thread 2 - released simple_lock
Thread 0 - failed to acquire simple_lock
Thread 3 - failed to acquire simple_lock
Thread 0 - acquired simple_lock
Thread 3 - failed to acquire simple_lock
Thread 0 - released simple_lock
Thread 3 - failed to acquire simple_lock
Thread 3 - acquired simple_lock
Thread 3 - released simple_lock

omp_test_nest_lock

Beágyazott zárolást próbál beállítani, de nem blokkolja a szál végrehajtását.

int omp_test_nest_lock(
   omp_nest_lock_t *lock
);

Paraméterek

zár
Egy omp_nest_lock_t típusú változó, amelyet az omp_init_nest_lock-kal inicializáltak.

Megjegyzések

További információ: 3.2.5 omp_test_lock és omp_test_nest_lock függvények.

Example

// omp_test_nest_lock.cpp
// compile with: /openmp
#include <stdio.h>
#include <omp.h>

omp_nest_lock_t nestable_lock;

int main() {
   omp_init_nest_lock(&nestable_lock);

   #pragma omp parallel num_threads(4)
   {
      int tid = omp_get_thread_num();
      while (!omp_test_nest_lock(&nestable_lock))
         printf_s("Thread %d - failed to acquire nestable_lock\n",
                tid);

      printf_s("Thread %d - acquired nestable_lock\n", tid);

      if (omp_test_nest_lock(&nestable_lock)) {
         printf_s("Thread %d - acquired nestable_lock again\n",
                tid);
         printf_s("Thread %d - released nestable_lock\n",
                tid);
         omp_unset_nest_lock(&nestable_lock);
      }

      printf_s("Thread %d - released nestable_lock\n", tid);
      omp_unset_nest_lock(&nestable_lock);
   }

   omp_destroy_nest_lock(&nestable_lock);
}

Thread 1 - acquired nestable_lock
Thread 0 - failed to acquire nestable_lock
Thread 1 - acquired nestable_lock again
Thread 0 - failed to acquire nestable_lock
Thread 1 - released nestable_lock
Thread 0 - failed to acquire nestable_lock
Thread 1 - released nestable_lock
Thread 0 - failed to acquire nestable_lock
Thread 3 - acquired nestable_lock
Thread 0 - failed to acquire nestable_lock
Thread 3 - acquired nestable_lock again
Thread 0 - failed to acquire nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 3 - released nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 3 - released nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 0 - acquired nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 0 - acquired nestable_lock again
Thread 2 - failed to acquire nestable_lock
Thread 0 - released nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 0 - released nestable_lock
Thread 2 - failed to acquire nestable_lock
Thread 2 - acquired nestable_lock
Thread 2 - acquired nestable_lock again
Thread 2 - released nestable_lock
Thread 2 - released nestable_lock

omp_unset_lock

Feloldja a zárolást.

void omp_unset_lock(
   omp_lock_t *lock
);

Paraméterek

zár
A omp_lock_t típusú változó, amelyet omp_init_lock-kal inicializáltak, és amely a szál tulajdonában van, valamint a függvényben történik a végrehajtása.

Megjegyzések

További információ: 3.2.4 omp_unset_lock és omp_unset_nest_lock függvények.

Example

Lásd az omp_init_lock példáját a omp_unset_lock használatáról.

omp_unset_nest_lock

Felold egy beágyazható zárolást.

void omp_unset_nest_lock(
   omp_nest_lock_t *lock
);

Paraméterek

zár
A omp_nest_lock_t típusú változó, amelyet omp_init_nest_lock-kel inicializáltak, a szál tulajdonában van és a függvényben hajtódik végre.

Megjegyzések

További információ: 3.2.4 omp_unset_lock és omp_unset_nest_lock függvények.

Example

A omp_init_nest_lock példaként szolgál a omp_unset_nest_lock használatára.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-02-24

Megosztás a következőn keresztül:

OpenMP függvények

omp_destroy_lock

Paraméterek

Megjegyzések

Example

omp_destroy_nest_lock

Paraméterek

Megjegyzések

Example

omp_get_dynamic

Visszaadott érték

Megjegyzések

Example

omp_get_max_threads

Megjegyzések

Example

omp_get_nested

Visszaadott érték

Megjegyzések

Example

omp_get_num_procs

Megjegyzések

Example

omp_get_num_threads

Megjegyzések

Example

omp_get_thread_num

Megjegyzések

Example

omp_get_wtick

Megjegyzések

Example

omp_get_wtime

Visszaadott érték

Megjegyzések

Example

omp_in_parallel

Megjegyzések

Example

omp_init_lock

Paraméterek

Megjegyzések

Example

omp_init_nest_lock

Paraméterek

Megjegyzések

Example

omp_set_dynamic

Paraméterek

Megjegyzések

Example

omp_set_lock

Paraméterek

Megjegyzések

Példák

omp_set_nest_lock

Paraméterek

Megjegyzések

Példák

omp_set_nested

Paraméterek

Megjegyzések

Example

omp_set_num_threads

Paraméterek

Megjegyzések

Example

omp_test_lock

Paraméterek

Megjegyzések

Example

omp_test_nest_lock

Paraméterek

Megjegyzések

Example

omp_unset_lock

Paraméterek

Megjegyzések

Example