Quando eu compilo o código C com um compilador recente em um sistema amd64 ou x86, as funções são alinhadas a um múltiplo de 16 bytes. Quanto esse alinhamento realmente importa nos processadores modernos? Existe uma enorme penalidade de desempenho associada à chamada de uma função desalinhada?

Referência

Executei a seguinte marca de microbench (call.S):

// benchmarking performance penalty of function alignment.
#include <sys/syscall.h>

#ifndef SKIP
# error "SKIP undefined"
#endif

#define COUNT 1073741824

        .globl _start
        .type _start,@function
_start: mov $COUNT,%rcx
0:      call test
        dec %rcx
        jnz 0b
        mov $SYS_exit,%rax
        xor %edi,%edi
        syscall
        .size _start,.-_start

        .align 16
        .space SKIP
test:   nop
        rep
        ret
        .size test,.-test

com o seguinte script de shell:

#!/bin/sh

for i in `seq 0 15` ; do
        echo SKIP=$i
        cc -c -DSKIP=$i call.S
        ld -o call call.o
        time -p ./call
done

Em uma CPU que se identifica comoCPU Intel (R) Core (TM) i7-2760QM a 2.40GHz de acordo com/proc/cpuinfo. O deslocamento não fez diferença para mim, o benchmark levou 1,9 segundos para ser executado.

Por outro lado, em outro sistema com uma CPU que se reporta como umCPU Intel (R) Core (i) i7 L 640 a 2.13GHz, a referência leva 6,3 segundos, exceto se você tiver um deslocamento de 14 ou 15, em que o código leva 7,2 segundos. Eu acho que é porque a função começa a abranger várias linhas de cache.