/openmp (Habilitar la compatibilidad con Openmp)

Hace que el compilador procese las directivas #pragma omp compatibles con OpenMP.

Sintaxis

/openmp
/openmp:experimental
/openmp:llvm

Comentarios

#pragma omp se usa para especificar Directivas y Cláusulas. Si no se especifica /openmp en una compilación, el compilador omite las directivas y las cláusulas de OpenMP. El compilador procesa las llamadas a Función de OpenMP, incluso si /openmp no se especifica.

El compilador de C++ admite actualmente el estándar OpenMP 2.0. Visual Studio 2019 también ofrece funcionalidad SIMD. Para usar SIMD, compile con la /openmp:experimental opción . Esta opción habilita las características habituales de OpenMP y las características SIMD de OpenMP que no están disponibles cuando se usa el modificador /openmp.

A partir de la versión 16.9 de Visual Studio 2019, puede usar la /openmp:llvm opción experimental en lugar de tener /openmp como destino el tiempo de ejecución de OpenMP de LLVM. La compatibilidad no está actualmente disponible para el código de producción, ya que los archivos DLL de libomp necesarios no se pueden redistribuir. La opción admite las mismas directivas de OpenMP 2.0 que /openmp. Además, admite todas las directivas SIMD compatibles con la opción /openmp:experimental. También admite índices enteros sin signo en paralelo para bucles de acuerdo con el estándar OpenMP 3.0. Para obtener más información, vea Compatibilidad mejorada con OpenMP para C++ en Visual Studio.

La /openmp:llvm opción admite la arquitectura x64. A partir de la versión 16.10 de Visual Studio 2019, también admite las arquitecturas x86 y ARM64. Esta opción no es compatible con /clr o /ZW.

Las aplicaciones compiladas mediante /openmp y /clr solo se pueden ejecutar en un único proceso de dominio de aplicación. No admite dominios de aplicación múltiples. Es decir, cuando se ejecuta el constructor del módulo (.cctor), detecta si el proceso se compila mediante /openmp y si la aplicación se carga en un entorno de ejecución no predeterminado. Para obtener más información, vea appdomain, /clr (Compilación de Common Language Runtime) e Inicialización de ensamblados mixtos.

Si intenta cargar una aplicación compilada mediante ambos /openmp y /clr en un dominio de aplicación no predeterminado, se lanza TypeInitializationException una excepción fuera del depurador y se lanza una OpenMPWithMultipleAppdomainsException excepción en el depurador.

Estas excepciones también se pueden producir en las siguientes situaciones:

• Si la aplicación se compila mediante /clr, pero no /openmp, y se carga en un dominio de aplicación no predeterminado en el que el proceso incluye una aplicación compilada con /openmp.

• Si pasas la /clr aplicación a una utilidad, como regasm.exe, que carga los ensamblados de destino en un dominio de aplicación no predeterminado.

La seguridad de acceso del código de Common Language Runtime no funciona en regiones de OpenMP. Si aplica un atributo de seguridad de acceso del código CLR fuera de una región paralela, no tendrá efecto en la región paralela.

Microsoft no recomienda que escriba aplicaciones /openmp que permitan autores de llamada de confianza parcial. No use AllowPartiallyTrustedCallersAttribute ni ningún atributo de seguridad de acceso del código CLR.

Para establecer esta opción del compilador en el entorno de desarrollo de Visual Studio

1. Abra el cuadro de diálogo Páginas de propiedades del proyecto. Para más información, vea Establecimiento del compilador de C++ y de propiedades de compilación en Visual Studio.

2. Expanda la página de propiedades Configuración de propiedades>C/C++>Lenguaje.

3. Modifique la propiedad Compatibilidad con OpenMP.

Para establecer esta opción del compilador mediante programación

• Vea OpenMP.

Ejemplo

El siguiente ejemplo muestra algunos de los efectos del inicio del grupo de subprocesos en comparación con el uso del grupo de subprocesos una vez iniciado. Suponiendo que se trata de un procesador dual x64 de un solo núcleo, el grupo de subprocesos tarda aproximadamente 16 ms en iniciarse. Después de eso, hay poco costo adicional para el grupo de subprocesos.

Cuando se compila con /openmp, la segunda llamada a test2 nunca se ejecuta durante más tiempo que si se compila con /openmp-, ya que no hay ningún inicio de grupo de subprocesos. En un millón de iteraciones, la versión /openmp es más rápida que la versión /openmp- de la segunda llamada a test2. En 25 iteraciones, tanto las versiones /openmp- como /openmp registran menos que la granularidad del reloj.

Si solo tiene un bucle en la aplicación y se ejecuta en menos de 15 ms (ajustado para la sobrecarga aproximada en la máquina), /openmp puede que no sea adecuado. Si es superior, es posible que quiera considerar el uso de /openmp.

// 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);
}

Consulte también

Opciones del compilador de MSVC
Sintaxis de línea de comandos del compilador de MSVC
OpenMP en MSVC