Я компилирую этот код C:
int mode; // use aa if true, else bb
int aa[2];
int bb[2];
inline int auto0() { return mode ? aa[0] : bb[0]; }
inline int auto1() { return mode ? aa[1] : bb[1]; }
int slow() { return auto1() - auto0(); }
int fast() { return mode ? aa[1] - aa[0] : bb[1] - bb[0]; }
Обе функции slow() и fast() предназначены для выполнения одного и того же, хотя fast() делает это с одним утверждением ветки вместо двух. Я хотел проверить, может ли GCC разбить две ветки на одну. Я пробовал это с GCC 4.4 и 4.7 с различными уровнями оптимизации, такими как -O2, -O3, -Os и -Ofast. Он всегда дает такие же странные результаты:
медленный():
movl mode(%rip), %ecx
testl %ecx, %ecx
je .L10
movl aa+4(%rip), %eax
movl aa(%rip), %edx
subl %edx, %eax
ret
.L10:
movl bb+4(%rip), %eax
movl bb(%rip), %edx
subl %edx, %eax
ret
быстро():
movl mode(%rip), %esi
testl %esi, %esi
jne .L18
movl bb+4(%rip), %eax
subl bb(%rip), %eax
ret
.L18:
movl aa+4(%rip), %eax
subl aa(%rip), %eax
ret
Действительно, в каждой функции генерируется только одна ветвь. Однако slow() кажется неудовлетворительным: он использует одну дополнительную нагрузку в каждой ветки для aa[0] и bb[0]. Код fast() использует их прямо из памяти в subl, не загружая их сначала в регистр. Таким образом, slow() использует один дополнительный регистр и одну дополнительную инструкцию для каждого вызова.
Простой микро-тест показывает, что вызов fast() один миллиард раз занимает 0,7 секунды, против 1,1 секунды для slow(). Я использую Xeon E5-2690 с частотой 2,9 ГГц.
Почему это должно быть? Можете ли вы каким-либо образом настроить мой исходный код, чтобы GCC выполнял лучшую работу?
Изменить: вот результаты с clang 4.2 в Mac OS:
медленный():
movq [email protected](%rip), %rax ; rax = aa (both ints at once)
movq [email protected](%rip), %rcx ; rcx = bb
movq [email protected](%rip), %rdx ; rdx = mode
cmpl $0, (%rdx) ; mode == 0 ?
leaq 4(%rcx), %rdx ; rdx = bb[1]
cmovneq %rax, %rcx ; if (mode != 0) rcx = aa
leaq 4(%rax), %rax ; rax = aa[1]
cmoveq %rdx, %rax ; if (mode == 0) rax = bb
movl (%rax), %eax ; eax = xx[1]
subl (%rcx), %eax ; eax -= xx[0]
быстро():
movq [email protected](%rip), %rax ; rax = mode
cmpl $0, (%rax) ; mode == 0 ?
je LBB1_2 ; if (mode != 0) {
movq [email protected](%rip), %rcx ; rcx = aa
jmp LBB1_3 ; } else {
LBB1_2: ; // (mode == 0)
movq [email protected](%rip), %rcx ; rcx = bb
LBB1_3: ; }
movl 4(%rcx), %eax ; eax = xx[1]
subl (%rcx), %eax ; eax -= xx[0]
Интересно: clang генерирует ветвящиеся условные выражения для slow(), но одну ветвь для fast()! С другой стороны, slow() выполняет три нагрузки (две из которых являются спекулятивными, одна из них не нужна) против двух для fast(). Реализация fast() более "очевидна", и, как и в случае GCC, она короче и использует один меньше регистра.
GCC 4.7 на Mac OS обычно испытывает ту же проблему, что и в Linux. Тем не менее он использует тот же "загружаемый 8 байт, а затем дважды извлекает 4 байта" в качестве Clang в Mac OS. Такой интересный, но не очень актуальный, поскольку исходная проблема испускания subl с двумя регистрами, а не с одной памятью и одним регистром, одинакова на обеих платформах для GCC.
