Is it possible to use SSE and SSE2 to make a 128-bit wide integer?

by

SIMD is meant to work on multiple small values at the same time, hence there won’t be any carry over to the higher unit and you must do that manually. In SSE2 there’s no carry flag but you can easily calculate the carry as carry = sum < a or carry = sum < b like this. Worse yet, SSE2 doesn’t have 64-bit comparisons either, so you must use some workaround like the one here

Here is an untested, unoptimized C code based on the idea above:

inline bool lessthan(__m128i a, __m128i b){
    a = _mm_xor_si128(a, _mm_set1_epi32(0x80000000));
    b = _mm_xor_si128(b, _mm_set1_epi32(0x80000000));
    __m128i t = _mm_cmplt_epi32(a, b);
    __m128i u = _mm_cmpgt_epi32(a, b);
    __m128i z = _mm_or_si128(t, _mm_shuffle_epi32(t, 177));
    z = _mm_andnot_si128(_mm_shuffle_epi32(u, 245),z);
    return _mm_cvtsi128_si32(z) & 1;
}

inline __m128i addi128(__m128i a, __m128i b)
{
    __m128i sum = _mm_add_epi64(a, b);
    __m128i mask = _mm_set1_epi64(0x8000000000000000);    
    if (lessthan(_mm_xor_si128(mask, sum), _mm_xor_si128(mask, a)))
    {
        __m128i ONE = _mm_setr_epi64(0, 1);
        sum = _mm_add_epi64(sum, ONE);
    }

    return sum;
}

As you can see, the code requires many more instructions and even after optimizing it may still be much longer than a simple 2 ADD/ADC pair in x86_64 (or 4 instructions in x86)

SSE2 will help though, if you have multiple 128-bit integers to add in parallel. However you need to arrange the high and low parts of the values properly so that we can add all the low parts at once, and all the high parts at once

See also

More Related Contents:

  1. What is the point of SSE2 instructions such as orpd?
  2. Fastest way to do horizontal SSE vector sum (or other reduction)
  3. What are the best instruction sequences to generate vector constants on the fly?
  4. Using ymm registers as a “memory-like” storage location
  5. Difference between MOVDQA and MOVAPS x86 instructions?
  6. Where is VPERMB in AVX2?
  7. Can PTEST be used to test if two registers are both zero or some other condition?
  8. What is the trick to learn x86 assembly language on Windows PC? [closed]
  9. Why do x86-64 instructions on 32-bit registers zero the upper part of the full 64-bit register?
  10. How to Calculate Jump Target Address and Branch Target Address?
  11. What is the purpose of XORing a register with itself? [duplicate]
  12. Does a memory barrier ensure that the cache coherence has been completed?
  13. Bomb lab phase_4
  14. What is the 0x10 in the “leal 0x10(%ebx), %eax” x86 assembly instruction?
  15. Does each PUSH instruction push a multiple of 8 bytes on x64?
  16. Can I add 64bit constants to 64bit registers?
  17. What does the bracket in `movl (%eax), %eax` mean?
  18. Questions about AT&T x86 Syntax design
  19. NASM Error Parsing, Instruction Expected
  20. Why is my assembly output in letter position? (1+1=b)
  21. Which is a better write barrier on x86: lock+addl or xchgl?
  22. X86 prefetching optimizations: “computed goto” threaded code
  23. x86-64 canonical address?
  24. What are the ESP and the EBP registers?
  25. What is the penalty of mixing EVEX and VEX encoded scheme?
  26. Second stage of bootloader prints garbage using Int 0x10/ah=0x0e
  27. How to use strings in emu8086
  28. How is POPCNT implemented in hardware?
  29. Solution needed for building a static IDT and GDT at assemble/compile/link time
  30. What is register %eiz?

Leave a Comment