The library provides data-parallel types and operations on these types: portable types for explicitly stating data-parallelism and structuring data through data-parallel execution resources where available, such asSIMD registers and instructions or execution units that are driven by a common instruction decoder.

The set ofvectorizable types comprises:

• all standard integers and character types;
• most floating-point types includingfloat,double, and the selected extended floating-point types:std::float16_t,std::float32_t, andstd::float64_t if defined; and
• std::complex<T> whereT is a vectorizable floating-point type.

Adata-parallel type consists of one or more elements of an underlying vectorizable type, called theelement type . The number of elements, called thewidth , is constant for each data-parallel type.

The data-parallel type refers to all enabled specializations of the class templatesbasic_simd andbasic_simd_mask.

Adata-parallel object of data-parallel type behaves analogously to objects of typeT. But whileT stores and manipulates a single value, the data-parallel type with the element typeT stores and manipulates multiple values.

Every operation on a data-parallel object actselement-wise (except for horizontal operations, such as reductions, which are clearly marked as such) applying to each element of the object or to corresponding elements of two objects. Each such application is unsequenced with respect to the others. This simple rule expresses data-parallelism and will be used by the compiler to generate SIMD instructions and/or independent execution streams.

All operations (except non-constexpr math function overloads) on data-parallel objects areconstexpr: it is possible to create and use data-parallel objects in the evaluation of a constant expression.

Alias templatessimd andsimd_mask are defined to allow users to specify the width to a certain size. The default width is determined by the implementation at compile-time.

[edit]Main classes

[edit]Load and store flags

[edit]Load and store operations

[edit]Casts

[edit]Algorithms

[edit]Reductions

[edit]Traits

[edit]Math functions

All functions in<cmath> and<complex> are overloaded forbasic_simd.

[edit]Bit manipulation functions

All bit manipulation functions in<bit> are overloaded forbasic_simd.

[edit]Implementation details

[edit]ABI tags

The data-parallel typesbasic_simd andbasic_simd_mask are associated withABI tags . These tags are types that specify the size and binary representation of data-parallel objects. The design intends the size and binary representation to vary based on target architecture and compiler flags. The ABI tag, together with the element type, determines the width.

The ABI tag remains independent of machine instruction set selection. The chosen machine instruction set limits the usable ABI tag types. The ABI tags enable users to safely pass objects of data-parallel type across translation unit boundaries.

[edit]Exposition-only entities

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;

template<class V>concept/*simd-floating-point*/=std::same_as<V,                 std::datapar::basic_simd<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>>|| ...);

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

[edit]Notes

[edit]Example

#include <iostream>#include <simd>#include <string_view> void println(std::string_view name,autoconst& a){std::cout<< name<<": ";for(std::size_t i{}; i!= a.size();++i)std::cout<< a[i]<<' ';std::cout<<'\n';} template<class A>constexpr std::datapar::basic_simd<int, A> my_abs(std::datapar::basic_simd<int, A> x){return std::datapar::select(x<0,-x, x);} int main(){constexpr std::datapar::simd<int> a=1;    println("a", a); constexpr std::datapar::simd<int> b([](int i){return i-2;});    println("b", b); constexprauto c= a+ b;    println("c", c); constexprauto d= my_abs(c);    println("d", d); constexprauto e= d* d;    println("e", e); constexprauto inner_product= std::datapar::reduce(e);std::cout<<"inner product: "<< inner_product<<'\n'; constexpr std::datapar::simd<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: 6x: 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

[edit]See also

[edit]External links

• In other languages

• Español
• 日本語
• Русский
• 中文