Partager via

/arch (x86)

  • Article

Spécifie l'architecture pour la génération de code sur x86. Pour plus d’informations sur /arch les autres architectures cibles, consultez /arch (ARM64), /arch (x64) et /arch (ARM).

Syntaxe

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

Arguments

/arch:IA32
Ne spécifie aucune instruction améliorée et spécifie x87 pour les calculs à virgule flottante.

/arch:SSE
Active les extensions SIMD Intel Streaming.

/arch:SSE2
Active les extensions SIMD Intel Streaming 2. Le jeu d’instructions par défaut est SSE2 si aucune option n’est /arch spécifiée.

/arch:AVX
Active les extensions de vecteurs avancées Intel.

/arch:AVX2
Active Intel Advanced Vector Extensions 2.

/arch:AVX512
Active Intel Advanced Vector Extensions 512.

/arch:AVX10.1
Active Intel Advanced Vector Extensions 10 version 1.

Notes

L’option /arch active ou désactive l’utilisation de certaines extensions de jeu d’instructions, en particulier pour le calcul vectoriel, disponible dans les processeurs d’Intel et AMD. En général, les processeurs introduits plus récemment peuvent prendre en charge des extensions au-delà de celles prises en charge par les processeurs plus anciens. Vous devez consulter la documentation d’un processeur particulier ou tester la prise en charge de l’extension du jeu d’instructions à l’aide __cpuid de l’exécution du code à l’aide d’une extension de jeu d’instructions. Vous pouvez également utiliser l’intrinsèque __check_isa_support pour rechercher les fonctionnalités processeur plus fréquemment utilisées.

/arch affecte uniquement la génération de code pour les fonctions natives. Lorsque vous utilisez /clr pour compiler, /arch n’a aucun effet sur la génération de code pour les fonctions managées.

Les /arch options font référence aux extensions de jeu d’instructions avec les caractéristiques suivantes :

  • IA32 est l’ensemble d’instructions x86 32 bits héritée sans opérations vectorielles et l’utilisation de x87 pour les calculs à virgule flottante.

  • SSE permet le calcul avec des vecteurs allant jusqu’à quatre valeurs à virgule flottante simple précision. Les instructions scalaires correspondantes à virgule flottante ont également été ajoutées.

  • SSE2 permet le calcul avec des vecteurs 128 bits de valeurs entières à précision unique, double précision et 1, 2, 4 ou 8 octets. Des instructions scalaires à double précision ont également été ajoutées.

  • AVX a introduit un autre encodage d’instructions pour les instructions scalaires à virgule flottante et vectorielle. Il autorise les vecteurs de 128 bits ou de 256 bits, et zéro étend tous les résultats de vecteur à la taille complète du vecteur. (Pour la compatibilité héritée, les instructions vectorielles de style SSE conservent tous les bits au-delà du bit 127.) La plupart des opérations à virgule flottante sont étendues à 256 bits.

  • AVX2 étend la plupart des opérations entières à des vecteurs 256 bits et permet d’utiliser des instructions FMA (Fused Multiply-Add).

  • AVX512 a introduit un autre formulaire d’encodage d’instructions qui autorise les vecteurs 512 bits, le masquage, l’arrondi incorporé/diffusion et de nouvelles instructions. La longueur du vecteur par défaut est AVX512 de 512 bits et peut être modifiée en 256 bits à l’aide de l’indicateur /vlen .

  • AVX10.1 ajoute d’autres instructions en plus de AVX-512. La longueur du vecteur par défaut est AVX10.1 de 256 bits et peut être modifiée en 512 bits à l’aide de l’indicateur /vlen .

L’optimiseur choisit quand et comment utiliser des instructions vectorielles en fonction de ce qui /arch est spécifié. Les calculs à virgule flottante scalaire sont généralement effectués avec des instructions SSE ou AVX lorsqu’elles sont disponibles. Certaines conventions d’appel spécifient le passage d’arguments à virgule flottante sur la pile x87 et, par conséquent, votre code peut utiliser un mélange d’instructions x87 et SSE/AVX pour les calculs à virgule flottante. Les instructions de vecteur entier peuvent également être utilisées pour certaines opérations entières 64 bits lorsqu’elles sont disponibles.

Outre les instructions scalaires vectorielles et à virgule flottante, chaque /arch option peut également activer l’utilisation d’autres instructions non vectorielles associées à cette option. Par exemple, la famille d’instructions CMOVcc qui est apparue pour la première fois sur les processeurs Intel Xeonum Pro. Étant donné que les instructions SSE ont été introduites avec le processeur Intel Xeonum III suivant, les instructions CMOVcc peuvent être générées, sauf lorsqu’elles /arch:IA32 sont spécifiées.

Les opérations à virgule flottante sont normalement arrondies à une double précision (64 bits) dans du code x87, mais vous pouvez utiliser _controlfp pour modifier le mot de contrôle FP, notamment définir le contrôle de précision sur une précision étendue (80 bits) ou une seule précision (32 bits). Pour plus d’informations, consultez _control87, . __control87_2_controlfp SSE et AVX ont des instructions distinctes à précision unique et double précision pour chaque opération. Il n’existe donc aucun équivalent pour le code SSE/AVX. Il peut modifier la façon dont les résultats sont arrondis lorsque le résultat d’une opération à virgule flottante est utilisé directement dans un calcul supplémentaire au lieu de l’affecter à une variable utilisateur. Tenez compte des opérations suivantes :

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

Avec une affectation explicite :

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 et /QIfist ne peut pas être utilisé ensemble. L’option /QIfist modifie le comportement d’arrondi de la conversion à virgule flottante en conversion entière. Le comportement par défaut consiste à tronquer (arrondi à zéro), tandis que l’option spécifie l’utilisation /QIfist du mode d’arrondi de l’environnement à virgule flottante. Étant donné que l’option modifie le comportement de toutes les conversions à virgule flottante en conversions entières, /QIfist est déconseillée. Lors de la compilation pour SSE ou AVX, vous pouvez arrondir une valeur à virgule flottante à un entier à l’aide du mode d’arrondi de l’environnement à virgule flottante à l’aide d’une séquence de fonctions intrinsèque :

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

Les _M_IX86_FPmacros , __AVX512F____AVX512BW____AVX2____AVX____AVX512DQ____AVX512VL____AVX512CD____AVX10_VER__ le cas échéant, /arch indiquent quelle option du compilateur a été utilisée. Pour plus d’informations, consultez Macros prédéfinies. L’option /arch:AVX2 et __AVX2__ la macro ont été introduites dans Visual Studio 2013 Update 2, version 12.0.34567.1. La prise en charge limitée de /arch:AVX512 Visual Studio 2017 a été ajoutée et développée dans Visual Studio 2019. La prise en charge a /arch:AVX10.1 été ajoutée dans Visual Studio 2022.

Pour définir l’option du /arch compilateur dans Visual Studio

  1. Ouvrez la boîte de dialogue Pages de propriétés du projet. Pour plus d’informations, consultez Définir le compilateur C++ et les propriétés de build dans Visual Studio.

  2. Sélectionnez la page de propriétés De configuration>C/C++>Génération de code.

  3. Modifiez la propriété Enable Enhanced Instruction Set .

Pour définir cette option du compilateur par programmation

Voir aussi

/arch (Architecture processeur minimale)
Options du compilateur MSVC
Syntaxe de ligne de commande du compilateur MSVC