__check_isa_support, __check_arch_support

Seção específica da Microsoft

__check_isa_support - detecta se o processador suporta o recurso ISA especificado e a versão AVX10 em tempo de execução. __check_arch_support- detecta se o sinalizador de arquitetura (consulte /arch (x86), /arch (x64)) suporta o recurso ISA especificado e a versão AVX10 em tempo de compilação.

Sintaxe

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

Parâmetros

feature
[em] ISA a ser verificado.

avx10_version
[em] Versão AVX10 para verificar. 0 se a verificação de versão do AVX10 não for necessária.

Valor retornado

__check_isa_support retorna true se o processador der suporte feature e avx10_version em tempo de execução, false caso contrário. __check_arch_support retorna true se o /arch sinalizador der suporte feature e avx10_version em tempo de compilação, false caso contrário.

Requisitos

Arquivo de cabeçalho <immintrin.h>

Comentários

O __check_isa_support intrínseco fornece uma alternativa mais rápida ao __cpuid intrínseco para verificar dinamicamente os recursos de CPU usados com mais frequência. O __check_arch_support intrínseco fornece uma alternativa para a predefined macros seleção de código em tempo de compilação com base em extensões ISA.

Os valores de recurso a seguir podem ser usados nesses intrínsecos. Esses valores são definidos em isa_availability.h.

Vários valores de feição podem ser combinados usando o operador OR(|).

O __check_arch_support intrínseco sempre pode ser avaliado em tempo de compilação, portanto, usá-lo em código otimizado não adiciona instruções extras a serem executadas. O suporte para esses intrínsecos foi adicionado no Visual Studio 2022 versão 17.10.

Exemplo

Este exemplo usa instruções AVX-512 de 256 bits para vetorizar a conversão de valores de precisão dupla em valores inteiros com sinal de 64 bits. O loop de cauda para converter quaisquer valores de origem não tratados pelo código vetorial também é usado caso o código vetorial não possa ser executado. O suporte em tempo de compilação é verificado antes do suporte em tempo de execução para que uma verificação em tempo de execução possa ser evitada, se possível.

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

Fim da seção específica da Microsoft

Confira também

Intrínsecos do compilador