Dela via

/arch (x86)

Anger arkitekturen för kodgenerering på x86. Dessa växlar gäller för x86-målversionen (32-bitars) av kompilatorn. Mer information om /arch andra målarkitekturer finns i /arch (ARM64),/arch (x64) och /arch (ARM).

Syntax

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

Argumentpunkter

/arch:IA32
Anger inga förbättrade instruktioner och anger även x87 för flyttalsberäkningar.

/arch:SSE
Aktiverar Intel Streaming SIMD-tillägg.

/arch:SSE2
Aktiverar Intel Streaming SIMD-tillägg 2. Standardinstruktionsuppsättningen är SSE2 om inget /arch alternativ har angetts.

/arch:AVX
Aktiverar Intel Advanced Vector Extensions.

/arch:AVX2
Aktiverar Intel Advanced Vector Extensions 2.

/arch:AVX512
Aktiverar Intel Advanced Vector Extensions 512.

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

/arch:AVX10.2
Aktiverar Intel Advanced Vector Extensions 10 version 2.

Anmärkningar

Alternativet /arch aktiverar eller inaktiverar användningen av vissa tillägg för instruktionsuppsättningar, särskilt för vektorberäkning, som finns i processorer från Intel och AMD. I allmänhet kan nyligen introducerade processorer ha stöd för tillägg utöver de som stöds av äldre processorer. Du bör läsa dokumentationen för en viss processor eller testa om det finns stöd för tillägg för instruktionsuppsättningar innan __cpuid du kör kod med hjälp av ett tillägg för instruktionsuppsättningar. Du kan också använda den inbyggda för __check_isa_support att söka efter mer frekvent använda CPU-funktioner.

/arch påverkar endast kodgenerering för inbyggda funktioner. När du använder /clr för att kompilera har /arch ingen effekt på kodgenereringen för hanterade funktioner.

Alternativen /arch refererar till tillägg för instruktionsuppsättningar med följande egenskaper:

  • IA32 är den äldre 32-bitars x86-instruktionsuppsättningen utan några vektoroperationer och med x87 för flyttalsberäkningar.

  • SSE Möjliggör beräkning med vektorer på upp till fyra flyttalsvärden med enkel precision. Motsvarande skalära flyttalsinstruktioner lades också till.

  • SSE2 Tillåter beräkning med 128-bitars vektorer med enkelprecision, dubbelprecision och heltalsvärden på 1, 2, 4 eller 8 byte. Skalära instruktioner med dubbel precision lades också till.

  • AVX Introducerade en alternativ instruktionskodning för vektor- och flyttalsskalära instruktioner. Den tillåter vektorer med antingen 128 bitar eller 256 bitar, och nollutvidgningar alla vektorresultat till den fulla vektorstorleken. (För äldre kompatibilitet bevarar SSE-stilvektorinstruktioner alla bitar utöver bit 127.) De flesta flyttalsåtgärder utökas till 256 bitar.

  • AVX2 utökar de flesta heltalsåtgärder till 256-bitars vektorer och gör det möjligt att använda FMA-instruktioner (Fused Multiply-Add).

  • AVX512 Introducerade en annan instruktionskodningsform som tillåter 512-bitars vektorer, maskering, inbäddad avrundning/sändning och nya instruktioner. Standardvektorlängden för AVX512 är 512 bitar och kan ändras till 256 bitar med hjälp av flaggan /vlen .

  • AVX10.1 lägger till fler instruktioner ovanpå AVX-512. Standardvektorlängden för AVX10.1 är 256 bitar och kan ändras till 512 bitar med hjälp av flaggan /vlen . Det här alternativet introducerades i Visual Studio 2022 17.13.

  • AVX10.2 expanderar instruktionsuppsättningen som introducerades i AVX10.1. Standardvektorlängden för AVX10.2 är 256 bitar och kan ökas till 512 bitar med hjälp av /vlen flaggan. AVX10.2 lägger till instruktioner som är förbättringar av äldre instruktioner och instruktioner för medieacceleration. Mer information om de nya instruktionerna finns i avsnitt 3.1.4 i Arkitekturspecifikationen för Intel Advanced Vector Extensions 10.2 AI-relaterade instruktioner i dokumentet stöds via MSVC-inbyggda objekt i stället för att genereras direkt eftersom MSVC inte stöder deras datatyper. Det här kompilatoralternativet introducerades i Visual Studio 2026.

