__check_isa_support, __check_arch_support

Articolo
11/12/2024

Sezione specifica Microsoft

__check_isa_support : rileva se il processore supporta la funzionalità ISA specificata e la versione AVX10 in fase di esecuzione. __check_arch_support - rileva se il flag arch (vedere /arch (x86), /arch (x64)) supporta la funzionalità ISA specificata e la versione AVX10 in fase di compilazione.

Sintassi

_Bool __check_isa_support(
   unsigned feature,
   unsigned avx10_version
);

_Bool __check_arch_support(
   unsigned feature,
   unsigned avx10_version
);

bool __check_isa_support(
   unsigned feature,
   unsigned avx10_version
);

bool __check_arch_support(
   unsigned feature,
   unsigned avx10_version
);

Parametri

feature
[in] Funzionalità ISA da controllare.

avx10_version
[in] Versione di AVX10 da controllare. 0 se il controllo della versione di AVX10 non è obbligatorio.

Valore restituito

__check_isa_support restituisce true se il processore supporta feature e avx10_version in fase di esecuzione; in caso contrario, false . __check_arch_support restituisce true se il /arch flag supporta feature e avx10_version in fase di compilazione; in caso contrario, false .

Requisiti

Intrinsic	Architettura
`__check_isa_support`	x86, x64
`__check_arch_support`	x86, x64

File di intestazione <immintrin.h>

Osservazioni:

L'intrinseco __check_isa_support offre un'alternativa più veloce all'intrinseco __cpuid per controllare in modo dinamico le funzionalità della CPU usate più di frequente. L'intrinseco __check_arch_support fornisce un'alternativa alla predefined macros selezione del codice in fase di compilazione in base alle estensioni ISA.

In questi oggetti intrinseci è possibile usare i valori di funzionalità seguenti. Questi valori sono definiti in isa_availability.h.

Nome valore funzionalità	Descrizione
`__IA_SUPPORT_VECTOR128`	Istruzioni vettoriali con lunghezze fino a 128 bit. Questa funzionalità è abilitata per le estensioni SSE2 o successive
`__IA_SUPPORT_VECTOR256`	Istruzioni vettoriali con lunghezze fino a 256 bit. Questa funzionalità è abilitata per le estensioni AVX2 o successive
`__IA_SUPPORT_VECTOR512`	Istruzioni vettoriali con lunghezze fino a 512 bit. Questa funzionalità è abilitata per le estensioni AVX-512 o successive
`__IA_SUPPORT_AVX10`	Supporto di AVX10. Questa funzionalità è abilitata per le estensioni AVX10.1 o successive
`__IA_SUPPORT_SSE42`	Supporto di SSE4.2
`__IA_SUPPORT_SV128X`	Istruzioni AVX-512 per scalare di 128 bit. Può essere usato per segnalare che alcune istruzioni AVX-512 utili come le conversioni possono essere usate nel codice scalare
`__IA_SUPPORT_AVX10_2`	Supporto di AVX10.2
`__IA_SUPPORT_APX`	Supporto APX
`__IA_SUPPORT_FP16`	Supporto delle istruzioni a virgola mobile a metà precisione

È possibile combinare più valori di funzionalità usando l'operatore OR(|).

L'intrinseco __check_arch_support può sempre essere valutato in fase di compilazione, quindi l'uso nel codice ottimizzato non aggiunge istruzioni aggiuntive da eseguire. Il supporto per questi intrinseci è stato aggiunto in Visual Studio 2022 versione 17.10.

Esempio

Questo esempio usa istruzioni AVX-512 a 256 bit per vettorizzare la conversione di valori con precisione doppia in valori integer con segno a 64 bit. Il ciclo tail per la conversione di qualsiasi valore di origine non gestito dal codice vettoriale viene usato anche nel caso in cui il codice vettoriale non possa essere eseguito. Il supporto in fase di compilazione viene controllato prima del supporto del runtime in modo che un controllo di runtime possa essere evitato, se possibile.

// Compile this test with: /EHsc /O2
#include <iostream>
#include <vector>
#include <immintrin.h>
#include <isa_availability.h>
using namespace std;

#define CHECK_INSTRUCTION_SUPPORT(a,v) \
        (__check_arch_support((a),(v)) || __check_isa_support((a),(v)))

int main()
{
    vector<double> input = {0.3, 1.4, 2.5, 3.6, 4.7, 5.8, 6.9, 8.0, 9.1, 11.14};
    vector<__int64> output(10, 0);
    int i = 0;

    if (CHECK_INSTRUCTION_SUPPORT(__IA_SUPPORT_SV128X | __IA_SUPPORT_VECTOR256, 0))
    {
        for (; i < input.size() - 4; i += 4)
        {
            __m256i values = _mm256_cvttpd_epi64(_mm256_load_pd(&input[i]));
            _mm256_storeu_epi64((void*)&output[i], values);
        }
    }
    for (; i < input.size(); i++)
    {
        output[i] = input[i];
    }

    for (i = 0; i < output.size(); i++) {
        cout << "output[" << i << "] = " << output[i] << endl;
    }
}

output[0] = 0
output[1] = 1
output[2] = 2
output[3] = 3
output[4] = 4
output[5] = 5
output[6] = 6
output[7] = 8
output[8] = 9
output[9] = 11

Fine sezione specifica Microsoft

Vedi anche

Intrinseci del compilatore

Condividi tramite