루프 내에서 malloc을 사용하여 생성 된 변수에 로컬로 선언 된 변수보다 빠르게 액세스하고 있습니까?

Question

루프에 있고 변수를 사용하는 응용 프로그램이 있습니다. 기본적으로 문자열을 변수로 복사 한 다음 다음 문자열로 이동합니다. 나는 내가 필요한 변수를 어떻게 선언해야하는지 궁금해서이 코드를 테스트하여 어느 것이 더 빠를 것인지 테스트했다. malloc이 내가 로컬로 선언 한 변수보다 빠르다는 것은 흥미 롭다. 나는 또한 메모리를 제로화 한 이후로 calloc과 그 속도가 느린 것에 던져 넣었다.

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#include <string.h> 
#include <sys/resource.h> 

struct rusage ruse; 
#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + ruse.ru_stime.tv_sec + 1e-6 * (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec)) 

void gen_random_letters(char *random_buffer, const int len) 
{ 
    int i; 
    static const char alphanum[] = 
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
     "abcdefghijklmnopqrstuvwxyz"; 

    /* initialize random seed: */ 
    srand (time(NULL)); 

    for (i = 0; i < len; ++i) { 
     random_buffer[i] = alphanum[rand() % (sizeof(alphanum) - 1)]; 
    } 

    random_buffer[len] = 0; 
} 

int main() 
{ 
    clock_t tic; 
    clock_t toc; 
    int counter; 
    char *buffer_calloc; 
    char *buffer_malloc; 
    char buffer_local_variable[1450]; 
    char copy_this[1450]; 
    double time_spent; 
    double first, second; 
    int loop_max; 

    loop_max = 5000000; 
    gen_random_letters(copy_this, sizeof(copy_this)); 

    /* Try the locally declared variable */ 
    tic = clock(); 
    first = CPU_TIME; 
    for (counter = 0; counter <= loop_max; counter++) 
    { 
     //memset(buffer_local_variable,0,sizeof(buffer_local_variable)); 
     memcpy(buffer_local_variable,copy_this,sizeof(buffer_local_variable)); 
    } 
    toc = clock(); 
    second = CPU_TIME; 
    time_spent = (toc - tic)/CLOCKS_PER_SEC; 
    printf("cpu local_variable : %.2f secs\n", second - first); 
    printf("Elapsed local_variable: %f seconds\n\n", time_spent); 

    /* Try calloc */ 
    tic = clock(); 
    first = CPU_TIME; 
    for (counter = 0; counter <= loop_max; counter++){ 
     buffer_calloc = calloc(1450,sizeof(char*)); 
     memcpy(buffer_calloc,copy_this,sizeof(buffer_calloc)); 
     free(buffer_calloc); 
    } 
    toc = clock(); 
    second = CPU_TIME; 
    time_spent = (toc - tic)/CLOCKS_PER_SEC; 
    printf("cpu calloc : %.2f secs\n", second - first); 
    printf("Elapsed calloc : %f seconds\n\n", time_spent); 

    /* And now malloc */ 
    tic = clock(); 
    first = CPU_TIME; 
    for (counter = 0; counter <= loop_max; counter++){ 
     buffer_malloc = malloc(1450 * sizeof(char*)); 
     memcpy(buffer_malloc,copy_this,sizeof(buffer_malloc)); 
     free(buffer_malloc); 
    } 
    toc = clock(); 
    second = CPU_TIME; 
    time_spent = (toc - tic)/CLOCKS_PER_SEC; 
    printf("Cpu malloc : %.2f secs\n", second - first); 
    printf("Elapsed malloc : %f seconds\n", time_spent); 

    return 0; 
} 

결과 :

cpu local_variable : 0.57 secs 
Elapsed local_variable : 0.000000 seconds 

cpu calloc : 2.08 secs 
Elapsed calloc : 2.000000 seconds 

Cpu malloc : 0.39 secs 
Elapsed malloc : 0.000000 seconds 

나는 그것을 위해 메모리가 이미 모든 루프를 호출 할 필요가 malloc을 달리 할당되기 때문에 빨리로 로컬로 선언 된 변수를 기다리고 있었다. 내 코드에 결함이 있기 때문에 malloc이 더 빠르거나 그게 바로 그 방법입니다.

Answer 1

코드에서 calloc 및 malloc 건의 잘못된 바이트 수가 복사됩니다. sizeof(buffer_malloc)는 포인터의 크기를 알려줍니다.

이러한 경우 sizeof(...) 대신 1450을 사용해보십시오. 위의 변화에 ​​내 노트북 ​​(2015 맥북)에

결과 :

cpu local_variable : 0.16 secs 
Elapsed local_variable: 0.000000 seconds 

cpu calloc : 1.60 secs 
Elapsed calloc : 1.000000 seconds 

Cpu malloc : 0.56 secs 
Elapsed malloc : 0.000000 seconds 

UPDATE 당신이 정말로 1450 * sizeof(char)를 사용해야하는 경우 또한 malloc으로 1450 * sizeof(char*) 바이트를 할당하고

. 그 수정 후

는, 결과는 좀 더 가까이 얻을 :

cpu local_variable : 0.16 secs 
Elapsed local_variable: 0.000000 seconds 

cpu calloc : 0.76 secs 
Elapsed calloc : 0.000000 seconds 

Cpu malloc : 0.57 secs 
Elapsed malloc : 0.000000 seconds