访问循环内使用 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) 给你指针的大小。

在这些情况下尝试使用 1450 而不是 sizeof(...)。

在我的笔记本电脑 (2015 Macbook) 上进行上述更改后的结果：

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

更新

当您真正应该使用 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

访问循环内使用 malloc 创建的变量是否比本地声明的变量更快？

Is accessing a variable created using malloc inside a loop faster than a locally declared variable?

c

performance

variables

malloc

calloc