/openmp (Abilitare il supporto OpenMP)

Fa sì che il compilatore elabori #pragma omp le direttive in supporto di OpenMP.

Sintassi

/openmp
/openmp:experimental
/openmp:llvm

Osservazioni:

#pragma omp viene utilizzato per specificare direttive e clausole. Se /openmp non viene specificato in una compilazione, il compilatore ignora le clausole e le direttive OpenMP. Le chiamate di funzione OpenMP vengono elaborate dal compilatore anche se /openmp non viene specificato.

Il compilatore C++ supporta attualmente lo standard OpenMP 2.0. Visual Studio 2019 offre anche funzionalità SIMD. Per usare SIMD, compilare usando l'opzione /openmp:experimental . Questa opzione abilita le normali funzionalità OpenMP e le funzionalità OPENMP SIMD non disponibili quando si usa l'opzione /openmp .

A partire da Visual Studio 2019 versione 16.9, è possibile usare l'opzione sperimentale /openmp:llvm anziché /openmp usare il runtime OPENMP LLVM. Il supporto non è attualmente disponibile per il codice di produzione, perché le DLL libomp necessarie non sono ridistribuibili. L'opzione supporta le stesse direttive OpenMP 2.0 di /openmp. Supporta inoltre tutte le direttive SIMD supportate dall'opzione /openmp:experimental . Supporta anche indici interi senza segno in parallelo per i cicli in base allo standard OpenMP 3.0. Per altre informazioni, vedere Miglioramento del supporto OpenMP per C++ in Visual Studio.

L'opzione /openmp:llvm supporta l'architettura x64. A partire da Visual Studio 2019 versione 16.10, supporta anche le architetture x86 e ARM64. Questa opzione non è compatibile con /clr o /ZW.

Le applicazioni compilate tramite e /openmp/clr possono essere eseguite solo in un singolo processo di dominio applicazione. Più domini applicazione non sono supportati. Ovvero, quando viene eseguito il costruttore del modulo (.cctor), rileva se il processo viene compilato usando /openmpe se l'app viene caricata in un runtime non predefinito. Per altre informazioni, vedere appdomain, /clr (compilazione Common Language Runtime) e inizializzazione di assembly misti.

Se si tenta di caricare un'app compilata usando e /clr/openmp in un dominio applicazione non predefinito, viene generata un'eccezione TypeInitializationException all'esterno del debugger e viene generata un'eccezione OpenMPWithMultipleAppdomainsException nel debugger.

Queste eccezioni possono essere generate anche nelle situazioni seguenti:

• Se l'applicazione viene compilata usando /clr ma non /openmpe viene caricata in un dominio applicazione non predefinito, in cui il processo include un'app compilata usando /openmp.

• Se passi l'app /clr a un'utilità, ad esempio regasm.exe, che carica gli assembly di destinazione in un dominio applicazione non predefinito.

La sicurezza dell'accesso al codice di Common Language Runtime non funziona nelle aree OpenMP. Se si applica un attributo di sicurezza dell'accesso al codice CLR all'esterno di un'area parallela, non sarà attivo nell'area parallela.

Microsoft non consiglia di scrivere /openmp app che consentano chiamanti parzialmente attendibili. Non usare AllowPartiallyTrustedCallersAttributeo gli attributi di sicurezza dell'accesso al codice CLR.

Per impostare l'opzione del compilatore nell'ambiente di sviluppo di Visual Studio

1. Aprire la finestra di dialogo Pagine delle proprietà del progetto. Per informazioni dettagliate, vedere Impostare il compilatore e le proprietà di compilazione.

2. Espandere la pagina delle proprietà Proprietà>di configurazione C/C++>Language.

3. Modificare la proprietà Supporto OpenMP.

Per impostare l'opzione del compilatore a livello di codice

• Vedere OpenMP.

Esempio

L'esempio seguente illustra alcuni degli effetti dell'avvio del pool di thread rispetto all'uso del pool di thread dopo l'avvio. Supponendo che un processore x64, a core singolo, doppio, il pool di thread richiede circa 16 ms per l'avvio. Successivamente, è previsto un costo aggiuntivo per il pool di thread.

Quando si esegue la compilazione usando /openmp, la seconda chiamata a test2 non viene mai eseguita più di se si esegue la compilazione usando /openmp-, perché non è disponibile l'avvio del pool di thread. A un milione di iterazioni, la /openmp versione è più veloce della /openmp- versione per la seconda chiamata a test2. A 25 iterazioni, entrambe /openmp- e /openmp le versioni registrano meno della granularità del clock.

Se nell'applicazione è presente un solo ciclo e viene eseguito in meno di 15 ms (modificato per l'overhead approssimativo nel computer), /openmp potrebbe non essere appropriato. Se è superiore, è consigliabile prendere in considerazione l'uso /openmpdi .

// cpp_compiler_options_openmp.cpp
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

volatile DWORD dwStart;
volatile int global = 0;

double test2(int num_steps) {
   int i;
   global++;
   double x, pi, sum = 0.0, step;

   step = 1.0 / (double) num_steps;

   #pragma omp parallel for reduction(+:sum) private(x)
   for (i = 1; i <= num_steps; i++) {
      x = (i - 0.5) * step;
      sum = sum + 4.0 / (1.0 + x*x);
   }

   pi = step * sum;
   return pi;
}

int main(int argc, char* argv[]) {
   double   d;
   int n = 1000000;

   if (argc > 1)
      n = atoi(argv[1]);

   dwStart = GetTickCount();
   d = test2(n);
   printf_s("For %d steps, pi = %.15f, %d milliseconds\n", n, d, GetTickCount() - dwStart);

   dwStart = GetTickCount();
   d = test2(n);
   printf_s("For %d steps, pi = %.15f, %d milliseconds\n", n, d, GetTickCount() - dwStart);
}

Vedi anche

Opzioni del compilatore MSVC
Sintassi della riga di comando del compilatore MSVC
OpenMP in MSVC