SSE multiplication of 4 32-bit integers

by

If you need signed 32×32 bit integer multiplication then the following example at software.intel.com looks like it should do what you want: 

static inline __m128i muly(const __m128i &a, const __m128i &b)
{
    __m128i tmp1 = _mm_mul_epu32(a,b); /* mul 2,0*/
    __m128i tmp2 = _mm_mul_epu32( _mm_srli_si128(a,4), _mm_srli_si128(b,4)); /* mul 3,1 */
    return _mm_unpacklo_epi32(_mm_shuffle_epi32(tmp1, _MM_SHUFFLE (0,0,2,0)), _mm_shuffle_epi32(tmp2, _MM_SHUFFLE (0,0,2,0))); /* shuffle results to [63..0] and pack */
}

You might want to have two builds – one for old CPUs and one for recent CPUs, in which case you could do the following:

static inline __m128i muly(const __m128i &a, const __m128i &b)
{
#ifdef __SSE4_1__  // modern CPU - use SSE 4.1
    return _mm_mullo_epi32(a, b);
#else               // old CPU - use SSE 2
    __m128i tmp1 = _mm_mul_epu32(a,b); /* mul 2,0*/
    __m128i tmp2 = _mm_mul_epu32( _mm_srli_si128(a,4), _mm_srli_si128(b,4)); /* mul 3,1 */
    return _mm_unpacklo_epi32(_mm_shuffle_epi32(tmp1, _MM_SHUFFLE (0,0,2,0)), _mm_shuffle_epi32(tmp2, _MM_SHUFFLE (0,0,2,0))); /* shuffle results to [63..0] and pack */
#endif
}

More Related Contents:

  1. Sum reduction of unsigned bytes without overflow, using SSE2 on Intel
  2. How to efficiently convert an 8-bit bitmap to array of 0/1 integers with x86 SIMD [duplicate]
  3. Fastest way to compute absolute value using SSE
  4. Header files for x86 SIMD intrinsics
  5. Convention for displaying vector registers
  6. Fastest way to do horizontal vector sum with AVX instructions [duplicate]
  7. Load address calculation when using AVX2 gather instructions
  8. Find the first instance of a character using simd
  9. What are the best instruction sequences to generate vector constants on the fly?
  10. How to implement atoi using SIMD?
  11. What is the meaning of “non temporal” memory accesses in x86
  12. How to merge a scalar into a vector without the compiler wasting an instruction zeroing upper elements? Design limitation in Intel’s intrinsics?
  13. How do I enable SSE for my freestanding bootable code?
  14. What’s the difference between logical SSE intrinsics?
  15. Fastest Implementation of Exponential Function Using AVX
  16. What is the point of SSE2 instructions such as orpd?
  17. Fast counting the number of set bits in __m128i register
  18. Per-element atomicity of vector load/store and gather/scatter?
  19. Fastest way to unpack 32 bits to a 32 byte SIMD vector
  20. Getting started with Intel x86 SSE SIMD instructions
  21. Difference between MOVDQA and MOVAPS x86 instructions?
  22. Efficient sse shuffle mask generation for left-packing byte elements
  23. Compare 16 byte strings with SSE
  24. inlining failed in call to always_inline ‘_mm_mullo_epi32’: target specific option mismatch
  25. How to compile Tensorflow with SSE4.2 and AVX instructions?
  26. What kind of address instruction does the x86 cpu have?
  27. What are the costs of failed store-to-load forwarding on x86?
  28. latency vs throughput in intel intrinsics
  29. Multiplying arbitrarily long sequences of ASCII digits by a single-digit multiplier
  30. Where can I find an official reference listing the operation of SSE intrinsic functions?

Leave a Comment