{"id":10786,"date":"2025-06-16T10:24:36","date_gmt":"2025-06-16T10:24:36","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=10786"},"modified":"2025-07-03T14:44:53","modified_gmt":"2025-07-03T14:44:53","slug":"data-parallel-types-simd","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/data-parallel-types-simd\/","title":{"rendered":"Data-Parallel Types (SIMD)"},"content":{"rendered":"\n

The data-parallel types (SIMD) library provides data-parallel types and operations on them. Today, I want to take a closer look at this.<\/p>\n\n\n\n

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

Before diving into the new library, I would like to take a moment to discuss SIMD.<\/p>\n\n\n\n

SIMD<\/h2>\n\n\n\n

Vectorization refers to the SIMD<\/a> (S<\/strong>ingle I<\/strong>nstruction, M<\/strong>ultiple D<\/strong>ata) extensions of a modern processor’s instruction set. SIMD enables your processor to execute one operation in parallel on several data.<\/p>\n\n\n\n

A Simple Example<\/h3>\n\n\n\n

Whether an algorithm runs in a parallel and vectorized way depends on many factors. It depends on whether the CPU and the operating system support SIMD instructions. Additionally, it\u2019s a question of the compiler and the optimization level you used to compile your code.<\/p>\n\n\n\n

\/\/ SIMD.cpp<\/span>\n\nconst<\/span> int<\/span> SIZE=<\/span> 8<\/span>;\n\nint<\/span> vec[]=<\/span>{1<\/span>,2<\/span>,3<\/span>,4<\/span>,5<\/span>,6<\/span>,7<\/span>,8<\/span>};\nint<\/span> res[SIZE]=<\/span>{0<\/span>,};\n\nint<\/span> main<\/span>(){\n  for<\/span> (int<\/span> i=<\/span> 0<\/span>; i <<\/span> SIZE; ++<\/span>i) {\n    res[i]=<\/span> vec[i]+<\/span>5<\/span>; \/\/ (1)<\/span>\n  }\n}\n<\/pre><\/div>\n\n\n\n

Line 1 is the key line in the small program. Thanks to the Compiler Explorer, it is quite easy to generate the assembler instructions for Clang 3.6 with and without maximum optimization (-O3).<\/p>\n\n\n\n
Without Optimization<\/h4>\n\n\n\n
Although my time fiddling with assembler instructions is long gone, it\u2019s evident that all is done sequentially.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
With maximum Optimization<\/h4>\n\n\n\n
I get instructions that run in parallel on several datasets by using maximum optimization.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The move operation (movdqa<\/code>) and the add operation (paddd<\/code>) use the special registers xmm0 and xmm1. Both registers are so-called SSE registers and have a width of 128 Bits. This allows you to process 4 ints in one go. SSE<\/a> stands for S<\/strong>treaming S<\/strong>IMD E<\/strong>xtensions.\u00a0<\/p>\n\n\n\n
Unfortunately, vector instructions are highly dependent on the architecture. Neither the instructions nor the register widths are uniform. Modern Intel architectures mostly support AVX2 or even AVX-512. This enables 256-bit or 512-bit operations. This means that 8 or 16 ints can be processed in parallel. AVX stands for A<\/strong>dvanced V<\/strong>ector Ex<\/strong>tension. <\/p>\n\n\n\n
This is exactly where the new library data-parallel types come in, offering a unified interface to vector instructions.<\/p>\n\n\n\n
Data-parallel types (SIMD)<\/h2>\n\n\n\n
Before diving into the new library, a few definitions are necessary. These definitions refer to proposal P1928R15<\/a>. In total, the new library comprises six proposals.<\/p>\n\n\n\n

The set of vectorizable types <\/strong>comprises all standard integer types, character types, and the types float <\/code>and double<\/code>. In addition, std::float16_t, std::float32_t, <\/code>and std::float64_t<\/code> are vectorizable types if defined.<\/p>\n\n\n\n
The term data-parallel type<\/strong> refers to all enabled specializations of the basic_simd <\/code>and basic_simd_mask <\/code>class templates. A data-parallel object is an object of data-parallel type.
<\/p>\n\n\n\n
A data-parallel type consists of one or more elements of an underlying vectorizable type, called the element type<\/strong>. The number of elements is a constant for each data-parallel type and called the width of that type. The elements in a data-parallel type are indexed from 0 to width \u2212 1.<\/p>\n\n\n\n
An element-wise operation <\/strong>applies a specified operation to the elements of one or more data-parallel objects. Each such application is unsequenced with respect to the others. A unary element-wise operation<\/strong> is an element-wise operation that applies a unary operation to each element of a data-parallel object. A binary element-wise operation<\/strong> is an element-wise operation that applies a binary operation to corresponding elements of two data-parallel objects.<\/p>\n\n\n\n
After so much theory, I would now like to show a small example. This is from Matthias Kretz, author of proposal P1928R15. The example from his presentation at CppCon 2023 shows a function f <\/code>that takes a vector and maps its elements to their sine values.<\/p>\n\n\n\n
<\/p>\n\n\n\n
void<\/span> f<\/span>(std::<\/span>vector<<\/span>float<\/span>>&<\/span> data) {\n    using<\/span> floatv =<\/span> std::<\/span>simd<<\/span>float<\/span>><\/span>;\n    for<\/span> (auto<\/span> it =<\/span> data.begin(); it <<\/span> data.end(); it +=<\/span> floatv::<\/span>size()) {\n        floatv v(it);\n        v =<\/span> std::<\/span>sin(v);\n        v.copy_to(it);\n    }\n}\n<\/pre><\/div>\n\n\n\n

The function f <\/code>takes a vector of floats (data<\/code>) as a reference. It defines floatv <\/code>as a SIMD vector of floats using std::simd<float>. f <\/code>iterates through the vector in blocks, each block having the size of the SIMD vector.<\/p>\n\n\n\n
For each block: <\/p>\n\n\n\n