Produce loops without cmp instruction in GCC

by

How about this. Compiler is gcc 4.9.0 mingw x64:

void triad(float *x, float *y, float *z, const int n) {
    float k = 3.14159f;
    intptr_t i;
    __m256 k4 = _mm256_set1_ps(k);

    for(i = -n; i < 0; i += 8) {
        _mm256_store_ps(&z[i+n], _mm256_add_ps(_mm256_load_ps(&x[i+n]), _mm256_mul_ps(k4, _mm256_load_ps(&y[i+n]))));
    }
}

gcc -c -O3 -march=corei7 -mavx2 triad.c

0000000000000000 <triad>:
   0:   44 89 c8                mov    eax,r9d
   3:   f7 d8                   neg    eax
   5:   48 98                   cdqe
   7:   48 85 c0                test   rax,rax
   a:   79 31                   jns    3d <triad+0x3d>
   c:   c5 fc 28 0d 00 00 00 00 vmovaps ymm1,YMMWORD PTR [rip+0x0]
  14:   4d 63 c9                movsxd r9,r9d
  17:   49 c1 e1 02             shl    r9,0x2
  1b:   4c 01 ca                add    rdx,r9
  1e:   4c 01 c9                add    rcx,r9
  21:   4d 01 c8                add    r8,r9

  24:   c5 f4 59 04 82          vmulps ymm0,ymm1,YMMWORD PTR [rdx+rax*4]
  29:   c5 fc 58 04 81          vaddps ymm0,ymm0,YMMWORD PTR [rcx+rax*4]
  2e:   c4 c1 7c 29 04 80       vmovaps YMMWORD PTR [r8+rax*4],ymm0
  34:   48 83 c0 08             add    rax,0x8
  38:   78 ea                   js     24 <triad+0x24>

  3a:   c5 f8 77                vzeroupper
  3d:   c3                      ret

Like your hand written code, gcc is using 5 instructions for the loop. The gcc code uses scale=4 where yours uses scale=1. I was able to get gcc to use scale=1 with a 5 instruction loop, but the C code is awkward and 2 of the AVX instructions in the loop grow from 5 bytes to 6 bytes.

More Related Contents:

  1. Competitive programming: "Time exceeded error"
  2. Why does GCC use multiplication by a strange number in implementing integer division?
  3. How can I indicate that the memory *pointed* to by an inline ASM argument may be used?
  4. What is the difference between ‘asm’, ‘__asm’ and ‘__asm__’?
  5. Using GCC to produce readable assembly?
  6. Can I use Intel syntax of x86 assembly with GCC?
  7. print a __m128i variable
  8. Why does GCC allocate more space than necessary on the stack, beyond what’s needed for alignment?
  9. Stack allocation, padding, and alignment
  10. Is it safe to read past the end of a buffer within the same page on x86 and x64?
  11. When to use earlyclobber constraint in extended GCC inline assembly?
  12. How does GCC implement variable-length arrays?
  13. What does it mean to align the stack?
  14. Syscall implementation of exit()
  15. Looping over arrays with inline assembly
  16. Why does GCC pad functions with NOPs?
  17. Reading a register value into a C variable [duplicate]
  18. How many GCC optimization levels are there?
  19. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  20. Why does gcc use movl instead of push to pass function args?
  21. x86_64 : is stack frame pointer almost useless?
  22. execute binary machine code from C
  23. calling assembly function from c
  24. Why do compilers insist on using a callee-saved register here?
  25. Why is gcc allowed to speculatively load from a struct?
  26. How to tell GCC to generate 16-bit code for real mode
  27. How to get the size of a C function from inside a C program or with inline assembly?
  28. What is the effect of second argument in _builtin_prefetch()?
  29. How do I compile the asm generated by GCC?
  30. Efficient 4×4 matrix multiplication (C vs assembly)

Leave a Comment