Типы с параллелизмом по данным (SIMD) (начиная с C++26)

Библиотека предоставляет типы с параллелизмом по данным и операции над этими типами: переносимые типы для явного задания параллелизма по данным и структурирования данных с помощью ресурсов выполнения с параллелизмом по данным, если они доступны, например регистров и инструкций SIMD или исполнительных устройств, управляемых общим декодером инструкций.

Множество векторизуемых типов включает:

• все стандартные целочисленные типы и символьные типы;
• большинство типов с плавающей точкой, включая float, double и выбранные расширенные типы с плавающей точкой: std::float16_t, std::float32_t и std::float64_t, если они определены; и
• std::complex<T>, где T — векторизуемый тип с плавающей точкой.

Тип с параллелизмом по данным состоит из одного или нескольких элементов базового векторизуемого типа, называемого типом элемента . Количество элементов, называемое шириной , является постоянным для каждого типа с параллелизмом по данным.

Тип с параллелизмом по данным обозначает все разрешённые специализации шаблонов классов basic_vec и basic_mask.

Объект с параллелизмом по данным типа с параллелизмом по данным ведёт себя аналогично объектам типа T. Однако, если T хранит и обрабатывает одно значение, тип с параллелизмом по данным и типом элемента T хранит и обрабатывает несколько значений.

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

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

Шаблоны псевдонимов vec и mask определены, чтобы позволить пользователям задавать ширину определённого размера. Ширина по умолчанию определяется реализацией во время компиляции.

Основные классы

Флаги загрузки и сохранения

Операции загрузки и сохранения

Преобразования типов

Алгоритмы

Редукции

Перестановки

Свойства типов

Математические функции

Все функции из <cmath> и <complex> перегружены для basic_vec.

Функции манипуляции битами

Все функции манипуляции битами из <bit>, кроме std::bit_cast, перегружены для basic_vec.

Подробности реализации

Теги ABI

Типы с параллелизмом по данным basic_vec и basic_mask связаны с тегами ABI . Эти теги — типы, задающие размер и двоичное представление объектов с параллелизмом по данным. Предполагается, что размер и двоичное представление будут изменяться в зависимости от целевой архитектуры и флагов компилятора. Тег ABI вместе с типом элемента определяет ширину.

Тег ABI не зависит от выбора набора машинных инструкций. Выбранный набор машинных инструкций ограничивает используемые типы тегов ABI. Теги ABI позволяют пользователям безопасно передавать объекты типа с параллелизмом по данным через границы единиц трансляции.

Сущности, используемые только для описания

using /*simd-size-type*/ = /* see description */;

template< std::size_t Bytes >
using /*integer-from*/ = /* see description */;

template< class T, class Abi >
constexpr /*simd-size-type*/ /*simd-size-v*/ = /* see description */;

template< class T >
constexpr std::size_t /*mask-element-size*/ = /* see description */;

template< class T >
concept /*constexpr-wrapper-like*/ = /* see description */;

template< class T >
using /*deduced-simd-t*/ = /* see description */;

template< class V, class T >
using /*make-compatible-simd-t*/ = /* see description */;

template< class T >
concept /*constexpr-wrapper-like*/ =
    std::convertible_to<T, decltype(T::value)> &&
    std::equality_comparable_with<T, decltype(T::value)> &&
    std::bool_constant<T() == T::value>::value &&
    std::bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;

• decltype(x+x), если тип x + x является разрешённой специализацией basic_vec; в противном случае
• void.

• /*deduced-simd-t*/<T>, если этот тип не равен void; в противном случае
• std::simd::vec<decltype(x+x),V​::​size()>.

template< class V >
concept /*simd-floating-point*/ = /* see description */;

template< class... Ts >
concept /*math-floating-point*/ = /* see description */;

template< class... Ts >
  requires /*math-floating-point*/<Ts...>
using /*math-common-simd-t*/ = /* see description */;

template< class BinaryOp, class T >
concept /*reduction-binary-operation*/ = /* see description */;

template< class V >
concept /*simd-floating-point*/ =
    std::same_as<V,
                 std::simd::basic_vec<typename V::value_type,
                 typename V::abi_type>> &&
    std::is_default_constructible_v<V> && 
    std::floating_point<typename V::value_type>;

template< class... Ts >
concept /*math-floating-point*/ =
    (/*simd-floating-point*/</*deduced-simd-t*/<Ts>> || ...);

• /*deduced-simd-t*/<T0>, если sizeof...(Ts) == 1 является true
• в противном случае std::common_type_t</*deduced-simd-t*/<T0>,/*deduced-simd-t*/<T1>>, если sizeof...(Ts) == 2 является true и /*math-floating-point*/<T0> && /*math-floating-point*/<T1> является true,
• в противном случае std::common_type_t</*deduced-simd-t*/<T0>,T1>, если sizeof...(Ts) == 2 является true и /*math-floating-point*/<T0> является true,
• в противном случае std::common_type_t<T0,/*deduced-simd-t*/<T1>>, если sizeof...(Ts) == 2 является true,
• в противном случае std::common_type_t</*math-common-simd-t*/<T0,T1>,TRest...>, если /*math-common-simd-t*/<T0,T1> является допустимым типом,
• в противном случае std::common_type_t</*math-common-simd-t*/<TRest...>,T0,T1>.

template< class BinaryOp, class T >
concept /*reduction-binary-operation*/ =
    requires (const BinaryOp binary_op, const std::simd::vec<T, 1> v) {
        { binary_op(v, v) } -> std::same_as<std::simd::vec<T, 1>>;
    };

template< class T >
using /*native-abi*/ = /* see description */;

template< class T, /*simd-size-type*/ N >
using /*deduce-abi-t*/ = /* see description */;

• /*simd-size-v*/<T,/*deduce-abi-t*/<T,N>> равен N,
• std::simd::basic_vec<T,/*deduce-abi-t*/<T,N>> является разрешённой специализацией, и
• std::simd::basic_mask<sizeof(T),/*deduce-abi-t*/</*integer-from*/<sizeof(T)>,N>> является разрешённой специализацией.

struct /*convert-flag*/;

struct /*aligned-flag*/;

template< std::size_t N >
struct /*overaligned-flag*/;

Примечания

Пример

#include <iostream>
#include <simd>
#include <string_view>

namespace simd = std::simd;

void println(std::string_view name, auto const& a)
{
    std::cout << name << ": ";
    for (std::size_t i{}; i != a.size(); ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

template<class A>
constexpr simd::basic_vec<int, A> my_abs(simd::basic_vec<int, A> x)
{
    return simd::select(x < 0, -x, x);
}

int main()
{
    constexpr simd::vec<int> a = 1;
    println("a", a);

    constexpr simd::vec<int> b([](int i) { return i - 2; });
    println("b", b);

    constexpr auto c = a + b;
    println("c", c);

    constexpr auto d = my_abs(c);
    println("d", d);

    constexpr auto e = d * d;
    println("e", e);

    constexpr auto inner_product = simd::reduce(e);
    std::cout << "inner product: " << inner_product << '\n';

    constexpr simd::vec<double, 16> x([](int i) { return i; });
    println("x", x);
    // overloaded math functions are defined in <simd>
    println("cos²(x) + sin²(x)", std::pow(std::cos(x), 2) + std::pow(std::sin(x), 2));
}

a: 1 1 1 1 
b: -2 -1 0 1 
c: -1 0 1 2 
d: 1 0 1 2 
e: 1 0 1 4 
inner product: 6
x: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
cos²(x) + sin²(x): 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

См. также