6.54 Использование векторных инструкций через встроенные функции

В некоторых целевых платформах набор инструкций содержит векторные SIMD-инструкции, которые работают с несколькими значениями, содержащимися в одном большом регистре одновременно. Например, на x86 можно использовать расширения MMX, 3DNow! и SSE таким образом.

Первый шаг при использовании этих расширений — предоставление необходимых типов данных. Это должно быть сделано с помощью соответствующего typedef:

typedef int v4si __attribute__ ((vector_size (16)));

Тип int задаёт базовый тип (который может быть typedef), а атрибут указывает размер вектора для переменной, измеряемый в байтах. Например, объявление выше приводит к тому, что компилятор устанавливает режим для типа v4si в 16 байт шириной и разделяет его на блоки по int байт. Для 32-битного int это означает вектор из 4 блоков по 4 байта, а соответствующий режим foo — V4SI.

Атрибут vector_size применим только к целочисленным и плавающим скалярам, хотя массивы, указатели и значения возвращаемых функций разрешены в сочетании с этим конструктом. В настоящее время разрешены только размеры, являющиеся положительными степенями двойки, кратными размеру базового типа.

Все основные целочисленные типы могут быть использованы в качестве базовых типов, как со знаком, так и без знака: char, short, int, long, long long. Кроме того, float и double могут быть использованы для создания векторов плавающей точки.

Указание комбинации, некорректной для текущей архитектуры, приводит к тому, что GCC синтезирует инструкции с более узким режимом. Например, если вы указываете переменную типа V4SI и ваша архитектура не поддерживает этот конкретный тип SIMD, GCC генерирует код, использующий 4 SIs.

Определенные таким образом типы могут быть использованы с подмножеством обычных операций C. В настоящее время GCC разрешает использование следующих операторов с этими типами: +, -, *, /, unary minus, ^, |, &, ~, %.

Операции ведут себя как C++ valarrays. Сложение определено как сложение соответствующих элементов операндов. Например, в коде ниже каждый из 4 элементов в a складывается с соответствующими 4 элементами в b, а полученный вектор сохраняется в c.

typedef int v4si __attribute__ ((vector_size (16)));

v4si a, b, c;

c = a + b;

Вычитание, умножение, деление и логические операции работают аналогичным образом. Аналогично, результат применения унарных операторов минус или дополнения к типу вектора — это вектор, элементы которого являются отрицательными или дополненными значениями соответствующих элементов в операнде.

Можно использовать операторы сдвига <<, >> для векторов целочисленного типа. Операция определяется следующим образом: {a0, a1, …, an} >> {b0, b1, …, bn} == {a0 >> b0, a1 >> b1, …, an >> bn}. В отличие от OpenCL, значения b не берутся неявно по модулю разрядности базового типа B, а поведение не определено, если какой-либо bi больше или равен B.

В отличие от скалярных операций в C и C++, операнды целочисленных векторных операций не подвергаются целочисленному продвижению.

Операнды бинарных векторных операций должны иметь одинаковое количество элементов.

Для удобства разрешается использовать бинарную векторную операцию, где один из операндов является скаляром. В этом случае компилятор преобразует скалярный операнд в вектор, где каждый элемент — это скаляр из операции. Преобразование происходит только в том случае, если скаляр может быть безопасно преобразован в тип элемента вектора. Рассмотрим следующий код.

typedef int v4si __attribute__ ((vector_size (16)));

v4si a, b, c;
long l;

a = b + 1;    /* a = b + {1,1,1,1}; */
a = 2 * b;    /* a = {2,2,2,2} * b; */

a = l + a;    /* Error, cannot convert long to int. */

Вектора можно индексировать, как если бы вектор был массивом с тем же количеством элементов и базовым типом. Доступ за пределами границ вызывает неопределённое поведение во время выполнения. Предупреждения о доступе за пределами границ для индексирования векторов можно включить с помощью -Warray-bounds.

