memcpy性能测试

存在的问题

1。测试结果以微秒为单位，明显不靠谱
2.gettimeofday精度不足，对高精度需要用汇编改写
3.存在cache缓存，建议测试时尽量模拟真实环境

至少存在以上三个问题，不知道为什么会被搞成“推荐文章”，

1。堆、栈中的内存区别
不同点：
堆内存是malloc分配的，直到程序结束或用free释放
栈内存是函数局部变量或参数，函数结束则自动释放
相同点：
二者都存在于内存中，对于memcpy的测试没影响，因此使用栈内存方便。
2。测试的开始，结束边界
t1 = time1;
for ( ... ) {
memcpy(...);
}
t2 = time2;
delta = t2 - t1;
3。char[1024]的大小
1)位（比特)，bit，表示0或1，速率 （bps)bits per second
2）字节，byte, 1byte = 8bits，速率(Bps)Byte per second
56Kbps拨号上网的速度是7 byte/s
char是8位，1个字节，char[1024]就是1024个字节，也就是1KB
32位系统，int是32位，4个字节大小
4。多组数据测试，1K，10K，100K，1M
1K,char[1024];
10K,char[1024*10];
100K,char[1024*100];
1M,char[1024*1024];
5。GCC优化级别，-O0，-O1，-O2，-O3，-O，-Os
-O0，不做优化
-O1,-O，减少编译后的代码大小和执行时间（reduce code size and execution time）
-O2，在-O1的基础上，增加编译时间和生成的代码的性能
-O3，在-O2的基础上，还加了剩下的几个优化选项
-Os，在-O2的基础上，但是生成的代码比-O2小
由于发行版的程序肯定会做优化，因此测试程序使用-O2
详见文章末尾的参考资料
6。GCC版本
gcc-4.4.1

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

#include <sys/time.h>

/* 测试数据大小 */
#define SIZE_1K     1024
#define SIZE_10K    1024*10
#define SIZE_100K   1024*100
#define SIZE_1M     1024*1024


/* 1M数据*/
void test_1M(void)
{
    struct timeval start;
    struct timeval end;
    int ret_start = -1;
    int ret_end = -1;

    char src[SIZE_1M];
    char dst[SIZE_1M];

    int i;
    long delta_time;

    /* 测试开始 */
    ret_start = gettimeofday(&start, NULL);
    for ( i = 0; i< 1000; ++i )
    {
        memcpy(src, dst, SIZE_1M);
    }
    ret_end = gettimeofday(&end, NULL);

    /* 测试结束,确保函数执行成功 */
    if ( ret_start != 0 || ret_end != 0 )
    {
        exit( -1 );
    }

    /* 输出测试结果 */
    delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    fprintf(stderr, "SIZE_1M, \t\t%ldus\n", delta_time);
}

/* 100K数据*/
void test_100k(void)
{
    struct timeval start;
    struct timeval end;
    int ret_start = -1;
    int ret_end = -1;

    char src[SIZE_100K];
    char dst[SIZE_100K];

    int i;
    long delta_time;

    /* 测试开始 */
    ret_start = gettimeofday(&start, NULL);
    for ( i = 0; i< 1000; ++i )
    {
        memcpy(src, dst, SIZE_100K);
    }
    ret_end = gettimeofday(&end, NULL);

    /* 测试结束,确保函数执行成功 */
    if ( ret_start != 0 || ret_end != 0 )
    {
        exit( -1 );
    }

    /* 输出测试结果 */
    delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    fprintf(stderr, "SIZE_100K, \t\t%ldus\n", delta_time);
}

/* 10K数据*/
void test_10k(void)
{
    struct timeval start;
    struct timeval end;
    int ret_start = -1;
    int ret_end = -1;

    char src[SIZE_10K];
    char dst[SIZE_10K];

    int i;
    long delta_time;

    /* 测试开始 */
    ret_start = gettimeofday(&start, NULL);
    for ( i = 0; i< 1000; ++i )
    {
        memcpy(src, dst, SIZE_10K);
    }
    ret_end = gettimeofday(&end, NULL);

    /* 测试结束,确保函数执行成功 */
    if ( ret_start != 0 || ret_end != 0 )
    {
        exit( -1 );
    }

    /* 输出测试结果 */
    delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    fprintf(stderr, "SIZE_10k, \t\t%ldus\n", delta_time);
}

/* 1K数据*/
void test_1k(void)
{
    struct timeval start;
    struct timeval end;
    int ret_start = -1;
    int ret_end = -1;

    char src[SIZE_1K];
    char dst[SIZE_1K];

    int i;
    long delta_time;

    /* 测试开始 */
    ret_start = gettimeofday(&start, NULL);
    for ( i = 0; i< 1000; ++i )
    {
        memcpy(src, dst, SIZE_1K);
    }
    ret_end = gettimeofday(&end, NULL);

    /* 测试结束,确保函数执行成功 */
    if ( ret_start != 0 || ret_end != 0 )
    {
        exit( -1 );
    }

    /* 输出测试结果 */
    delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    fprintf(stderr, "SIZE_1k, \t\t%ldus\n", delta_time);
}

int main(int argc, char **argv)
{

    test_1k();

    test_10k();

    test_100k();

    test_1M();

    return 0;
}

测试结果：1000拷贝操作所消耗的时间

SIZE_1k,                350us
SIZE_10k,               5502us
SIZE_100K,              96624us
SIZE_1M,                689399us

参考：