{"id":10871,"date":"2025-07-14T09:16:39","date_gmt":"2025-07-14T09:16:39","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10871"},"modified":"2025-07-14T09:16:40","modified_gmt":"2025-07-14T09:16:40","slug":"data-parallel-types-simd_mask","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/data-parallel-types-simd_mask\/","title":{"rendered":"Data-Parallel Types: simd_mask"},"content":{"rendered":"\n

Thanks to simd_mask<\/code>, conditional execution of operations on data-parallel types is possible.<\/p>\n\n\n\n

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

Unfortunately, in my last article, Data-Parallel Types \u2013 A First Example<\/a>, I forgot to introduce one of the new library functions. I will make up for that in this article.<\/p>\n\n\n\n

Where Expression<\/h2>\n\n\n\n

The new keyword where<\/code> creates a so-called where expression. This allows the elements of a SIMD vector to be addressed conditionally.
The following example illustrates this behavior:<\/p>\n\n\n\n

\/\/ where.cpp<\/span>\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; \/\/ Set elements where x is negative to their absolute value       <\/span>\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}\n<\/pre><\/div>\n\n\n\n
The where<\/code> function is used in the my_abs<\/code> function: where(x < 0, x) = -x<\/code>; . This expression causes all elements of the SIMD vector that are less than zero to be set to their absolute value. The following screenshot shows the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
In this case, SSE2 commands are used. The SIMD vector is 128 bits in size.<\/p>\n\n\n\n
The where <\/code>expression can be parameterized with a bool <\/code>expression or a simd_mask<\/code>.<\/p>\n\n\n\n
simd_mask<\/code><\/h2>\n\n\n\n
This allows the previous program where.cpp<\/code> to also be implemented by using a simd_mask<\/code>. The following program shows the application of the simd_mask<\/code>.<\/p>\n\n\n\n
\/\/ whereMask.cpp<\/span>\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> std::<\/span>boolalpha <<<\/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\n \nint<\/span> main<\/span>()\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> stdx::<\/span>native_simd_mask x =<\/span> c <<\/span> 0<\/span>; \n    println("x"<\/span>, x);\n\n    auto<\/span> d  =<\/span> c;\n    where(x, d) *=<\/span> -<\/span>1<\/span>; \n    println("d"<\/span>, d);\n \n}\n<\/pre><\/div>\n\n\n\n

I would like to begin my explanation with the last five lines of the main<\/code> function. First, I create the simd_mask x<\/code> by applying the predicate  c < 0<\/code> to each element of the SIMD vector c<\/code>. The mask x <\/code>has the same length as the SIMD vector, but only contains truth values. To ensure that these truth values are displayed as true <\/code>or false<\/code> and not as 1 <\/code>or 0<\/code>, I have added the stream manipulator std::boolalpha<\/code> to the println<\/code> function. In addition, I have to initialize the SIMD vector d<\/code> with c<\/code>, since c<\/code> is constant. Now the where expression  where(x, d) *= -1 <\/code>can be applied to d<\/code>. Each element of the SIMD vector d<\/code> is negated if the mask has the value true.<\/p>\n\n\n\n
The following screenshot shows the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The data type simd_mask<\/code> is very similar to the data type simd<\/code>. The main difference is that simd<\/code> can accept all standard integer types, character types, and the types float<\/code> and double<\/code>. In contrast, simd_mask <\/code>only supports Boolean values.<\/p>\n\n\n\n
Here is the definition of simd_mask<\/code>:<\/p>\n\n\n\n
template<\/span><<\/span>size_t<\/span> Bytes, class<\/span> Abi<\/span>><\/span> \nclass<\/span> basic_simd_mask<\/span>\n<\/pre><\/div>\n\n\n\n
The Abi <\/code>tag determines the number of elements and their memory. For the sake of completeness, here are the ABI tags again:<\/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

    Similar to simd<\/code>, simd_mask<\/code> also has two aliases:<\/p>\n\n\n\n
    template<\/span><<\/span> size_t<\/span> Bytes, int<\/span> N ><\/span> \nusing<\/span> fixed_size_simd_mask =<\/span> simd_mask<<\/span>Bytes, simd_abi::<\/span>fixed_size<<\/span>N>><\/span> \n\ntemplate<\/span><<\/span> size_t<\/span> Bytes ><\/span> \nusing<\/span> native_simd_mask =<\/span>  simd_mask<<\/span>Bytes, simd_abi::<\/span>native<<\/span>Bytes>><\/span>\n<\/pre><\/div>\n\n\n\n\n
    What’s next?<\/h2>\n\n\n\n
    In what will be my last article on data-parallel types for the time being, I would like to discuss the special functions for these types.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Thanks to simd_mask, conditional execution of operations on data-parallel types is possible. Unfortunately, in my last article, Data-Parallel Types \u2013 A First Example, I forgot to introduce one of the new library functions. I will make up for that in this article. Where Expression The new keyword where creates a so-called where expression. This allows […]<\/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-10871","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\/10871","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=10871"}],"version-history":[{"count":12,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10871\/revisions"}],"predecessor-version":[{"id":10887,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/10871\/revisions\/10887"}],"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=10871"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=10871"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=10871"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}