SIMD library

Fusionné dans la norme ISO C++ La fonctionnalité décrite sur cette page a été fusionnée dans la norme principale ISO C++ à partir de 11/2024 ; voir les types parallèles de données (SIMD) (depuis C++26)

La bibliothèque SIMD fournit des types portables pour exprimer explicitement le parallélisme de données et structurer les données pour un accès SIMD plus efficace.

Un objet de type simd<T> se comporte de manière analogue aux objets de type T . Mais alors que T stocke et manipule une seule valeur, simd<T> stocke et manipule plusieurs valeurs (appelées width mais identifiées comme size pour la cohérence avec le reste de la bibliothèque standard ; cf. simd_size ).

Chaque opérateur et opération sur simd<T> agit élément par élément (sauf pour les opérations horizontales , qui sont clairement indiquées comme telles). Cette règle simple exprime le parallélisme de données et sera utilisée par le compilateur pour générer des instructions SIMD et/ou des flux d'exécution indépendants.

La largeur des types simd<T> et native_simd<T> est déterminée par l'implémentation au moment de la compilation. En revanche, la largeur du type fixed_size_simd<T, N> est fixée par le développeur à une taille spécifique.

Un modèle recommandé pour utiliser un mélange de différents types SIMD avec une haute efficacité utilise native_simd et 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>;

Cela garantit que l'ensemble des types ont la même largeur et peuvent donc être convertis mutuellement. Une conversion avec des largeurs incompatibles n'est pas définie car elle supprimerait des valeurs ou devrait inventer des valeurs. Pour les opérations de redimensionnement, la bibliothèque SIMD fournit les fonctions split et concat .

Classes principales

Étiquettes ABI

Balises d'alignement

Expression Where

Casts

Algorithmes

Réduction

Réduction de masque

Traits

Fonctions mathématiques

Toutes les fonctions dans <cmath> , à l'exception des fonctions mathématiques spéciales, sont surchargées pour simd .

Exemple

#include <experimental/simd>
#include <iostream>
#include <string_view>
namespace stdx = std::experimental;
void println(std::string_view name, auto const& a)
{
    std::cout << name << ": ";
    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;
    println("a", a);
    const stdx::native_simd<int> b([](int i) { return i - 2; });
    println("b", b);
    const auto c = a + b;
    println("c", c);
    const auto d = my_abs(c);
    println("d", d);
    const auto e = d * d;
    println("e", e);
    const auto inner_product = stdx::reduce(e);
    std::cout << "inner product: " << inner_product << '\n';
    const stdx::fixed_size_simd<long double, 16> x([](int i) { return i; });
    println("x", x);
    println("cos²(x) + sin²(x)", stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::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

Voir aussi

Liens externes