{"id":10831,"date":"2025-06-25T16:01:32","date_gmt":"2025-06-25T16:01:32","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10831"},"modified":"2025-07-03T14:45:54","modified_gmt":"2025-07-03T14:45:54","slug":"data-parallel-types-a-first-example","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/data-parallel-types-a-first-example\/","title":{"rendered":"Data-Parallel Types – A First Example"},"content":{"rendered":"\n

After providing a theoretical introduction to the new C++ 26 feature in my last article, \u201cData-Parallel Types (SIMD)<\/a>,\u201d I would like to follow up today with a practical example.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

The following introductory example is from the experimental implementation of the SIMD library<\/a>. This functionality has been fully adopted in the C++ 26 draft under the name Data-parallel types (SIMD)<\/a>. To port the program to the C++ 26 standard, it should be sufficient to replace the header <experimental\/simd> <\/code>with <simd><\/code> and the namespace std::experimental <\/code>with std::datapar.<\/code><\/p>\n\n\n\n

#include <experimental\/simd><\/span>\n#include <iostream><\/span>\n#include <string_view><\/span>\nnamespace<\/span> stdx =<\/span> std::<\/span>experimental;\n \nvoid<\/span> println<\/span>(std::<\/span>string_view name, auto<\/span> const<\/span>&<\/span> a)\n{\n    std::<\/span>cout <<<\/span> name <<<\/span> ": "<\/span>;\n    for<\/span> (std::<\/span>size_t<\/span> i{}; i !=<\/span> std::<\/span>size(a); ++<\/span>i)\n        std::<\/span>cout <<<\/span> a[i] <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n \ntemplate<\/span><<\/span>class<\/span> A<\/span>><\/span>\nstdx::<\/span>simd<<\/span>int<\/span>, A><\/span> my_abs(stdx::<\/span>simd<<\/span>int<\/span>, A><\/span> x)\n{\n    where(x <<\/span> 0<\/span>, x) =<\/span> -<\/span>x;\n    return<\/span> x;\n}\n \nint<\/span> main()\n{\n    const<\/span> stdx::<\/span>native_simd<<\/span>int<\/span>><\/span> a =<\/span> 1<\/span>;\n    println("a"<\/span>, a);\n \n    const<\/span> stdx::<\/span>native_simd<<\/span>int<\/span>><\/span> b([](int<\/span> i) { return<\/span> i -<\/span> 2<\/span>; });\n    println("b"<\/span>, b);\n \n    const<\/span> auto<\/span> c =<\/span> a +<\/span> b;\n    println("c"<\/span>, c);\n \n    const<\/span> auto<\/span> d =<\/span> my_abs(c);\n    println("d"<\/span>, d);\n \n    const<\/span> auto<\/span> e =<\/span> d *<\/span> d;\n    println("e"<\/span>, e);\n \n    const<\/span> auto<\/span> inner_product =<\/span> stdx::<\/span>reduce(e);\n    std::<\/span>cout <<<\/span> "inner product: "<\/span> <<<\/span> inner_product <<<\/span> '\\n'<\/span>;\n \n    const<\/span> stdx::<\/span>fixed_size_simd<<\/span>long<\/span> double<\/span>, 16<\/span>><\/span> x([](int<\/span> i) { return<\/span> i; });\n    println("x"<\/span>, x);\n    println("cos\u00b2(x) + sin\u00b2(x)"<\/span>, stdx::<\/span>pow(stdx::<\/span>cos(x), 2<\/span>) +<\/span> stdx::<\/span>pow(stdx::<\/span>sin(x), 2<\/span>));\n}\n<\/pre><\/div>\n\n\n\n
Before I proceed with the program, I would like to introduce the output.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
First, I would like to focus on the println<\/code> and my_abs<\/code> functions. The println<\/code> function outputs the name and content of a SIMD vector, iterating through its elements. my_abs<\/code> calculates the absolute value of each element in a SIMD vector with integers, using where <\/code>to conditionally negate negative values.<\/p>\n\n\n\n
The main<\/code> function is much more interesting. In the SIMD vector a<\/code>, each element is set to 1, whereas in the SIMD vector b<\/code>, thanks to the lambda function, each element is initialized so that it has its index minus 2. By default, SSE2<\/a> instructions are used via const stdx::native_simd<\/code>. These SIMD vectors are 128 bits in size. Now the arithmetic begins. Vector c<\/code> is the element-wise sum of a <\/code>and b<\/code>, d<\/code> is the element-wise absolute value of c<\/code>, and vector e <\/code>is the element-wise square of d<\/code>. Finally, stdx::reduce(e)<\/code> is used. This reduces vector e <\/code>to its sum. <\/p>\n\n\n\n
The expression const stdx::fixed_size_simd<long double, 16> x([](int i) { return i; })<\/code> is particularly interesting. It initializes the SIMD vector x<\/code> with 16 long double values from 0 to 15. This is possible if the architecture is sufficiently modern and supports AVX-252. <\/a>This applies, for example, to Intel’s Xeon Phi or AMD’s Zen 4 architecture. Similarly interesting is the line println(\u201ccos\u00b2(x) + sin\u00b2(x)\u201d, stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::sin(x), 2))<\/code>. This calculates cos\u00b2(x) + sin\u00b2(x)<\/code> for each element, which is 1 for all elements due to the trigonometric identity of Pythagoras. All functions in <cmath> <\/a>except for the special mathematical functions for simd are overloaded. These include basic functions such as abs, min, and max.<\/kbd> However, exponential, power, trigonometric, hyperbolic, and gamma functions can also be applied directly to SIMD vectors.<\/p>\n\n\n\n
Now I would like to go into more detail about the width of the data type simd<T><\/code>.<\/p>\n\n\n\n
Width of simd<T><\/code><\/h2>\n\n\n\n
The width of the data type native_simd<\/code><T><\/code> is determined by the implementation at compile time. In contrast, the developer specifies the width of the data type fixed_size_simd<\/code><T><\/code>.<\/p>\n\n\n\n
The class template simd has the following declaration:<\/p>\n\n\n\n
template<\/span><<\/span> class<\/span> T<\/span>, class<\/span> Abi<\/span> =<\/span> simd_abi::<\/span>compatible ><\/span>\nclass<\/span> simd<\/span>;\n<\/pre><\/div>\n\n\n\n
Here, T <\/code>stands for the element type, which cannot be bool<\/code>. The Abi <\/code>tag determines the number of elements and their memory.<\/p>\n\n\n\n
There are two aliases for this class template:<\/p>\n\n\n\n
template<\/span><<\/span> class<\/span> T<\/span>, int<\/span> N ><\/span>\nusing<\/span> fixed_size_simd =<\/span> std::<\/span>experimental::<\/span>simd<<\/span>T, std::<\/span>experimental::<\/span>simd_abi::<\/span>fixed_size<<\/span>N>><\/span>;\n\t\t\ntemplate<\/span><<\/span> class<\/span> T<\/span> ><\/span>\nusing<\/span> native_simd =<\/span> std::<\/span>experimental::<\/span>simd<<\/span>T, std::<\/span>experimental::<\/span>simd_abi::<\/span>native<<\/span>T>><\/span>;\n<\/pre><\/div>\n\n\n\n\n
The following ABI tags are available:<\/p>\n\n\n\n
    \n
  • scalar<\/code>: storing a single element<\/li>\n\n\n\n
  • fixed_size<\/code>: storing a specified number of elements<\/li>\n\n\n\n
  • compatible<\/code>: ensures ABI compatibility<\/li>\n\n\n\n
  • native<\/code>: most efficient<\/li>\n\n\n\n
  • max_fixed_size<\/code>: maximum number of elements guaranteed to be supported by fixed_size<\/code><\/li>\n<\/ul>\n\n\n\n
    What’s next? <\/h2>\n\n\n\n
    After this initial example of data parallel types, I would like to take a closer look at their functionality in the next article.<\/p>\n\n\n\n
    <\/p>\n","protected":false},"excerpt":{"rendered":"
    After providing a theoretical introduction to the new C++ 26 feature in my last article, \u201cData-Parallel Types (SIMD),\u201d I would like to follow up today with a practical example. The following introductory example is from the experimental implementation of the SIMD library. This functionality has been fully adopted in the C++ 26 draft under the […]<\/p>\n","protected":false},"author":21,"featured_media":10788,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[559],"tags":[566],"class_list":["post-10831","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c26-blog","tag-data-parallel-types"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10831","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=10831"}],"version-history":[{"count":9,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10831\/revisions"}],"predecessor-version":[{"id":10842,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10831\/revisions\/10842"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/10788"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=10831"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10831"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10831"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}