1 of 1

Instruções intrínsecas

Aprendendo sobre as instruções intrínsecas na arquitetura x86-64

As instruções intrínsecas é um recurso originalmente fornecido pelo compilador Intel C/C++ mas que também é implementado pelo GCC. Se tratam basicamente de tipos especiais e funções que são expandidas inline para alguma instrução do processador, ou seja, é basicamente uma alternativa mais prática e legível do que usar inline Assembly para tudo.

Usando instruções intrínsecas é possível obter o mesmo resultado de usar inline Assembly com a diferença de ter a sintaxe amigável de uma chamada de função.

Para usar instruções intrínsecas é necessário incluir o header <immintrin.h> onde ele declara as funções e os tipos.

Para entender apropriadamente as operações e tipos indicados aqui, sugiro que já tenha lido o tópico sobre SSE.

Tipos de dados

Os tipos de dados na tabela abaixo servem para indicar como os valores usados na instrução intrínseca serão armazenados.

Nomenclatura

A maioria das instruções intrínsecas (SIMD) seguem a seguinte convenção de notação:

_mm_<operação>_<sufixo>

Onde <operação> é a operação que será executada com os dados. O <sufixo> indica o tipo de dado na operação. A primeira ou as duas primeiras letras do sufixo indicam se o dado é packed (p), extended packed (ep) ou escalar (s). Os demais caracteres do sufixo indicam o tipo de dado, como mostra a tabela abaixo:

Exemplo:

double array[] = { 1.0, 2.0 };
__m128d data = _mm_load_pd(array);

Instruções

Abaixo irei listar apenas algumas instruções intrínsecas, em sua maioria relacionadas à tecnologia SSE. Para ver a lista completa sugiro que consulte a referência oficial da Intel no link abaixo:

https://software.intel.com/sites/landingpage/IntrinsicsGuide/

Algumas instruções intrínsecas não são compiladas para uma só instrução mas sim uma sequência de várias delas.

Operações load, store e extract

As operações load carregam um valor da memória para um registrador, o conteúdo que deve estar na memória apontada pelo argumento tem que estar de acordo com o tipo da instrução identificado pelo sufixo.

Operações store leem um ou mais dados do registrador e escrevem os mesmos no endereço passado como primeiro argumento.

Já a operação extract obtém um valor de uma parte do registrador identificado pelo valor imediato passado como segundo argumento. Esse valor é o índice do campo do registrador contando da direita para a esquerda começando em zero.

Exemplos:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  float number;
  float array[] = {1.0f, 2.0f, 3.0f, 4.0f};
  __m128 data = _mm_load_ps(array);

  _mm_store_ss(&number, data);
  printf("%f\n", number);
  return 0;
}

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int array[] = {111, 222, 333, 444};
  __m128i data = _mm_load_si128((__m128i *)array);

  int number = _mm_extract_epi32(data, 2);
  printf("%d\n", number);
  return 0;
}

Operações set

As instruções intrínsecas de set definem o valor de todos os campos do registrador ao mesmo tempo sem a necessidade de usar uma array para isso. Elas não são traduzidas para uma mas sim várias instruções em sequência, portanto pode haver uma penalidade de desempenho.

As operações set escalares (_mm_set_sd e_mm_set_ss) definem o valor da parte menos significativa do registrador e zeram os demais valores.

As duas operações abaixo definem todos os campos do registrador para o mesmo valor passado como argumento:

Exemplo:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  __m128i data = _mm_set_epi32(444, 333, 222, 111);

  int number = _mm_extract_epi32(data, 2);
  printf("%d\n", number);
  return 0;
}

Operações matemáticas

Exemplos:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int array[4];
  __m128i data1 = _mm_set_epi32(444, 333, 222, 111);
  __m128i data2 = _mm_set_epi32(111, 222, 333, 444);

  __m128i result = _mm_add_epi32(data1, data2);
  _mm_store_si128((__m128i *)array, result);
  printf("%d, %d, %d, %d\n", array[0], array[1], array[2], array[3]);
  return 0;
}

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  double array[2];
  __m128d data = _mm_set_pd(81.0, 625.0);

  __m128d result = _mm_sqrt_pd(data);
  _mm_store_pd(array, result);
  printf("%f, %f\n", array[0], array[1]);
  return 0;
}

Operações de randomização

As instruções intrínsecas abaixo leem um valor aleatório gerado por hardware:

A instrução rdrand escreve o valor aleatório obtido no ponteiro passado como argumento. Ela deve ser usada em um loop pois não há garantia de que ela irá obter de fato um valor. Se obter o valor a função retorna 1, caso contrário retorna 0.

Exemplo:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int value;

  while (!_rdrand32_step(&value))
    ;

  printf("Valor: %d\n", value);
  return 0;
}

Você deve compilar passando a flag -mrdrnd para o GCC para indicar que o processador suporta a tecnologia. Caso contrário você obterá um erro como este:

error: inlining failed in call to always_inline ‘_rdrand32_step’: target specific option mismatch

As instruções intrínsecas abaixo são utilizadas da mesma maneira que rdrand porém o valor aleatório não é gerado por hardware.

É necessário compilar com a flag -mrdseed para poder usar essas instruções intrínsecas.

Instruções intrínsecas

Aprendendo sobre as instruções intrínsecas na arquitetura x86-64

Usando instruções intrínsecas é possível obter o mesmo resultado de usar inline Assembly com a diferença de ter a sintaxe amigável de uma chamada de função.

Para usar instruções intrínsecas é necessário incluir o header <immintrin.h> onde ele declara as funções e os tipos.

Para entender apropriadamente as operações e tipos indicados aqui, sugiro que já tenha lido o tópico sobre SSE.

Tipos de dados

Os tipos de dados na tabela abaixo servem para indicar como os valores usados na instrução intrínseca serão armazenados.

Nomenclatura

A maioria das instruções intrínsecas (SIMD) seguem a seguinte convenção de notação:

_mm_<operação>_<sufixo>

Exemplo:

double array[] = { 1.0, 2.0 };
__m128d data = _mm_load_pd(array);

Instruções

https://software.intel.com/sites/landingpage/IntrinsicsGuide/

Algumas instruções intrínsecas não são compiladas para uma só instrução mas sim uma sequência de várias delas.

Operações load, store e extract

Operações store leem um ou mais dados do registrador e escrevem os mesmos no endereço passado como primeiro argumento.

Exemplos:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  float number;
  float array[] = {1.0f, 2.0f, 3.0f, 4.0f};
  __m128 data = _mm_load_ps(array);

  _mm_store_ss(&number, data);
  printf("%f\n", number);
  return 0;
}

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int array[] = {111, 222, 333, 444};
  __m128i data = _mm_load_si128((__m128i *)array);

  int number = _mm_extract_epi32(data, 2);
  printf("%d\n", number);
  return 0;
}

Operações set

As operações set escalares (_mm_set_sd e_mm_set_ss) definem o valor da parte menos significativa do registrador e zeram os demais valores.

As duas operações abaixo definem todos os campos do registrador para o mesmo valor passado como argumento:

Exemplo:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  __m128i data = _mm_set_epi32(444, 333, 222, 111);

  int number = _mm_extract_epi32(data, 2);
  printf("%d\n", number);
  return 0;
}

Operações matemáticas

Exemplos:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int array[4];
  __m128i data1 = _mm_set_epi32(444, 333, 222, 111);
  __m128i data2 = _mm_set_epi32(111, 222, 333, 444);

  __m128i result = _mm_add_epi32(data1, data2);
  _mm_store_si128((__m128i *)array, result);
  printf("%d, %d, %d, %d\n", array[0], array[1], array[2], array[3]);
  return 0;
}

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  double array[2];
  __m128d data = _mm_set_pd(81.0, 625.0);

  __m128d result = _mm_sqrt_pd(data);
  _mm_store_pd(array, result);
  printf("%f, %f\n", array[0], array[1]);
  return 0;
}

Operações de randomização

As instruções intrínsecas abaixo leem um valor aleatório gerado por hardware:

Exemplo:

#include <stdio.h>
#include <immintrin.h>

int main(void)
{
  int value;

  while (!_rdrand32_step(&value))
    ;

  printf("Valor: %d\n", value);
  return 0;
}

Você deve compilar passando a flag -mrdrnd para o GCC para indicar que o processador suporta a tecnologia. Caso contrário você obterá um erro como este:

error: inlining failed in call to always_inline ‘_rdrand32_step’: target specific option mismatch

As instruções intrínsecas abaixo são utilizadas da mesma maneira que rdrand porém o valor aleatório não é gerado por hardware.

É necessário compilar com a flag -mrdseed para poder usar essas instruções intrínsecas.