我用C语言实现的memcpy算法

phoneix

这是我的一个开源程序库的其中一个函数（http://gforge.osdn.net.cn/frs/?group_id=86）
程序源码如下：

typedef  unsigned char  ylib_byte_t;
typedef  unsigned int   ylib_word_t;

enum YOUNG_LIBRARY_MEMORY_FUNCTION_CONSTANT
{
    /* 循环展开的次数 */
    OUTSPREAD = 16,

    /* 最大余数，先将其按位取反，再与整数 N 按位与，
     * 可得最接近 N 的 OUTSPREAD 的倍数 */
    RESIDUE = OUTSPREAD - 1
};

#define  CYCLE_OUTSPREAD( expression ) \
         expression;  expression;  expression;  expression; \
         expression;  expression;  expression;  expression; \
         expression;  expression;  expression;  expression; \
         expression;  expression;  expression;  expression;

    void* ylib_memcopy( void* dst, const void* src, size_t count )
    {
        ylib_byte_t *d, *s;
        ylib_word_t* dstword = (ylib_word_t*)dst;
        const ylib_word_t* srcword = (const ylib_word_t*)src;
        size_t tmp, word_count = count / sizeof(ylib_word_t);
        size_t word_outspread = word_count & ~((size_t)RESIDUE);

        /* 复制可被循环展开的机器字 */
        for( tmp = 0; tmp < word_outspread; tmp += OUTSPREAD )
        {
            CYCLE_OUTSPREAD( *dstword++ = *srcword++ )
        }

        /* 复制剩下的机器字 */
        for( ; tmp < word_count; ++tmp )
            *dstword++ = *srcword++;

        /* 复制剩下的字节 */
        d = (ylib_byte_t*)dstword;
        s = (ylib_byte_t*)srcword;
        for( tmp *= sizeof(ylib_word_t); tmp < count; ++tmp )
            *d++ = *s++;

        return dst;
    }

void test_memcpy(void)
{
    double sec;
    clock_t begin, end;
    int i, dst[10000];
    int src[10000];

    begin = clock();
    for( i = 0; i < 100000; ++i )
        ylib_memcopy( dst, src, sizeof(int) * 10000 );
    end = clock();
    sec = (double)(end - begin) / (double)CLOCKS_PER_SEC;
    printf( "\nylib_memcopy time = %f\n", sec );

    begin = clock();
    for( i = 0; i < 100000; ++i )
        memcpy( dst, src, sizeof(int) * 10000 );
    end = clock();
    sec = (double)(end - begin) / (double)CLOCKS_PER_SEC;
    printf( "\nmemcpy time = %f\n", sec );
}

比VC6.0的稍快（用默认的release设置编译）： 1.078 VS 1.109
比VC7.1的慢大概1/4（用默认的release设置编译）： 1.078 VS 0.813
比DEV-CPP4.9.9.2慢近一倍（-O2 优化） ： 1.093 VS 0.532

[ 本帖最后由 phoneix 于 2007-4-30 12:57 编辑 ]

flw2

memcpy( dst, src, sizeof(int) * 10000 );

10000*4 == 39 K

很少需要一次这么多的复制，很少很少。

应该统计一下 你的10000编成10会怎么样，100又会如何。找到一个点和标准库的实现一样

思一克

你这个也不会比memcpy快。

你有比较结果？

flw2

#include<string.h>
#include<stdlib.h>
char buf1[4096*10];
char buf2[4096*10];
int main()
{
        int i = 0;
        while(i++ < 100000)
                memcpy(buf1,buf2,4096*10);
        exit(0);
}
gcc编译 P4 3.0 0.5秒

mingyanguo

效率与每次拷贝的大小有关。
你测试一下每次1, 4, 8, 16, 32, 64, 128...字节时效率如何。

思一克

测试程序和结果
是memcpy速度的1/3多点。

其实你根本不应该写这样的程序。因为你是用C复制*dst = *src的循环，怎么能和优化为最快机器串操作指令比速度？


./a.out
src[AFFEC008], dst[A7FEB008], start :
4480000
1850000

1. 
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <time.h>
   
5. #include <stdlib.h>
   
6. 
   
7. 
   
8. /*
   
9. void *  mmcp(void*, const void*, size_t);
   
10. 
    
11. void *  mmcp(void* dst, const void *src, size_t size)
    
12. {
    
13.         typedef struct {char bytes[size]; } buffer_t;
    
14. 
    
15.         const buffer_t *psrc = (const buffer_t *)src;
    
16.         buffer_t *pdst = (buffer_t *)dst;
    
17. 
    
18.   *pdst = *psrc;
    
19. 
    
20.   return dst;
    
21. }
    
22. */
    
23. 
    
24. typedef  unsigned char  ylib_byte_t;
    
25. typedef  unsigned int   ylib_word_t;
    
26. 
    
27. enum YOUNG_LIBRARY_MEMORY_FUNCTION_CONSTANT
    