Поддержка сравнения векторов с помощью стандартных операторов сравнения: ==, !=, <, <=, >, >=. Операнды сравнения могут быть выражениями векторов целочисленного или вещественного типа. Сравнение между векторами целочисленного типа и векторами вещественного типа не поддерживается. Результатом сравнения является вектор той же ширины и числа элементов, что и операнды сравнения, с целочисленным элементом со знаком.

Вектора сравниваются поэлементно, возвращая 0, когда сравнение ложно, и -1 (константа соответствующего типа, где все биты установлены) в противном случае. Рассмотрим следующий пример.

typedef int v4si __attribute__ ((vector_size (16)));

v4si a = {1,2,3,4};
v4si b = {3,2,1,4};
v4si c;

c = a >  b;     /* The result would be {0, 0,-1, 0}  */
c = a == b;     /* The result would be {0,-1, 0,-1}  */

В C++ доступен тернарный оператор ?:. a?b:c, где b и c — векторы одного типа, а a — целочисленный вектор с тем же количеством элементов одинакового размера, что и b и c, вычисляет все три аргумента и создаёт вектор {a[0]?b[0]:c[0], a[1]?b[1]:c[1], …}. Обратите внимание, что в отличие от OpenCL, a интерпретируется как a != 0 а не a < 0.

Как и в случае бинарных операций, этот синтаксис также принимается, когда один из b или c является скаляром, который затем преобразуется в вектор. Если оба b и c — скаляры, и тип true?b:c имеет тот же размер, что и тип элемента a, то b и c преобразуются в тип вектора, элементы которого имеют этот тип и имеют то же количество элементов, что и a.

В C++ доступны логические операторы !, &&, || для векторов. !v эквивалентно v == 0, a && b эквивалентно a!=0 & b!=0, а a || b эквивалентно a!=0 | b!=0. Для смешанных операций между скаляром s и вектором v, s && v эквивалентно s?v!=0:0 (оценка выполняется по принципу короткой цепочки) и v && s эквивалентно v!=0 & (s?-1:0).

Векторное переупорядочение доступно с использованием функций __builtin_shuffle (vec, mask) и __builtin_shuffle (vec0, vec1, mask).

Обе функции конструируют перестановку элементов из одного или двух векторов и возвращают вектор того же типа, что и входной(е) вектор(ы). mask — целочисленный вектор с той же шириной (W) и количеством элементов (N), что и выходной вектор.

Элементы входных векторов нумеруются в порядке памяти vec0 начиная с 0 и vec1 начиная с N.

Элементы mask рассматриваются по модулю N в случае с одним операндом и по модулю 2*N в случае с двумя операндами.

Рассмотрим следующий пример.

typedef int v4si __attribute__ ((vector_size (16)));

v4si a = {1,2,3,4};
v4si b = {5,6,7,8};
v4si mask1 = {0,1,1,3};
v4si mask2 = {0,4,2,5};
v4si res;

res = __builtin_shuffle (a, mask1);       /* res is {1,2,2,4}  */
res = __builtin_shuffle (a, b, mask2);    /* res is {1,5,3,6}  */

Обратите внимание, что __builtin_shuffle намеренно совместим по семантике с функциями OpenCL shuffle и shuffle2.

Вы можете объявлять переменные, использовать их в вызовах функций и возвращаемых значениях, а также в присваиваниях и некоторых преобразованиях типов. Вы можете указать тип вектора в качестве возвращаемого типа для функции. Типы векторов также могут использоваться в качестве аргументов функций. Возможно преобразование одного типа вектора в другой, при условии, что они имеют одинаковый размер (фактически, вы также можете преобразовывать векторы в другие типы данных того же размера).

Вы не можете выполнять операции между векторами различной длины или различной знаковости без преобразования типа.

Векторное переупорядочение доступно с помощью функции __builtin_shufflevector (vec1, vec2, index...).

