gcc -O3选项如何使运行这么快？

Question

[Question] I run below code with O3 option. And then, I found that the perforamce of the code with O3, is nine times higher than performance of the code without O3.

Edit : I want to know the key of optimization technique, not reason. This is my question. I have never experienced x86 assembly. So it is too hard to understand x86 assembly code. That is the reason I posted this question. Or, could you explain the code with O3 option for me? ................................................................................

[C code] The code just executes addition.

float minmax_scale(unsigned int x) {

    // x_min = 0.0, x_max = 2040.0, new_min = 0.0, new_max = 1.0
    return (x/(255.0 * OFFSET));
}

int main(int argc, char** argv) {
  char ibuffer[INPUT_FEATURE];
  double H[TSIZE];

  // feature summation and scale
  for (int k = 0, i = 0; k < TSIZE; i+=OFFSET, k++) {
            H[k] = minmax_scale(
                   (unsigned int)ibuffer[i]
                   + ibuffer[i+1]
                   + ibuffer[i+2]
                   + ibuffer[i+3]
                   + ibuffer[i+4]
                   + ibuffer[i+5]
                   + ibuffer[i+6]
                   + ibuffer[i+7]
                  );
  }

  return 0;
}

[Assembly with O3]

    .file   "measure_fs_simple.c"
    .section    .text.unlikely,"ax",@progbits
.LCOLDB1:
    .text
.LHOTB1:
    .p2align 4,,15
    .globl  minmax_scale
    .type   minmax_scale, @function
minmax_scale:
.LFB0:
    .cfi_startproc
    pxor    %xmm0, %xmm0
    movl    %edi, %edi
    cvtsi2sdq   %rdi, %xmm0
    divsd   .LC0(%rip), %xmm0
    cvtsd2ss    %xmm0, %xmm0
    ret
    .cfi_endproc
.LFE0:
    .size   minmax_scale, .-minmax_scale
    .section    .text.unlikely
.LCOLDE1:
    .text
.LHOTE1:
    .section    .text.unlikely
.LCOLDB2:
    .section    .text.startup,"ax",@progbits
.LHOTB2:
    .p2align 4,,15
    .globl  main
    .type   main, @function
main:
.LFB1:
    .cfi_startproc
    xorl    %eax, %eax
    ret
    .cfi_endproc
.LFE1:
    .size   main, .-main
    .section    .text.unlikely
.LCOLDE2:
    .section    .text.startup
.LHOTE2:
    .section    .rodata.cst8,"aM",@progbits,8
    .align 8
.LC0:
    .long   0
    .long   1084219392
    .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609"
    .section    .note.GNU-stack,"",@progbits

[Assembly without O3]

 .file   "measure_fs_simple.c"
    .text
    .globl  minmax_scale
    .type   minmax_scale, @function
minmax_scale:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    %edi, -4(%rbp)
    movl    -4(%rbp), %eax
    testq   %rax, %rax
    js  .L2
    pxor    %xmm0, %xmm0
    cvtsi2sdq   %rax, %xmm0
    jmp .L3
.L2:
    movq    %rax, %rdx
    shrq    %rdx
    andl    $1, %eax
    orq %rax, %rdx
    pxor    %xmm0, %xmm0
    cvtsi2sdq   %rdx, %xmm0
    addsd   %xmm0, %xmm0
.L3:
    movsd   .LC0(%rip), %xmm1
    divsd   %xmm1, %xmm0
    cvtsd2ss    %xmm0, %xmm0
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   minmax_scale, .-minmax_scale
    .globl  main
    .type   main, @function
main:
.LFB1:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $2096, %rsp
    movl    %edi, -2084(%rbp)
    movq    %rsi, -2096(%rbp)
    movq    %fs:40, %rax
    movq    %rax, -8(%rbp)
    xorl    %eax, %eax
    movl    $0, -2072(%rbp)
    movl    $0, -2068(%rbp)
    jmp .L6
.L7:
    movl    -2068(%rbp), %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %edx
    movl    -2068(%rbp), %eax
    addl    $1, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $2, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $3, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $4, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $5, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $6, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %eax, %edx
    movl    -2068(%rbp), %eax
    addl    $7, %eax
    cltq
    movzbl  -1040(%rbp,%rax), %eax
    movsbl  %al, %eax
    addl    %edx, %eax
    movl    %eax, %edi
    call    minmax_scale
    cvtss2sd    %xmm0, %xmm0
    movl    -2072(%rbp), %eax
    cltq
    movsd   %xmm0, -2064(%rbp,%rax,8)
    addl    $8, -2068(%rbp)
    addl    $1, -2072(%rbp)
.L6:
    cmpl    $127, -2072(%rbp)
    jle .L7
    movl    $0, %eax
    movq    -8(%rbp), %rcx
    xorq    %fs:40, %rcx
    je  .L9
    call    __stack_chk_fail
.L9:
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE1:
    .size   main, .-main
    .section    .rodata
    .align 8
.LC0:
    .long   0
    .long   1084219392
    .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609"
    .section    .note.GNU-stack,"",@progbits

Answer 1

You code has no observable side-effects so the optimizer is simply discarding most of your code.

Using -O3 turns your main function into:

main:
    xorl    %eax, %eax
    ret

Which is equivalent to:

int main()
{
    return 0;
}

This shows that micro-benchmarking code can be difficult to do correctly.

Edit:

As pointed out in a comment below, the posted code doesn't initialize ibuffer[INPUT_FEATURE]. Reading an uninitialized variable is undefined behavior which makes the whole program malformed. This is a real problem and the code isn't required to produce reasonable results. Thanks @chqrlie