28. {
    
29.     OUTSPREAD = 16,
    
30.     RESIDUE = OUTSPREAD - 1
    
31. };
    
32. 
    
33. #define  CYCLE_OUTSPREAD( expression ) \
    
34.          expression;  expression;  expression;  expression; \
    
35.          expression;  expression;  expression;  expression; \
    
36.          expression;  expression;  expression;  expression; \
    
37.          expression;  expression;  expression;  expression;
    
38. 
    
39. void* mmcp( void* dst, const void* src, size_t count )
    
40. {
    
41.         ylib_byte_t *d, *s;
    
42.         ylib_word_t* dstword = (ylib_word_t*)dst;
    
43.         const ylib_word_t* srcword = (const ylib_word_t*)src;
    
44.         size_t tmp, word_count = count / sizeof(ylib_word_t);
    
45.         size_t word_outspread = word_count & ~((size_t)RESIDUE);
    
46. 
    
47.         /* 赂麓脰驴杀禄循禄路展驴陋碌幕煤 */
    
48.         for( tmp = 0; tmp < word_outspread; tmp += OUTSPREAD )
    
49.         {
    
50.             CYCLE_OUTSPREAD( *dstword++ = *srcword++ )
    
51.         }
    
52. 
    
53.         /* 赂麓脰剩脧碌幕煤 */
    
54.         for( ; tmp < word_count; ++tmp )
    
55.             *dstword++ = *srcword++;
    
56. 
    
57.         /* 赂麓脰剩脧碌脛纸脷*/
    
58.         d = (ylib_byte_t*)dstword;
    
59.         s = (ylib_byte_t*)srcword;
    
60.         for( tmp *= sizeof(ylib_word_t); tmp < count; ++tmp )
    
61.             *d++ = *s++;
    
62. 
    
63.         return dst;
    
64. }
    
65. 
    
66. 
    
67. 
    
68. int main(void)
    
69. {
    
70.         size_t size = 1024 * 1024 * 128;
    
71.         size_t count = 30;
    
72.         clock_t t;
    
73.         int i;
    
74. 
    
75.         char *src = (char *)malloc(size);
    
76.         char *dst = (char *)malloc(size);
    
77. 
    
78.         memcpy(dst, src, size);
    
79. 
    
80.         printf("src[%08X], dst[%08X], start :\n", src, dst);
    
81. 
    
82.         t = clock();
    
83.         for (i = 0; i < count; i ++)
    
84.                 mmcp(dst, src, size);
    
85.         printf("%ld\n", clock() - t);
    
86. 
    
87.         t = clock();
    
88.         for (i = 0; i < count; i ++)
    
89.                 memcpy(dst, src, size);
    
90.         printf("%ld\n", clock() - t);
    
91. 
    
92.         return 0;
    
93. }
    
94. 
    
95. 
    

复制代码

MMMIX

原帖由 思一克 于 2007-4-30 13:10 发表
测试程序和结果
是memcpy速度的1/3多点。

其实你根本不应该写这样的程序。因为你是用C复制*dst = *src的循环，怎么能和优化为最快机器串操作指令比速度？

对头，许多时候 memcpy 之类的操作直接就是用汇编实现的。

phoneix

重新修改了一下测试程序：
void test_memcpy(void)
{
    double sec;
    clock_t begin, end;
    int i;
    int dst[100];
    int src[100] = { 0 };

    begin = clock();
    for( i = 0; i < 1000000; ++i )
        memcpy( dst, src, sizeof(int) * 100 );
    end = clock();
    sec = (double)(end - begin) / (double)CLOCKS_PER_SEC;
    printf( "\nbegin = %ld, end = %ld, memcpy time = %f\n",
            begin, end, sec );

    begin = clock();
    for( i = 0; i < 1000000; ++i )
        ylib_memcopy( dst, src, sizeof(int) * 100 );
    end = clock();
    sec = (double)(end - begin) / (double)CLOCKS_PER_SEC;
    printf( "\nbegin = %ld, end = %ld, ylib_memcopy time = %f\n",
            begin, end, sec );
}

此时，我写的函数比DEV-CPP自带的memcpy快近一倍 ： 0.063 VS 0.140
而和VC 6.0自带的memcpy相比却变成了： 0.093 VS 0.000
和VC 7.0自带的memcpy也类似： 0.078 VS 0.000

天壤之别啊！看来微软还是更务实一些，只对小数据优化，毕竟，小数据的复制还是用的多一些。

思一克

你的程序，只能比没有用机器串操作指令的（而是用C写的）memcpy的库快。对于使用了用机器串操作指令的就没有优势了。

phoneix

回应楼上的各位，我没有说要取代标准库的memcpy，这个函数是我的程序库中的一个，
在我的程序库中通过一个宏来控制使用自定义的函数还是使用标准库的函数，它的使用是有前提的。
我的程序库是准备在嵌入式硬件的裸机上运行用的，有的硬件平台只有一个简单的GCC编译器的移植，
而没有标准库的移植，这个时候就可以使用这个函数替换memcpy保证程序库的正确编译。