Optimeraren väljer när och hur vektorinstruktioner ska användas beroende på vad som /arch anges. Skalära flyttalsberäkningar utförs vanligtvis med SSE- eller AVX-instruktioner när de är tillgängliga. Vissa anropskonventioner anger att flyttalsargument skickas på x87-stacken, och därför kan koden använda en blandning av både x87- och SSE/AVX-instruktioner för flyttalsberäkningar. Heltalsvektorinstruktioner kan också användas för vissa 64-bitars heltalsåtgärder när de är tillgängliga.

Förutom vektor- och flyttalsskalarinstruktionerna kan varje /arch alternativ även aktivera användning av andra icke-bevektorinstruktioner som är associerade med det alternativet. Ett exempel är instruktionsfamiljen CMOVcc som först dök upp på Intel Pentium Pro-processorerna. Eftersom SSE-instruktioner introducerades med den efterföljande Intel Pentium III-processorn kan CMOVcc-instruktioner genereras förutom när /arch:IA32 det anges.

Flyttalsåtgärder avrundas normalt till dubbel precision (64-bitars) i x87-kod, men du kan använda _controlfp för att ändra FP-kontrollordet, inklusive att ställa in precisionskontrollen på utökad precision (80-bitars) eller enkel precision (32-bitars). Mer information finns i _control87, _controlfp, __control87_2. SSE och AVX har separata instruktioner med enkel precision och dubbel precision för varje operation, så det finns ingen motsvarighet för SSE/AVX-kod. Det kan ändra hur resultat avrundas när resultatet av en flyttalsoperation används direkt i ytterligare beräkning i stället för att tilldela det till en användarvariabel. Tänk på följande åtgärder:

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

Med explicit tilldelning:

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 och /QIfist kan inte användas tillsammans. Alternativet /QIfist ändrar avrundningsbeteendet för konvertering av flyttal till heltal. Standardbeteendet är att trunkera (avrunda mot noll), medan /QIfist alternativet anger användning av avrundningsläget för flyttalsmiljön . Eftersom alternativet ändrar beteendet för alla flyttal till heltalskonverteringar /QIfist är inaktuellt. När du kompilerar för SSE eller AVX kan du avrunda ett flyttalsvärde till ett heltal med hjälp av avrundningsläget för flyttalsmiljön med hjälp av en inbyggd funktionssekvens:

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

Makrona _M_IX86_FP, __AVX__, __AVX2__, __AVX512F____AVX512CD____AVX512BW____AVX512DQ____AVX512VL__, och __AVX10_VER__ makron anger vilket, om något, /arch kompilatoralternativ som användes. Mer information finns i fördefinierade makron. Alternativet /arch:AVX2 och __AVX2__ makrot introducerades i Visual Studio 2013 Update 2, version 12.0.34567.1. Begränsat stöd för /arch:AVX512 lades till i Visual Studio 2017 och utökades i Visual Studio 2019. Stöd för /arch:AVX10.1 lades till i Visual Studio 2022.

Så här anger du /arch kompilatoralternativet i Visual Studio

  1. Öppna dialogrutan egenskapssidor för projektet. Mer information finns i Ange C++-kompilator- och byggegenskaper i Visual Studio.

  2. Välj egenskapssidan Konfigurationsegenskaper>C/C++>Kodgenerering.

  3. Ändra egenskapen Aktivera förbättrad instruktionsuppsättning .

Så här ställer du in det här kompilatoralternativet programmatiskt

Se även

/arch (Minsta CPU-arkitektur)
MSVC-kompilatoralternativ
kommandoradssyntax för MSVC-kompilatorn

  • Last updated on