Condividi tramite

/arch (x86)

  • Articolo

Specifica l'architettura per la generazione del codice su piattaforme x86. Per altre informazioni su altre architetture di destinazione, vedere (ARM64), (x64) e (ARM).For more information on /arch for other target architectures, see /arch (ARM64), /arch (x64), and /arch (ARM).

Sintassi

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

Argomenti

/arch:IA32
Non specifica istruzioni avanzate e specifica x87 per i calcoli a virgola mobile.

/arch:SSE
Abilita le estensioni SIMD di Intel Streaming.

/arch:SSE2
Abilita le estensioni SIMD di Intel Streaming 2. Il set di istruzioni predefinito è SSE2 se non viene specificata alcuna /arch opzione.

/arch:AVX
Abilita Le estensioni vettoriali avanzate Intel.

/arch:AVX2
Abilita Intel Advanced Vector Extensions 2.

/arch:AVX512
Abilita Intel Advanced Vector Extensions 512.

/arch:AVX10.1
Abilita Intel Advanced Vector Extensions 10 versione 1.

Osservazioni:

L'opzione /arch abilita o disabilita l'uso di determinate estensioni del set di istruzioni, in particolare per il calcolo vettoriale, disponibile nei processori intel e AMD. In generale, i processori introdotti più di recente possono supportare estensioni oltre quelle supportate dai processori meno recenti. È consigliabile consultare la documentazione relativa a un particolare processore o test per il supporto dell'estensione del set di istruzioni usando __cpuid prima di eseguire il codice usando un'estensione del set di istruzioni. È anche possibile usare l'intrinseco __check_isa_support per verificare la presenza di funzionalità della CPU usate più di frequente.

/arch influisce solo sulla generazione del codice per le funzioni native. Quando si usa /clr per la compilazione, /arch non ha alcun effetto sulla generazione di codice per le funzioni gestite.

Le /arch opzioni fanno riferimento alle estensioni del set di istruzioni con le caratteristiche seguenti:

  • IA32 è l'istruzione x86 a 32 bit legacy senza operazioni vettoriali e l'uso di x87 per i calcoli a virgola mobile.

  • SSE consente il calcolo con vettori fino a quattro valori a virgola mobile e precisione singola. Sono state aggiunte anche le istruzioni scalari a virgola mobile corrispondenti.

  • SSE2 consente il calcolo con vettori a 128 bit di valori integer a precisione singola, precisione doppia e 1, 2, 4 o integer a 8 byte. Sono state aggiunte anche istruzioni scalari a precisione doppia.

  • AVX è stata introdotta una codifica di istruzioni alternative per istruzioni scalari vettoriali e a virgola mobile. Consente vettori di 128 bit o 256 bit ed estende tutti i risultati del vettore alla dimensione del vettore completa. Per la compatibilità legacy, le istruzioni del vettore in stile SSE mantengono tutti i bit oltre il bit 127. La maggior parte delle operazioni a virgola mobile viene estesa a 256 bit.

  • AVX2 estende la maggior parte delle operazioni integer a vettori a 256 bit e consente l'uso delle istruzioni Fused Multiply-Add (FMA).

  • AVX512 ha introdotto un altro modulo di codifica delle istruzioni che consente vettori a 512 bit, mascheramento, arrotondamento/trasmissione incorporati e nuove istruzioni. La lunghezza del vettore predefinita per AVX512 è 512 bit e può essere modificata in 256 bit usando il /vlen flag .

  • AVX10.1 aggiunge altre istruzioni all'inizio di AVX-512. La lunghezza del vettore predefinita per AVX10.1 è di 256 bit e può essere modificata in 512 bit usando il /vlen flag .

L'utilità di ottimizzazione sceglie quando e come usare le istruzioni vettoriali in base a quanto /arch specificato. I calcoli a virgola mobile scalari vengono in genere eseguiti con istruzioni SSE o AVX, se disponibili. Alcune convenzioni di chiamata specificano il passaggio di argomenti a virgola mobile nello stack x87 e, di conseguenza, il codice può usare una combinazione di istruzioni x87 e SSE/AVX per i calcoli a virgola mobile. Le istruzioni del vettore integer possono essere usate anche per alcune operazioni integer a 64 bit, se disponibili.

Oltre alle istruzioni scalari a virgola mobile e vettoriale, ogni /arch opzione può anche abilitare l'uso di altre istruzioni non vettoriali associate a tale opzione. Un esempio è la famiglia di istruzioni CMOVcc che è apparsa per la prima volta sui processori Intel Pentium Pro. Poiché le istruzioni SSE sono state introdotte con il processore Intel Pentium III successivo, le istruzioni CMOVcc possono essere generate tranne quando /arch:IA32 viene specificato.

Le operazioni a virgola mobile vengono in genere arrotondate a precisione doppia (64 bit) nel codice x87, ma è possibile usare _controlfp per modificare la parola di controllo FP, inclusa l'impostazione del controllo precisione su precisione estesa (80 bit) o precisione singola (a 32 bit). Per altre informazioni, vedere , , __control87_2_controlfp._control87 SSE e AVX dispongono di istruzioni separate a precisione singola e a precisione doppia per ogni operazione, quindi non esiste un equivalente per il codice SSE/AVX. Può modificare il modo in cui i risultati vengono arrotondati quando il risultato di un'operazione a virgola mobile viene usato direttamente in un ulteriore calcolo anziché assegnarlo a una variabile utente. Considerare le operazioni seguenti:

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

Con assegnazione esplicita:

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 e /QIfist non possono essere usati insieme. L'opzione /QIfist modifica il comportamento di arrotondamento della conversione a virgola mobile in integer. Il comportamento predefinito consiste nel troncamento (arrotondamento verso zero), mentre l'opzione /QIfist specifica l'uso della modalità di arrotondamento dell'ambiente a virgola mobile. Poiché l'opzione modifica il comportamento di tutte le conversioni a virgola mobile in integer, /QIfist è deprecato. Durante la compilazione per SSE o AVX, è possibile arrotondare un valore a virgola mobile a un intero usando la modalità di arrotondamento dell'ambiente a virgola mobile usando una sequenza di funzioni intrinseche:

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

Le _M_IX86_FPmacro , __AVX2____AVX__, __AVX512F____AVX512DQ____AVX512BW____AVX512VL____AVX512CD__e __AVX10_VER__ indicano quale opzione del compilatore, se presente, /arch è stata usata. Per altre informazioni, vedere Macro predefinite. L'opzione /arch:AVX2 e __AVX2__ la macro sono state introdotte in Visual Studio 2013 Update 2, versione 12.0.34567.1. È stato aggiunto un supporto limitato per /arch:AVX512 in Visual Studio 2017 ed è stato espanso in Visual Studio 2019. Il supporto per /arch:AVX10.1 è stato aggiunto in Visual Studio 2022.

Per impostare l'opzione del /arch compilatore in Visual Studio

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

  2. Selezionare la pagina delle proprietà Proprietà>di configurazione C/C++>Generazione codice.

  3. Modificare la proprietà Enable Enhanced Instruction Set .

Per impostare l'opzione del compilatore a livello di codice

Vedi anche

/arch (Architettura cpu minima)
Opzioni del compilatore MSVC
Sintassi della riga di comando del compilatore MSVC