Getting started with Intel x86 SSE SIMD instructions

by

First, I don’t recommend on using the built-in functions – they are not portable (across compilers of the same arch).

Use intrinsics, GCC does a wonderful job optimizing SSE intrinsics into even more optimized code. You can always have a peek at the assembly and see how to use SSE to it’s full potential.

Intrinsics are easy – just like normal function calls:

#include <immintrin.h>  // portable to all x86 compilers

int main()
{
    __m128 vector1 = _mm_set_ps(4.0, 3.0, 2.0, 1.0); // high element first, opposite of C array order.  Use _mm_setr_ps if you want "little endian" element order in the source.
    __m128 vector2 = _mm_set_ps(7.0, 8.0, 9.0, 0.0);

    __m128 sum = _mm_add_ps(vector1, vector2); // result = vector1 + vector 2

    vector1 = _mm_shuffle_ps(vector1, vector1, _MM_SHUFFLE(0,1,2,3));
    // vector1 is now (1, 2, 3, 4) (above shuffle reversed it)
    return 0;
}

Use _mm_load_ps or _mm_loadu_ps to load data from arrays.

Of course there are way more options, SSE is really powerful and in my opinion relatively easy to learn.

See also https://stackoverflow.com/tags/sse/info for some links to guides.

More Related Contents:

  1. Compare 16 byte strings with SSE
  2. inlining failed in call to always_inline ‘_mm_mullo_epi32’: target specific option mismatch
  3. Assembly code fsqrt and fmul instructions
  4. Why does mulss take only 3 cycles on Haswell, different from Agner’s instruction tables? (Unrolling FP loops with multiple accumulators)
  5. Order of local variable allocation on the stack
  6. Can I use Intel syntax of x86 assembly with GCC?
  7. print a __m128i variable
  8. Stack allocation, padding, and alignment
  9. Why does integer division by -1 (negative one) result in FPE?
  10. Is it possible to tell the branch predictor how likely it is to follow the branch?
  11. SIMD signed with unsigned multiplication for 64-bit * 64-bit to 128-bit
  12. What does it mean to align the stack?
  13. Syscall implementation of exit()
  14. What’s missing/sub-optimal in this memcpy implementation?
  15. Drawing a character in VGA memory with GNU C inline assembly
  16. What’s the difference between logical SSE intrinsics?
  17. Fastest Implementation of the Natural Exponential Function Using SSE
  18. Fast counting the number of set bits in __m128i register
  19. In GNU C inline asm, what are the size-override modifiers for xmm/ymm/zmm for a single operand?
  20. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  21. multi-word addition using the carry flag
  22. Getting max value in a __m128i vector with SSE?
  23. Inline assembly that clobbers the red zone
  24. How to determine if memory is aligned?
  25. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  26. Why is gcc allowed to speculatively load from a struct?
  27. What is the effect of second argument in _builtin_prefetch()?
  28. How to convert 32-bit float to 8-bit signed char? (4:1 packing of int32 to int8 __m256i)
  29. Where can I find an official reference listing the operation of SSE intrinsic functions?
  30. Intel SSE: Why does `_mm_extract_ps` return `int` instead of `float`?

Leave a Comment