vec1 и vec2 должны быть выражениями с векторным типом и совместимым типом элементов. Результатом __builtin_shufflevector является вектор с тем же типом элементов, что и vec1 и vec2, но с количеством элементов, равным числу указанных индексов.

Аргументы index представляют собой список целых чисел, которые указывают индексы элементов первых двух векторов, которые должны быть извлечены и возвращены в новом векторе. Эти индексы элементов нумеруются последовательно, начиная с первого вектора, продолжая во второй вектор.

Индекс -1 может использоваться для обозначения того, что соответствующий элемент в возвращаемом векторе является «независимым» и может быть свободно выбран для оптимизации генерируемой последовательности кода, выполняющей операцию перестановки.

Рассмотрим следующий пример.

typedef int v4si __attribute__ ((vector_size (16)));
typedef int v8si __attribute__ ((vector_size (32)));

v8si a = {1,-2,3,-4,5,-6,7,-8};
v4si b = __builtin_shufflevector (a, a, 0, 2, 4, 6); /* b is {1,3,5,7} */
v4si c = {-2,-4,-6,-8};
v8si d = __builtin_shufflevector (c, b, 4, 0, 5, 1, 6, 2, 7, 3); /* d is a */

Преобразование векторов доступно с помощью функции __builtin_convertvector (vec, vectype).

vec должно быть выражением с целочисленным или вещественным векторным типом, а vectype — целочисленным или вещественным векторным типом с тем же количеством элементов.

Результат имеет тип vectype и значение результата преобразования каждого элемента vec в тип элемента vectype.

Рассмотрим следующий пример.

typedef int v4si __attribute__ ((vector_size (16)));
typedef float v4sf __attribute__ ((vector_size (16)));
typedef double v4df __attribute__ ((vector_size (32)));
typedef unsigned long long v4di __attribute__ ((vector_size (32)));

v4si a = {1,-2,3,-4};
v4sf b = {1.5f,-2.5f,3.f,7.f};
v4di c = {1ULL,5ULL,0ULL,10ULL};
v4sf d = __builtin_convertvector (a, v4sf); /* d is {1.f,-2.f,3.f,-4.f} */
/* Equivalent of:
   v4sf d = { (float)a[0], (float)a[1], (float)a[2], (float)a[3] }; */
v4df e = __builtin_convertvector (a, v4df); /* e is {1.,-2.,3.,-4.} */
v4df f = __builtin_convertvector (b, v4df); /* f is {1.5,-2.5,3.,7.} */
v4si g = __builtin_convertvector (f, v4si); /* g is {1,-2,3,7} */
v4si h = __builtin_convertvector (c, v4si); /* h is {1,5,0,10} */

Иногда желательно писать код, используя смесь общих векторных операций (для ясности) и машинозависимых векторных встроенных функций (для доступа к векторным инструкциям, которые не доступны через общие встроенные функции). На x86 встроенные функции для целочисленных векторов обычно используют тот же тип вектора __m128i независимо от того, как они интерпретируют вектор, что делает необходимым приведение аргументов и возвращаемых значений из/в другие типы векторов. В C вы можете использовать тип union:

#include <immintrin.h>

typedef unsigned char u8x16 __attribute__ ((vector_size (16)));
typedef unsigned int  u32x4 __attribute__ ((vector_size (16)));

typedef union {
        __m128i mm;
        u8x16   u8;
        u32x4   u32;
} v128;

для переменных, которые могут использоваться как с встроенными операторами, так и с x86 встроенными функциями:

v128 x, y = { 0 };
memcpy (&x, ptr, sizeof x);
y.u8  += 0x80;
x.mm  = _mm_adds_epu8 (x.mm, y.mm);
x.u32 &= 0xffffff;

/* Instead of a variable, a compound literal may be used to pass the
   return value of an intrinsic call to a function expecting the union: */
v128 foo (v128);
x = foo ((v128) {_mm_adds_epu8 (x.mm, y.mm)});