Compartir a través de

/arch (x86)

  • Artículo

Especifica la arquitectura para la generación de código en x86. Para obtener más información sobre /arch en otras arquitecturas de destino, consulte /arch (ARM64), /arch (x64) y /arch (ARM).

Sintaxis

/arch:[IA32AVX10.1|AVX512|AVX2|||AVX|SSESSE2]

Argumentos

/arch:IA32
No especifica ninguna instrucción mejorada y también especifica x87 para los cálculos de punto flotante.

/arch:SSE
Habilita las extensiones SIMD de streaming de Intel.

/arch:SSE2
Habilita Intel Streaming SIMD Extensions 2. El conjunto de instrucciones predeterminado es SSE2 si no se especifica ninguna /arch opción.

/arch:AVX
Habilita las extensiones de vector avanzado de Intel.

/arch:AVX2
Habilita Intel Advanced Vector Extensions 2.

/arch:AVX512
Habilita intel Advanced Vector Extensions 512.

/arch:AVX10.1
Habilita intel Advanced Vector Extensions 10 versión 1.

Comentarios

La opción /arch habilita o deshabilita el uso de determinadas extensiones de conjunto de instrucciones, especialmente para el cálculo de vectores, que están disponibles en procesadores de Intel y AMD. En general, los procesadores más recientes pueden admitir más extensiones que los procesadores antiguos. Antes de ejecutar código mediante una extensión de conjunto de instrucciones, debe consultar la documentación del procesador en cuestión o probar la compatibilidad con la extensión mediante __cpuid. También puede usar el __check_isa_support intrínseco para comprobar si hay características de CPU usadas con más frecuencia.

/arch solo afecta a la generación de código de las funciones nativas. Cuando se usa /clr para compilar, /arch no tiene ningún efecto en la generación de código para las funciones administradas.

Las opciones /arch hacen referencia a las extensiones de conjunto de instrucciones con las siguientes características:

  • IA32 es el conjunto de instrucciones x86 de 32 bits heredado sin ninguna operación vectorial y usando x87 para cálculos de punto flotante.

  • SSE permite el cálculo con vectores de hasta cuatro valores de punto flotante con precisión sencilla. También se han agregado las instrucciones de punto flotante escalar correspondientes.

  • SSE2 permite el cálculo con vectores de 128 bits de valores enteros con precisión sencilla, precisión doble y 1, 2, 4 u 8 bytes. También se han agregado instrucciones escalares con precisión doble.

  • AVX introdujo una codificación alternativa de instrucciones para instrucciones escalares y vectoriales de punto flotante. Permite vectores de 128 bits o 256 bits y extiende a cero todos los resultados vectoriales hasta el tamaño de vector completo. Para la compatibilidad heredada, las instrucciones vectoriales de estilo SSE conservan todos los bits más allá del bit 127. La mayoría de las operaciones de punto flotante se extienden hasta los 256 bits.

  • AVX2 extiende la mayoría de las operaciones de entero a vectores de 256 bits y permite el uso de instrucciones de multiplicación y suma fusionadas (FMA).

  • AVX512 introdujo otro formulario de codificación de instrucciones que permite vectores de 512 bits, enmascaramiento, redondeo/difusión insertados y nuevas instrucciones. La longitud de vector predeterminada para AVX512 es de 512 bits y se puede cambiar a 256 bits mediante la /vlen marca .

  • AVX10.1 agrega más instrucciones sobre AVX-512. La longitud de vector predeterminada para AVX10.1 es de 256 bits y se puede cambiar a 512 bits mediante la /vlen marca .

El optimizador elige cuándo y cómo usar instrucciones vectoriales en función del /arch que se especifique. Los cálculos de punto flotante escalares se suelen realizar con instrucciones SSE o AVX cuando estén disponibles. Algunas convenciones de llamada especifican pasar argumentos de punto flotante en la pila x87 y, como resultado, el código puede usar una combinación de instrucciones x87 y SSE/AVX para cálculos de punto flotante. Las instrucciones de vector entero también se pueden usar para algunas operaciones de enteros de 64 bits cuando están disponibles.

Además de las instrucciones escalares de vector y punto flotante, cada opción /arch también puede habilitar el uso de otras instrucciones no vectoriales asociadas a esa opción. Un ejemplo de ello es la familia de instrucciones CMOVcc, que aparece por primera vez en los procesadores Intel Pentium Pro. Dado que las instrucciones SSE llegan con el procesador Intel Pentium III posterior, las instrucciones CMOVcc se pueden generar excepto cuando se especifica /arch:IA32.

Normalmente, las operaciones de punto flotante se redondean a precisión doble (64 bits) en código x87, pero se puede usar _controlfp para modificar la palabra de control FP; esto incluye establecer el control de precisión en precisión extendida (80 bits) o precisión sencilla (32 bits). Para obtener más información, consulte _control87, _controlfp, __control87_2. SSE y AVX tienen instrucciones independientes de precisión sencilla y de doble precisión para cada operación, por lo que no hay ningún equivalente para el código SSE/AVX. Puede alterar cómo se redondean los resultados cuando el resultado de una operación de punto flotante se usa directamente en otro cálculo en lugar de asignarlo a una variable de usuario. Considere la posibilidad de hacer estas operaciones:

r = f1 * f2 + d;  // Different results are possible on SSE/SSE2.

Con asignación explícita:

t = f1 * f2;   // Do f1 * f2, round to the type of t.
r = t + d;     // This should produce the same overall result
               // whether x87 stack is used or SSE/SSE2 is used.

/arch y /QIfist no se pueden usar juntos. La opción /QIfist cambia el comportamiento de redondeo de la conversión de punto flotante a entero. El comportamiento predeterminado es truncar (redondear hacia cero), mientras que la opción especifica el /QIfist uso del modo de redondeo del entorno de punto flotante. Dado que la opción cambia el comportamiento de todas las conversiones de enteros de punto flotante a entero, /QIfist está en desuso. En una compilación para SSE o AVX, puede redondear un valor de punto flotante a un entero mediante el modo de redondeo del entorno de punto flotante y una secuencia de funciones intrínsecas:

int convert_float_to_int(float x) {
    return _mm_cvtss_si32(_mm_set_ss(x));
}

int convert_double_to_int(double x) {
    return _mm_cvtsd_si32(_mm_set_sd(x));
}

Las _M_IX86_FPmacros , __AVX__, __AVX2__, __AVX512CD____AVX512F__, __AVX512BW__, __AVX512DQ__, , __AVX512VL__y __AVX10_VER__ indican qué opción del compilador, si existe, /arch se usó. Para obtener más información, consulte Macros predefinidas. La /arch:AVX2 opción y __AVX2__ la macro se introdujeron en Visual Studio 2013 Update 2, versión 12.0.34567.1. La compatibilidad limitada con /arch:AVX512 se incorporó en Visual Studio 2017 y se amplió en Visual Studio 2019. Se ha agregado compatibilidad con /arch:AVX10.1 en Visual Studio 2022.

Para establecer la opción del compilador /arch en 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. Seleccione la página de propiedades Propiedades de configuración>C/C++>Generación de código.

  3. Modifique la propiedad Habilitar conjunto de instrucciones mejorado.

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

Consulte también

/arch (Arquitectura de CPU mínima)
Opciones del compilador de MSVC
Sintaxis de línea de comandos del compilador de MSVC