сумма перекрывающихся массивов, авто-векторизация и ограничение

Я не понимаю, в чем проблема. Тестирование в Linux / 64 бит, GCC 4.6, -O3, -mtune = native, -msse4.1 (то есть очень старый компилятор / система), этот код

void dot_int(int *a, int *b, int *c, int n) {
for(int i=0; i<n; ++i) {
c[i] = a[i] + b[i];
}
}

компилируется в этот внутренний цикл:

.L4:
movdqu  (%rdi,%rax), %xmm1
addl    $1, %r8d
movdqu  (%rsi,%rax), %xmm0
paddd   %xmm1, %xmm0
movdqu  %xmm0, (%rdx,%rax)
addq    $16, %rax
cmpl    %r8d, %r10d
ja      .L4
cmpl    %r9d, %ecx
je      .L1

Пока этот код

void dot_int_restrict(int * __restrict a, int * __restrict b, int * __restrict c, int n) {
for(int i=0; i<n; ++i) {
c[i] = a[i] + b[i];
}
}

компилируется в это:

.L15:
movdqu  (%rbx,%rax), %xmm0
addl    $1, %r8d
paddd   0(%rbp,%rax), %xmm0
movdqu  %xmm0, (%r11,%rax)
addq    $16, %rax
cmpl    %r10d, %r8d
jb      .L15
addl    %r12d, %r9d
cmpl    %r12d, %r13d
je      .L10

Как вы можете видеть, нагрузка на один меньше. Я предполагаю, что это правильно, что нет необходимости явно загружать память перед выполнением суммирования, поскольку результат ничего не перезаписывает.

Также есть место для дополнительных оптимизаций — GCC не знает, что параметры f.i. Выровненный по 128 битам, следовательно, он должен генерировать огромную преамбулу, чтобы проверить, нет ли проблем с выравниванием (YMMV), и иметь возможность работать с дополнительными не выровненными частями (или менее широкими, чем 128 бит). Это на самом деле происходит с обеими версиями выше. Это полный код, сгенерированный для dot_int:

dot_int:
.LFB626:
.cfi_startproc
testl   %ecx, %ecx
pushq   %rbx
.cfi_def_cfa_offset 16
.cfi_offset 3, -16
jle     .L1
leaq    16(%rdx), %r11
movl    %ecx, %r10d
shrl    $2, %r10d
leal    0(,%r10,4), %r9d
testl   %r9d, %r9d
je      .L6
leaq    16(%rdi), %rax
cmpl    $6, %ecx
seta    %r8b
cmpq    %rax, %rdx
seta    %al
cmpq    %r11, %rdi
seta    %bl
orl     %ebx, %eax
andl    %eax, %r8d
leaq    16(%rsi), %rax
cmpq    %rax, %rdx
seta    %al
cmpq    %r11, %rsi
seta    %r11b
orl     %r11d, %eax
testb   %al, %r8b
je      .L6
xorl    %eax, %eax
xorl    %r8d, %r8d
.p2align 4,,10
.p2align 3
.L4:
movdqu  (%rdi,%rax), %xmm1
addl    $1, %r8d
movdqu  (%rsi,%rax), %xmm0
paddd   %xmm1, %xmm0
movdqu  %xmm0, (%rdx,%rax)
addq    $16, %rax
cmpl    %r8d, %r10d
ja      .L4
cmpl    %r9d, %ecx
je      .L1
.L3:
movslq  %r9d, %r8
xorl    %eax, %eax
salq    $2, %r8
addq    %r8, %rdx
addq    %r8, %rdi
addq    %r8, %rsi
.p2align 4,,10
.p2align 3
.L5:
movl    (%rdi,%rax,4), %r8d
addl    (%rsi,%rax,4), %r8d
movl    %r8d, (%rdx,%rax,4)
addq    $1, %rax
leal    (%r9,%rax), %r8d
cmpl    %r8d, %ecx
jg      .L5
.L1:
popq    %rbx
.cfi_remember_state
.cfi_def_cfa_offset 8
ret
.L6:
.cfi_restore_state
xorl    %r9d, %r9d
jmp     .L3
.cfi_endproc

Теперь в вашем случае эффективно не выровнены (как они в стеке), но если вы можете сделать их выровненными и сказать GCC так, то вы можете улучшить генерацию кода:

typedef int intvec __attribute__((vector_size(16)));

void dot_int_restrict_alig(intvec * restrict a,
intvec * restrict b,
intvec * restrict c,
unsigned int n) {
for(unsigned int i=0; i<n; ++i) {
c[i] = a[i] + b[i];
}
}

Это генерирует этот код без преамбулы:

dot_int_restrict_alig:
.LFB628:
.cfi_startproc
testl   %ecx, %ecx
je      .L23
subl    $1, %ecx
xorl    %eax, %eax
addq    $1, %rcx
salq    $4, %rcx
.p2align 4,,10
.p2align 3
.L25:
movdqa  (%rdi,%rax), %xmm0
paddd   (%rsi,%rax), %xmm0
movdqa  %xmm0, (%rdx,%rax)
addq    $16, %rax
cmpq    %rcx, %rax
jne     .L25
.L23:
rep
ret
.cfi_endproc

Обратите внимание на использование совмещенных 128-битных инструкций загрузки (movdqa, как выровнен, против movdquВыровненный)