Yığın bellekte memcpy neden yığın belleğe göre çok daha hızlı? aşağıdaki gibi

Question

Önce bir dosya oluşturmak: Ben kullanırsanız

clock_t start = clock(); 

event_data stack_buffer; 
event_data* heap_buffer = new event_data(); 

for(int j=0; j<10000; j++) 
{ 
    boost::iostreams::mapped_file mmap("C:\\test.bin", boost::iostreams::mapped_file::readonly); 
    const char* data = mmap.const_data(); 
    for(int i=0; i<100000; i++) 
    { 
     const event_data* evt = reinterpret_cast<const event_data*>(data) + i; 
     // Use memcpy to copy data to buffer, either (1) or (2) 
     // memcpy(&stack_buffer, evt, sizeof(event_data)); <== (1) 
     // memcpy(heap_buffer, evt, sizeof(event_data)); <== (2) 
    } 
} 

clock_t end = clock(); 

printf("%f sec\n", (double) (end - start)/CLOCKS_PER_SEC); 

(1), bu yazdırır: Bundan sonra

struct event_data 
{ 
    uint32_t data_1; 
    uint32_t data_2; 
    uint32_t data_3; 
    uint32_t data_4; 
    uint32_t data_5; 
    uint32_t data_6; 
    uint32_t data_7; 
    uint32_t data_8; 
}; 

FILE* fp = fopen("C:\\test.bin", "w+b"); 
for(int i=0; i<100000; i++) 
{ 
    event_data data; 
    fwrite(&data, sizeof(event_data), 1, fp); 
} 
fclose(fp); 

Ben dosyadan veri okumak için Boost bellek haritalı dosyayı kullanmaya çalıştı ~ 0,56 sn. Eğer (2) kullanırsam, ~ '26 .6 sn 'yazdırır. Sonuçlar neden bu kadar farklı?

Answer 1

yazdım iki işlev:

foo1

_Z4foo1v: 
.LFB5: 
    pushq %rdi 
    .seh_pushreg %rdi 
    pushq %rsi 
    .seh_pushreg %rsi 
    .seh_endprologue 
    movq .refptr.moo1(%rip), %rsi 
    movq .refptr.moo2(%rip), %rax 
    movq (%rsi), %rdx 
    leaq 8(%rax), %rdi 
    movq %rax, %rcx 
    andq $-8, %rdi 
    movq %rdx, (%rax) 
    movq 392(%rsi), %rdx 
    subq %rdi, %rcx 
    subq %rcx, %rsi 
    addl $400, %ecx 
    shrl $3, %ecx 
    movq %rdx, 392(%rax) 
    rep movsq 
    movl 56(%rax), %edx 
    addl 308(%rax), %edx 
    movl %edx, 8(%rax) 
    popq %rsi 
    popq %rdi 
    ret 

foo2

_Z4foo2v: 
.LFB6: 
    .seh_endprologue 
    ret 

:

extern int moo1 [100]; 
extern int moo2 [100]; 


void foo1() 
{ 
    memcpy(moo2, moo1, sizeof(moo1)); 
    moo2[2] = moo2[77] + moo2[14]; 
} 

void foo2() 
{ 
    int moo3[100]; 

    memcpy(moo3, moo1, sizeof(moo1)); 
    moo3[2] = moo3[77] + moo3[14]; 
} 

İşte gcc onları derler ne

Kendi sonuçlarınızı çizin.