基於Intel處理器的PREFETCH指令的基本使用

以下這個例子很簡單，分別有兩個雙精度浮點類型的二維數組：double[512][1024]，共4MB數據，分為512行1024列，每列位8個字節。現在將每對浮點數組的每一行的第一個元素相加，然后將結果存到一個在棧上分配的數組。

算法的匯編文件如下所示：

.align 2
.text
.globl _fast_int_sqrt
.globl _get_cycles
.globl _naive_calc
.globl _opt_calc

_get_cycles:

    rdtsc
    shl     $32, %rdx
    or      %rdx, %rax
    ret

_naive_calc:

    mov     $100, %r9

native_loop:

    mov     $512, %r8
    xor     %rcx, %rcx
    xor     %rax, %rax

naive_process:

    fldl    (%rsi, %rcx)
    fldl    (%rdx, %rcx)

    fadd    %st(0), %st(1)
    fcmove  %st(1), %st(0)
    faddp   %st(0), %st(1)


    fstpl   (%rdi, %rax)

    add     $(8 * 1024), %rcx
    add     $8, %rax
    sub     $1, %r8
    jne     naive_process

    sub     $1, %r9
    jne     native_loop

    ret

_opt_calc:

    mov     $100, %r9

    opt_loop:

    mov     $512, %r8
    xor     %rcx, %rcx
    xor     %rax, %rax

opt_process:

    prefetcht0  (8 * 1024)(%rsi, %rcx)
    prefetcht0  (8 * 1024)(%rdx, %rcx)

    fldl    (%rsi, %rcx)
    fldl    (%rdx, %rcx)

    fadd    %st(0), %st(1)
    fcmove  %st(1), %st(0)
    faddp   %st(0), %st(1)


    fstpl   (%rdi, %rax)

    add     $(8 * 1024), %rcx
    add     $8, %rax
    sub     $1, %r8
    jne     opt_process

    sub     $1, %r9
    jne     opt_loop

    ret

上面可以看到opt_calc與naive_calc的唯一區別就是opt_calc多了兩條PREFETCH指令。

下面是C語言的測試函數：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern unsigned long get_cycles(void);

// Calculate 2 * (src1 + src2)
extern void naive_calc(void *dst, const void *src1, const void *src2);
extern void opt_calc(void *dst, const void *src1, const void *src2);

extern void hey(int y);

void hey(int y)
{
    // Initialize the buffers
    void *src1 = malloc(8 * 1024 * 512);
    void *src2 = malloc(8 * 1024 * 512);
    double dst[512];
    
    memset(src1, 0, 8 * 1024 * 512);
    memset(src2, 0, 8 * 1024 * 512);
    
    double *p = (double*)src1;
    *p = 3.141;
    p = (double*)src2;
    *p = 2.163;
    
    // naive
    unsigned long t1 = get_cycles();
    
    naive_calc(dst, src1, src2);        // rdi, rsi, rdx
    
    unsigned long t2 = get_cycles();
    
    // opt
    unsigned long t3 = get_cycles();
    
    opt_calc(dst, src1, src2);
    
    unsigned long t4 = get_cycles();
    
    printf("Naive cycles is: %lu\n", t2 - t1);
    printf("Opt cycles: %lu\n", t4 - t3);
    printf("The value is: %f\n", dst[0]);
    
    free(src1);
    free(src2);
}

這里為了增加些計算周期，所以用了乘以2的方式。

俺在Mac Mini CPU為P7350，2.00GHz的雙核基於45nm技術的Intel Core架構的處理器下測試，添加opt_calc的性能大約能增長8%到20%。