Difference between revisions of "cpp/experimental/simd"

Revision as of 19:06, 22 May 2023

The SIMD library provides portable types for explicitly stating data-parallelism and structuring data for more efficient SIMD access.

An object of type simd<T> behaves analogue to objects of type T. But while T stores and manipulates one value, simd<T> stores and manipulates multiple values (called width but identified as size for consistency with the rest of the standard library; cf. simd_size).

Every operator and operation on simd<T> acts element-wise (except for horizontal operations, which are clearly marked as such). This simple rule expresses data-parallelism and will be used by the compiler to generate SIMD instructions and/or independent execution streams.

The width of the types simd<T> and native_simd<T> is determined by the implementation at compile-time. In contrast, the width of the type fixed_size_simd<T, N> is fixed by the developer to a certain size.

A recommended pattern for using a mix of different SIMD types with high efficiency uses native_simd and rebind_simd:

#include <experimental/simd>
 
namespace stdx = std::experimental;
 
using floatv  = stdx::native_simd<float>;
using doublev = stdx::rebind_simd_t<double, floatv>;
using intv    = stdx::rebind_simd_t<int, floatv>;

This ensures that the set of types all have the same width and thus can be interconverted. A conversion with mismatching width is not defined because it would either drop values or have to invent values. For resizing operations, the SIMD library provides the split and concat functions.

Main classes

ABI tags

Alignment tags

Where expression

Casts

Algorithms

Reduction

Mask reduction

Traits

Math functions

All functions in <cmath>, except for the special math functions, are overloaded for simd.

Example

#include <experimental/simd>
#include <iostream>
namespace stdx = std::experimental;
 
void print(auto const& a)
{
    for (std::size_t i{}; i != std::size(a); ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}
 
template <class A>
stdx::simd<int, A> my_abs(stdx::simd<int, A> x)
{
    where(x < 0, x) = -x;
    return x;
}
 
int main()
{
    const stdx::native_simd<int> a = 1;
    print(a);
    const stdx::native_simd<int> b([](int i) { return i - 2; });
    print(b);
    const auto c = a + b;
    print(c);
    const auto d = my_abs(c);
    print(d);
    const auto e = d * d;
    print(e);
    const auto inner_product = stdx::reduce(e);
    std::cout << inner_product << '\n';
}

1 1 1 1 
-2 -1 0 1 
-1 0 1 2 
1 0 1 2 
1 0 1 4 
6