__check_isa_support, __check_arch_support

Article
11/12/2024

Section spécifique à Microsoft

__check_isa_support - détecte si le processeur prend en charge la fonctionnalité ISA spécifiée et la version AVX10 au moment de l’exécution. __check_arch_support - détecte si l’indicateur arch (voir /arch (x86), /arch (x64)) prend en charge la fonctionnalité ISA spécifiée et la version AVX10 au moment de la compilation.

Syntaxe

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

Paramètres

feature
[in] Fonctionnalité ISA à vérifier.

avx10_version
[in] Version d’AVX10 à vérifier. 0 si la vérification de version AVX10 n’est pas requise.

Valeur retournée

__check_isa_support retourne true si le processeur prend en charge feature et avx10_version au moment de l’exécution, false sinon. __check_arch_supportretourne true si l’indicateur prend en charge feature et avx10_version au moment de la /arch compilation, false sinon.

Spécifications

Intrinsic	Architecture
`__check_isa_support`	x86, x64
`__check_arch_support`	x86, x64

Fichier d’en-tête <immintrin.h>

Notes

L’intrinsèque __check_isa_support offre une alternative plus rapide à l’intrinsèque __cpuid pour rechercher dynamiquement les fonctionnalités processeur les plus fréquemment utilisées. L’intrinsèque __check_arch_support fournit une alternative à la sélection de predefined macros code de temps de compilation basée sur les extensions ISA.

Les valeurs de fonctionnalité suivantes peuvent être utilisées dans ces intrinsèques. Ces valeurs sont définies dans isa_availability.h.

Nom de la valeur de la fonctionnalité	Description
`__IA_SUPPORT_VECTOR128`	Instructions vectorielles avec des longueurs allant jusqu’à 128 bits. Cette fonctionnalité est activée pour les extensions SSE2 ou ultérieures
`__IA_SUPPORT_VECTOR256`	Instructions vectorielles avec des longueurs allant jusqu’à 256 bits. Cette fonctionnalité est activée pour les extensions AVX2 ou ultérieures
`__IA_SUPPORT_VECTOR512`	Instructions vectorielles avec des longueurs allant jusqu’à 512 bits. Cette fonctionnalité est activée pour les extensions AVX-512 ou ultérieures
`__IA_SUPPORT_AVX10`	Prise en charge d’AVX10. Cette fonctionnalité est activée pour les extensions AVX10.1 ou ultérieures
`__IA_SUPPORT_SSE42`	Prise en charge de SSE4.2
`__IA_SUPPORT_SV128X`	Instructions AVX-512 pour scalaire de 128 bits. Peut être utilisé pour signaler que certaines instructions AVX-512 utiles telles que les conversions peuvent être utilisées dans le code scalaire
`__IA_SUPPORT_AVX10_2`	Prise en charge d’AVX10.2
`__IA_SUPPORT_APX`	Prise en charge d’APX
`__IA_SUPPORT_FP16`	Prise en charge des instructions à virgule flottante demi-précision

Plusieurs valeurs de fonctionnalité peuvent être combinées à l’aide de l’opérateur OR(|).

L’intrinsèque peut toujours être évaluée au moment de la compilation. Ainsi __check_arch_support , l’utilisation dans le code optimisé n’ajoute aucune instruction supplémentaire à exécuter. La prise en charge de ces intrinsèques a été ajoutée dans Visual Studio 2022 version 17.10.

Exemple

Cet exemple utilise des instructions AVX-512 256 bits pour vectoriser la conversion de valeurs de double précision en valeurs entières signées 64 bits. La boucle de fin pour convertir les valeurs sources non gérées par le code vectoriel est également utilisée si le code vectoriel ne peut pas être exécuté. La prise en charge au moment de la compilation est vérifiée avant la prise en charge du runtime afin qu’une vérification du runtime puisse être évitée si possible.

// 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

FIN de la section spécifique à Microsoft

Voir aussi

Intrinsèques du compilateur

Partager via