29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.2 Exposition-only types, variables, and concepts [simd.expos]

using simd-size-type = see below; // exposition only template<size_t Bytes> using integer-from = see below; // exposition only template<class T, class Abi> constexpr simd-size-type simd-size-v = see below; // exposition only template<class T> constexpr size_t mask-element-size = see below; // exposition only template<class T> concept constexpr-wrapper-like = // exposition only convertible_to<T, decltype(T::value)> && equality_comparable_with<T, decltype(T::value)> && bool_constant<T() == T::value>::value && bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value; template<class T> using deduced-simd-t = see below; // exposition only template<class V, class T> using make-compatible-simd-t = see below; // exposition only template<class V> concept simd-floating-point = // exposition only same_as<V, basic_simd<typename V::value_type, typename V::abi_type>> && is_default_constructible_v<V> && floating_point<typename V::value_type>; template<class... Ts> concept math-floating-point = // exposition only (simd-floating-point<deduced-simd-t<Ts>> || ...); template<class... Ts> requires math-floating-point<Ts...> using math-common-simd-t = see below; // exposition only template<class BinaryOperation, class T> concept reduction-binary-operation = see below; // exposition only // [simd.expos.abi], simd ABI tags template<class T> using native-abi = see below; // exposition only template<class T, simd-size-type N> using deduce-abi-t = see below; // exposition only // [simd.flags], Load and store flags struct convert-flag; // exposition only struct aligned-flag; // exposition only template<size_t N> struct overaligned-flag; // exposition only

29.10.2.1 Exposition-only helpers [simd.expos.defn]

🔗

using simd-size-type = see below;

simd-size-type is an alias for a signed integer type.

🔗

template<size_t Bytes> using integer-from = see below;

integer-from<Bytes> is an alias for a signed integer type T such that sizeof(T) equals Bytes.

🔗

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

simd-size-v<T, Abi> denotes the width of basic_simd<T, Abi> if the specialization basic_simd<T, Abi> is enabled, or 0 otherwise.

🔗

template<class T> constexpr size_t mask-element-size = see below;

mask-element-size<basic_simd_mask<Bytes, Abi>> has the value Bytes.

🔗

template<class T> using deduced-simd-t = see below;

Let x denote an lvalue of type const T.

deduced-simd-t<T> is an alias for

(6.1)
decltype(x + x), if the type of x + x is an enabled specialization of basic_simd; otherwise
(6.2)
void.

🔗

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

Let x denote an lvalue of type const T.

make-compatible-simd-t<V, T> is an alias for

(8.1)
deduced-simd-t<T>, if that type is not void, otherwise
(8.2)
simd<decltype(x + x), V::size()>.

🔗

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

Let T0 denote Ts...[0].

Let T1 denote Ts...[1].

Let TRest denote a pack such that T0, T1, TRest... is equivalent to Ts....

Let math-common-simd-t<Ts...> be an alias for

(10.1)
deduced-simd-t<T0>, if sizeof...(Ts) equals 1; otherwise
(10.2)
common_type_t<deduced-simd-t<T0>, deduced-simd-t<T1>>, if sizeof...(Ts) equals 2 and math-floating-point<T0> && math-floating-point<T1> is true; otherwise
(10.3)
common_type_t<deduced-simd-t<T0>, T1>, if sizeof...(Ts) equals 2 and math-floating-point<T0> is true; otherwise
(10.4)
common_type_t<T0, deduced-simd-t<T1>>, if sizeof...(Ts) equals 2; otherwise
(10.5)
common_type_t<math-common-simd-t<T0, T1>, TRest...>, if math-common-simd-t<T0, T1> is valid and denotes a type; otherwise
(10.6)
common_type_t<math-common-simd-t<TRest...>, T0, T1>.

🔗

template<class BinaryOperation, class T>
  concept reduction-binary-operation =
    requires (const BinaryOperation binary_op, const simd<T, 1> v) {
      { binary_op(v, v) } -> same_as<simd<T, 1>>;
    };

Types BinaryOperation and T model reduction-binary-operation<BinaryOperation, T> only if:

(11.1)
BinaryOperation is a binary element-wise operation and the operation is commutative.
(11.2)
An object of type BinaryOperation can be invoked with two arguments of type basic_simd<T, Abi>, with unspecified ABI tag Abi, returning a basic_simd<T, Abi>.

29.10.2.2 simd ABI tags [simd.expos.abi]

🔗

template<class T> using native-abi = see below;
template<class T, simd-size-type N> using deduce-abi-t = see below;

An ABI tag is a type that indicates a choice of size and binary representation for objects of data-parallel type.

[Note 1:

The intent is for the size and binary representation to depend on the target architecture and compiler flags.

The ABI tag, together with a given element type, implies the width.

— end note]

[Note 2:

The ABI tag is orthogonal to selecting the machine instruction set.

The selected machine instruction set limits the usable ABI tag types, though (see [simd.overview]).

The ABI tags enable users to safely pass objects of data-parallel type between translation unit boundaries (e.g., function calls or I/O).

— end note]

An implementation defines ABI tag types as necessary for the following aliases.

deduce-abi-t<T, N> is defined if

(4.1)
T is a vectorizable type,
(4.2)
N is greater than zero, and
(4.3)
N is not larger than an implementation-defined maximum.

The implementation-defined maximum for N is not smaller than 64 and can differ depending on T.

Where present, deduce-abi-t<T, N> names an ABI tag type such that

(5.1)
simd-size-v<T, deduce-abi-t<T, N>> equals N,
(5.2)
basic_simd<T, deduce-abi-t<T, N>> is enabled ([simd.overview]), and
(5.3)
basic_simd_mask<sizeof(T), deduce-abi-t<integer-from<sizeof(T)>, N>> is enabled.

native-abi<T> is an implementation-defined alias for an ABI tag.

basic_simd<T, native-abi<T>> is an enabled specialization.

[Note 3:

The intent is to use the ABI tag producing the most efficient data-parallel execution for the element type T on the currently targeted system.

For target architectures with ISA extensions, compiler flags can change the type of the native-abi<T> alias.

— end note]

[Example 1:

Consider a target architecture supporting the ABI tags __simd128 and __simd256, where hardware support for __simd256 exists only for floating-point types.

The implementation therefore defines native-abi<T> as an alias for

(6.1)
__simd256 if T is a floating-point type, and
(6.2)
__simd128 otherwise.

— end example]