g++ -O3 为循环创建奇怪的指令

Question

I'm writing some codes for numerical computation using c++. I need to write code very carefully to help compiler to genrate good instructions. Then, I find some things strange for g++ 9.2 with -O3 flag. I am not an expert of assemble, So I need someone to help me or point out where I am wrong.

Full codes can be found here https://godbolt.org/z/fyuYtq . I copy and paste the key snippet here

void sum_twopointer(Elem *p1, Elem *p2, ptrdiff_t stride, ptrdiff_t start, ptrdiff_t end) {

    Elem sm = 0;
    for(auto i = start;i != end; ++i) {
        p1[0] = p2[0] + p2[0];
        p1 += stride;
        p2 += stride;
    }

}

It is compiled with g++ -O3 . The version of g++ is 9.2. The assemble code is

sum_twopointer(double*, double*, long, long, long):
  cmp rcx, r8
  je .L32
  lea r9, [0+rdx*8]
  xor eax, eax
  cmp rdx, 1
  jne .L36
.L34:
  movsd xmm0, QWORD PTR [rsi+rax]
  add rcx, 1
  addsd xmm0, xmm0
  movsd QWORD PTR [rdi+rax], xmm0
  add rax, r9
  cmp r8, rcx
  jne .L34
.L32:
  ret
.L36:
  movsd xmm0, QWORD PTR [rsi+rax]
  add rcx, 1
  addsd xmm0, xmm0
  movsd QWORD PTR [rdi+rax], xmm0
  add rax, r9
  cmp r8, rcx
  jne .L36
  ret

As my understanding, the compiler is trying to do some optimization for the special case that stride is just 1, so it create a new branch for the case that stride==1, but it doesn't do anything further. Note that the codes following the .L34 are just identical to those following .L36 .

I have done some benchmarks for this. The performance for stride=1 and stride=2, are list in the following. The code is there https://gist.github.com/lhprojects/dac3a9fcf15bd5b1ec365ba6a87c679d

g++ -O2
---------------------------------------------------------------
Benchmark                     Time             CPU   Iterations
---------------------------------------------------------------
BM_twopointer/8192/1       3743 ns         3742 ns       185062      stride=1
BM_twopointer/8192/2       1980 ns         1980 ns       328523      stride=2

g++ -O3
---------------------------------------------------------------
Benchmark                     Time             CPU   Iterations
---------------------------------------------------------------
BM_twopointer/8192/1       5006 ns         5001 ns       120725      stride=1
BM_twopointer/8192/2       2043 ns         2041 ns       333914      stride=2

Anyway, for stride=1, performance get worse with -O3 compared to -O2. I want to know what happend to my code. Did I trigger some undefined behavior in c++? Or simply, there is a defect in code optimization in g++. (I am sorry if my English writing let you feel very confused.)

Answer 1

I believe that the compiler needs to know that p1 and p2 don't overlap ... declaring them as __restrict pointers should allow the compiler to actually utilize the simd instructions. It does seem odd to me that it would create a special case for stride==1, but then not do anything with that knowledge.