None of the answers appear to actually answer the question, why does it return int. The reason is, the extractps instruction actually copies a component of the vector to a general register. It does seem pretty silly for it to return an int but that’s what’s actually happening – the raw floating point value ends … Read more
A general method to find the instruction switch for gcc File intrin.sh: #!/bin/bash get_instruction () { [ -z “$1″ ] && exit func_name=”$1 ” header_file=`grep –include=\*intrin.h -Rl “$func_name” /usr/lib/gcc | head -n1` [ -z “$header_file” ] && exit >&2 echo “find in: $header_file” target_directive=`grep “#pragma GCC target(\|$func_name” $header_file | grep -B 1 “$func_name” | head … Read more
4×4 matrix multiplication is 64 multiplications and 48 additions. Using SSE this can be reduced to 16 multiplications and 12 additions (and 16 broadcasts). The following code will do this for you. It only requires SSE (#include <xmmintrin.h>). The arrays A, B, and C need to be 16 byte aligned. Using horizontal instructions such as … Read more
As well as Intel’s vol.2 PDF manual, there is also an online intrinsics guide. The Intel® Intrinsics Guide contains reference information for Intel intrinsics, which provide access to Intel instructions such as Intel® Streaming SIMD Extensions (Intel® SSE), Intel® Advanced Vector Extensions (Intel® AVX), and Intel® Advanced Vector Extensions 2 (Intel® AVX2). It has a … Read more
You can use the PTEST instuction via the _mm_testz_si128 intrinsic (SSE4.1), like this: #include “smmintrin.h” // SSE4.1 header if (!_mm_testz_si128(xor, xor)) { // rectangle has changed } Note that _mm_testz_si128 returns 1 if the bitwise AND of the two arguments is zero.
Typically you generate 4 partial sums in your loop and then just sum horizontally across the 4 elements after the loop, e.g. #include <cassert> #include <cstdint> #include <emmintrin.h> float vsum(const float *a, int n) { float sum; __m128 vsum = _mm_set1_ps(0.0f); assert((n & 3) == 0); assert(((uintptr_t)a & 15) == 0); for (int i = … Read more
I know this post is quite outdated but I found it useful to give my (validated) solution. It assumes all ones/all zeroes in every lane of the Input argument. const uint8_t __attribute__ ((aligned (16))) _Powers[16]= { 1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128 }; // Set … Read more
If by “modern” you mean processors supporting the sort of SSE2 instructions that you quote in your question as produced by your compiler (mulsd, …), then the answer is no, strictfp does not make a difference, because the instruction set does not allow to take advantage of the absence of strictfp. The available instructions are … Read more
SSE intrinsics is one of those niche corner cases where you have to push the rules a bit. Since these intrinsics are compiler extensions (somewhat standardized by Intel), they are already outside the specification of the C and C++ language standards. So it’s somewhat self-defeating to try to be “standard compliant” while using a feature … Read more
Vector comparison instructions produce their result as a mask, of elements that are all-1s (true) or all-0s (false) according to the comparison between the corresponding source elements. See https://stackoverflow.com/tags/x86/info for some links that will tell you what those intrinsics do. The code in the question looks like it should work. If you want to find … Read more