我的memcpy还是不如标准库的厉害

dulao5

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <memory.h>
   
5. 
   
6. #ifdef WIN32
   
7.     #include <windows.h>
   
8. #else
   
9.     #include<sys/time.h>
   
10.     #include<unistd.h>
    
11. #endif
    
12. 
    
13. double get_time_ms()
    
14. {
    
15. #ifdef WIN32
    
16.     return (double)GetTickCount();
    
17. #else
    
18.     struct timeval tv;
    
19.     struct timezone tz;
    
20.     gettimeofday (&tv , &tz);
    
21.     return tv.tv_sec * 1000 + tv.tv_usec / 1000 ;
    
22. #endif
    
23. }
    
24. 
    
25. //这是微软公开的crt src文件夹内的源代码:
    
26. void * memcpy_1 (void * dst, void * src , size_t n)
    
27. {
    
28.     void * ret = dst;
    
29.     while (n--) {
    
30.             *(char *)dst = *(char *)src;
    
31.             dst = (char *)dst + 1;
    
32.             src = (char *)src + 1;
    
33.     }
    
34.     return ret;
    
35. }
    
36. 
    
37. 
    
38. //这是我写的,按照最近流行的优化方式做的
    
39. void * memcpy_2 (void * dst, void * src , size_t n)
    
40. {
    
41.     void * ret = dst;
    
42.     size_t l = n>>2;
    
43.     while (l--) {
    
44.         *(size_t *)dst = *(size_t *)src;
    
45.         dst = (size_t *)dst + 1;
    
46.         src = (size_t *)src + 1;
    
47.     }
    
48.     l = n & 3;
    
49.     while (l--) {
    
50.         *(char *)dst = *(char *)src;
    
51.         dst = (char *)dst + 1;
    
52.         src = (char *)src + 1;
    
53.     }
    
54.     return ret;
    
55. }
    
56. 
    
57. void main(int argc, char ** argv)
    
58. {
    
59.     const int cstMemSize = 0x2FFFFFF;
    
60. 
    
61.     if(argc<2)
    
62.     {
    
63.         printf("请输入参数 [ 0 | 1 | 2 | 3] ");
    
64.         return ;
    
65.     }
    
66. 
    
67.     char * str  = (char*)malloc(cstMemSize);
    
68.     char * str2 = (char*)malloc(cstMemSize+16);
    
69. 
    
70.     size_t t1 = get_time_ms();
    
71. 
    
72.     switch(argv[1][0])
    
73.     {
    
74.         case '0': memcpy(str, str2, cstMemSize );
    
75.             break;
    
76.         case '1': memcpy_1(str, str2, cstMemSize );
    
77.             break;
    
78.         case '2': memcpy_2(str, str2, cstMemSize );
    
79.             break;
    
80.         case '3': memcpy_2(str, str2+1, cstMemSize );  //考虑字节不对齐的情况
    
81.             break;
    
82.     }
    
83.    
    
84.    
    
85.     double t2 = get_time_ms();
    
86.     free(str);
    
87.     free(str2);
    
88.     printf("memset_%c %f\n", argv[1][0] ,t2-t1);
    
89. 
    
90. }
    

复制代码

在windows xp/vc6环境下:

结果发现memcpy_1是最慢的,当然,这是串操作,当然很慢;
但是直接调用memcpy函数是最快的,这大概是微软在vc链接程序时做的优化.
而上面memcpy_2的效果一般般,比memcpy_1快,但是不如直接调用memcpy快.


在gcc/freebsd环境下,如果未加优化参数-O2,case '3'的情况速度更慢.我怀疑可能是字节不对齐带来的恶果.
不过,当开启了-O2后,4个case的测试时间差不多了.但是还是gcc自己的memset函数最快.

我现在怀疑,象(int *)这样的奇技淫巧如果使用不当,带来的效果不明显,还不如不用.现实情况是复杂的,编译器比我考虑的多的多.

bleem1998

一般memcpy都是用废编写的呢
你怎么可能快得过它

dulao5

估计是人家使用了更优化的指令.

gvim

呵呵，下面的代码，UV管道都计算的异常精确，通过判断是否支持sse等高级操作来加快效率。
当然效率极高。
补充一句：这是来自微软的代码，一个朋友给我的，似乎是VS 2007里面的。

1. 
   
2.        page    ,132
   
3.         title   memcpy - Copy source memory bytes to destination
   
4. ;***
   
5. ;memcpy.asm - contains memcpy and memmove routines
   
6. ;
   
7. ;       Copyright (c) Microsoft Corporation. All rights reserved.
   
8. ;
   
9. ;Purpose:
   
10. ;       memcpy() copies a source memory buffer to a destination buffer.
    
11. ;       Overlapping buffers are not treated specially, so propogation may occur.
    
12. ;       memmove() copies a source memory buffer to a destination buffer.
    
13. ;       Overlapping buffers are treated specially, to avoid propogation.
    
14. ;
    
15. ;*******************************************************************************
    
16. 
    
17.         .xlist
    
18.         include cruntime.inc
    
19.         .list
    
20. 
    
21. M_EXIT  macro
    
22.         ret                     ; _cdecl return
    
23.         endm    ; M_EXIT
    
24. 
    
25.         CODESEG
    
26.     extrn   _VEC_memcpy:near
    
27.     extrn   __sse2_available:dword
    
28. 
    
29. page
    
30. ;***
    
31. ;memcpy - Copy source buffer to destination buffer
    
32. ;
    
33. ;Purpose:
    
34. ;       memcpy() copies a source memory buffer to a destination memory buffer.
    
35. ;       This routine does NOT recognize overlapping buffers, and thus can lead
    
36. ;       to propogation.
    
37. ;       For cases where propogation must be avoided, memmove() must be used.
    
38. ;
    
39. ;       Algorithm:
    
40. ;
    
41. ;           Same as memmove. See Below
    
42. ;
    
43. ;
    
44. ;memmove - Copy source buffer to destination buffer
    
45. ;
    
46. ;Purpose:
    
47. ;       memmove() copies a source memory buffer to a destination memory buffer.
    
48. ;       This routine recognize overlapping buffers to avoid propogation.
    
49. ;       For cases where propogation is not a problem, memcpy() can be used.
    
50. ;
    
51. ;   Algorithm:
    
52. ;
    
53. ;       void * memmove(void * dst, void * src, size_t count)
    
54. ;       {
    
55. ;               void * ret = dst;
    
56. ;
    
57. ;               if (dst <= src || dst >= (src + count)) {
    
58. ;                       /*
    
59. ;                        * Non-Overlapping Buffers
    
60. ;                        * copy from lower addresses to higher addresses
    
61. ;                        */
    
62. ;                       while (count--)
    
63. ;                               *dst++ = *src++;
    
64. ;                       }
    
65. ;               else {
    
66. ;                       /*
    
67. ;                        * Overlapping Buffers
    
68. ;                        * copy from higher addresses to lower addresses
    
69. ;                        */
    
70. ;                       dst += count - 1;
    
71. ;                       src += count - 1;
    
72. ;
    
73. ;                       while (count--)
    
74. ;                               *dst-- = *src--;
    
75. ;                       }
    
76. ;
    
77. ;               return(ret);
    
78. ;       }
    
79. ;
    
80. ;
    
81. ;Entry:
    
82. ;       void *dst = pointer to destination buffer
    
83. ;       const void *src = pointer to source buffer
    
84. ;       size_t count = number of bytes to copy
    
85. ;
    
86. ;Exit:
    
87. ;       Returns a pointer to the destination buffer in AX/DX:AX
    
88. ;
    
89. ;Uses:
    
90. ;       CX, DX
    
91. ;
    
92. ;Exceptions:
    
93. ;*******************************************************************************
    

复制代码

后续

[ 本帖最后由 gvim 于 2006-12-28 18:34 编辑 ]

gvim

接上

1. 
   
2. ifdef MEM_MOVE
   
3.         _MEM_     equ <memmove>
   
4. else  ; MEM_MOVE
   
5.         _MEM_     equ <memcpy>
   
6. endif  ; MEM_MOVE
   
7. 
   
8. %       public  _MEM_
   
9. _MEM_   proc \
   
10.         dst:ptr byte, \
    
11.         src:ptr byte, \
    
12.         count:IWORD
    
13. 
    
14.               ; destination pointer
    
15.               ; source pointer
    
16.               ; number of bytes to copy
    
17. 
    
18. ;       push    ebp             ;U - save old frame pointer
    
19. ;       mov     ebp, esp        ;V - set new frame pointer
    
20. 
    
21.         push    edi             ;U - save edi
    
22.         push    esi             ;V - save esi
    
23. 
    
24.         mov     esi,[src]       ;U - esi = source
    
25.         mov     ecx,[count]     ;V - ecx = number of bytes to move
    
26. 
    
27.         mov     edi,[dst]       ;U - edi = dest
    
28. 
    
29. ;
    
30. ; Check for overlapping buffers:
    
31. ;       If (dst <= src) Or (dst >= src + Count) Then
    
32. ;               Do normal (Upwards) Copy
    
33. ;       Else
    
34. ;               Do Downwards Copy to avoid propagation
    
35. ;
    
36. 
    
37.         mov     eax,ecx         ;V - eax = byte count...
    
38. 
    
39.         mov     edx,ecx         ;U - edx = byte count...
    
40.         add     eax,esi         ;V - eax = point past source end
    
41. 
    
42.         cmp     edi,esi         ;U - dst <= src ?
    
43.         jbe     short CopyUp    ;V - yes, copy toward higher addresses
    
44. 
    
45.         cmp     edi,eax         ;U - dst < (src + count) ?
    
46.         jb      CopyDown        ;V - yes, copy toward lower addresses
    
47. 
    
48. ;
    
49. ; Copy toward higher addresses.
    
50. ;
    
51. CopyUp:
    
52. ;
    
53. ; First, see if we can use a "fast" copy SSE2 routine
    
54.         ; block size greater than min threshold?
    
55.         cmp     ecx,0100h
    
56.         jb      Dword_align
    
57.         ; SSE2 supported?
    
58.         cmp     DWORD PTR __sse2_available,0
    
59.         je      Dword_align
    
60.         ; alignments equal?
    
61.         push    edi
    
62.         push    esi
    
63.         and     edi,15
    
64.         and     esi,15
    
65.         cmp     edi,esi
    
66.         pop     esi
    
67.         pop     edi
    
68.         jne     Dword_align
    
69. 
    
70.         ; do fast SSE2 copy, params already on stack
    
71.         pop     esi
    
72.         pop     edi
    
73.         pop     ebp
    
74.         jmp     _VEC_memcpy
    
75.         ; no return
    
76. ;
    
77. ; The algorithm for forward moves is to align the destination to a dword
    
78. ; boundary and so we can move dwords with an aligned destination.  This
    
79. ; occurs in 3 steps.
    
80. ;
    
81. ;   - move x = ((4 - Dest & 3) & 3) bytes
    
82. ;   - move y = ((L-x) >> 2) dwords
    
83. ;   - move (L - x - y*4) bytes
    
84. ;
    
85. 
    
86. Dword_align:
    
87.         test    edi,11b         ;U - destination dword aligned?
    
88.         jnz     short CopyLeadUp ;V - if we are not dword aligned already, align
    
89. 
    
90.         shr     ecx,2           ;U - shift down to dword count
    
91.         and     edx,11b         ;V - trailing byte count
    
92. 
    
93.         cmp     ecx,8           ;U - test if small enough for unwind copy
    
94.         jb      short CopyUnwindUp ;V - if so, then jump
    
95. 
    
96.         rep     movsd           ;N - move all of our dwords
    
97. 
    
98.         jmp     dword ptr TrailUpVec[edx*4] ;N - process trailing bytes
    
99. 
    
100. ;
     
101. ; Code to do optimal memory copies for non-dword-aligned destinations.
     
102. ;
     
103. 
     
104. ; The following length check is done for two reasons:
     
105. ;
     
106. ;    1. to ensure that the actual move length is greater than any possiale
     
107. ;       alignment move, and
     
108. ;
     
109. ;    2. to skip the multiple move logic for small moves where it would
     
110. ;       be faster to move the bytes with one instruction.
     
111. ;
     
112. 
     
113.         align   @WordSize
     
114. CopyLeadUp:
     
115. 
     
116.         mov     eax,edi         ;U - get destination offset
     
117.         mov     edx,11b         ;V - prepare for mask
     
118. 
     
119.         sub     ecx,4           ;U - check for really short string - sub for adjust
     
120.         jb      short ByteCopyUp ;V - branch to just copy bytes
     
121. 
     
122.         and     eax,11b         ;U - get offset within first dword
     
123.         add     ecx,eax         ;V - update size after leading bytes copied
     
124. 
     
125.         jmp     dword ptr LeadUpVec[eax*4-4] ;N - process leading bytes
     
126. 
     
127.         align   @WordSize
     
128. ByteCopyUp:
     
129.         jmp     dword ptr TrailUpVec[ecx*4+16] ;N - process just bytes
     
130. 
     
131.         align   @WordSize
     
132. CopyUnwindUp:
     
133.         jmp     dword ptr UnwindUpVec[ecx*4] ;N - unwind dword copy
     
134. 
     
135.         align   @WordSize
     
136. LeadUpVec       dd      LeadUp1, LeadUp2, LeadUp3
     
137. 
     
138.         align   @WordSize
     
139. LeadUp1:
     
140.         and     edx,ecx         ;U - trailing byte count
     
141.         mov     al,[esi]        ;V - get first byte from source
     
142. 
     
143.         mov     [edi],al        ;U - write second byte to destination
     
144.         mov     al,[esi+1]      ;V - get second byte from source
     
145. 
     
146.         mov     [edi+1],al      ;U - write second byte to destination
     
147.         mov     al,[esi+2]      ;V - get third byte from source
     
148. 
     
149.         shr     ecx,2           ;U - shift down to dword count
     
150.         mov     [edi+2],al      ;V - write third byte to destination
     
151. 
     
152.         add     esi,3           ;U - advance source pointer
     
153.         add     edi,3           ;V - advance destination pointer
     
154. 
     
155.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
156.         jb      short CopyUnwindUp ;V - if so, then jump
     
157. 
     
158.         rep     movsd           ;N - move all of our dwords
     
159. 
     
160.         jmp     dword ptr TrailUpVec[edx*4] ;N - process trailing bytes
     
161. 
     
162.         align   @WordSize
     
163. LeadUp2:
     
164.         and     edx,ecx         ;U - trailing byte count
     
165.         mov     al,[esi]        ;V - get first byte from source
     
166. 
     
167.         mov     [edi],al        ;U - write second byte to destination
     
168.         mov     al,[esi+1]      ;V - get second byte from source
     
169. 
     
170.         shr     ecx,2           ;U - shift down to dword count
     
171.         mov     [edi+1],al      ;V - write second byte to destination
     
172. 
     
173.         add     esi,2           ;U - advance source pointer
     
174.         add     edi,2           ;V - advance destination pointer
     
175. 
     
176.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
177.         jb      short CopyUnwindUp ;V - if so, then jump
     
178. 
     
179.         rep     movsd           ;N - move all of our dwords
     
180. 
     
181.         jmp     dword ptr TrailUpVec[edx*4] ;N - process trailing bytes
     
182. 
     
183.         align   @WordSize
     
184. LeadUp3:
     
185.         and     edx,ecx         ;U - trailing byte count
     
186.         mov     al,[esi]        ;V - get first byte from source
     
187. 
     
188.         mov     [edi],al        ;U - write second byte to destination
     
189.         add     esi,1           ;V - advance source pointer
     
190. 
     
191.         shr     ecx,2           ;U - shift down to dword count
     
192.         add     edi,1           ;V - advance destination pointer
     
193. 
     
194.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
195.         jb      short CopyUnwindUp ;V - if so, then jump
     
196. 
     
197.         rep     movsd           ;N - move all of our dwords
     
198. 
     
199.         jmp     dword ptr TrailUpVec[edx*4] ;N - process trailing bytes
     
200. 
     
201.         align   @WordSize
     
202. UnwindUpVec     dd      UnwindUp0, UnwindUp1, UnwindUp2, UnwindUp3
     
203.                 dd      UnwindUp4, UnwindUp5, UnwindUp6, UnwindUp7
     
204. 
     
205. UnwindUp7:
     
206.         mov     eax,[esi+ecx*4-28] ;U - get dword from source
     
207.                                    ;V - spare
     
208.         mov     [edi+ecx*4-28],eax ;U - put dword into destination
     
209. UnwindUp6:
     
210.         mov     eax,[esi+ecx*4-24] ;U(entry)/V(not) - get dword from source
     
211.                                    ;V(entry) - spare
     
212.         mov     [edi+ecx*4-24],eax ;U - put dword into destination
     
213. UnwindUp5:
     
214.         mov     eax,[esi+ecx*4-20] ;U(entry)/V(not) - get dword from source
     
215.                                    ;V(entry) - spare
     
216.         mov     [edi+ecx*4-20],eax ;U - put dword into destination
     
217. UnwindUp4:
     
218.         mov     eax,[esi+ecx*4-16] ;U(entry)/V(not) - get dword from source
     
219.                                    ;V(entry) - spare
     
220.         mov     [edi+ecx*4-16],eax ;U - put dword into destination
     
221. UnwindUp3:
     
222.         mov     eax,[esi+ecx*4-12] ;U(entry)/V(not) - get dword from source
     
223.                                    ;V(entry) - spare
     
224.         mov     [edi+ecx*4-12],eax ;U - put dword into destination
     
225. UnwindUp2:
     
226.         mov     eax,[esi+ecx*4-8] ;U(entry)/V(not) - get dword from source
     
227.                                   ;V(entry) - spare
     
228.         mov     [edi+ecx*4-8],eax ;U - put dword into destination
     
229. UnwindUp1:
     
230.         mov     eax,[esi+ecx*4-4] ;U(entry)/V(not) - get dword from source
     
231.                                   ;V(entry) - spare
     
232.         mov     [edi+ecx*4-4],eax ;U - put dword into destination
     
233. 
     
234.         lea     eax,[ecx*4]     ;V - compute update for pointer
     
235. 
     
236.         add     esi,eax         ;U - update source pointer
     
237.         add     edi,eax         ;V - update destination pointer
     
238. UnwindUp0:
     
239.         jmp     dword ptr TrailUpVec[edx*4] ;N - process trailing bytes
     
240. 
     
241. ;-----------------------------------------------------------------------------
     
242. 
     
243.         align   @WordSize
     
244. TrailUpVec      dd      TrailUp0, TrailUp1, TrailUp2, TrailUp3
     
245. 
     
246.         align   @WordSize
     
247. TrailUp0:
     
248.         mov     eax,[dst]       ;U - return pointer to destination
     
249.         pop     esi             ;V - restore esi
     
250.         pop     edi             ;U - restore edi
     
251.                                 ;V - spare
     
252.         M_EXIT
     
253. 
     
254.         align   @WordSize
     
255. TrailUp1:
     
256.         mov     al,[esi]        ;U - get byte from source
     
257.                                 ;V - spare
     
258.         mov     [edi],al        ;U - put byte in destination
     
259.         mov     eax,[dst]       ;V - return pointer to destination
     
260.         pop     esi             ;U - restore esi
     
261.         pop     edi             ;V - restore edi
     
262.         M_EXIT
     
263. 
     
264.         align   @WordSize
     
265. TrailUp2:
     
266.         mov     al,[esi]        ;U - get first byte from source
     
267.                                 ;V - spare
     
268.         mov     [edi],al        ;U - put first byte into destination
     
269.         mov     al,[esi+1]      ;V - get second byte from source
     
270.         mov     [edi+1],al      ;U - put second byte into destination
     
271.         mov     eax,[dst]       ;V - return pointer to destination
     
272.         pop     esi             ;U - restore esi
     
273.         pop     edi             ;V - restore edi
     
274.         M_EXIT
     
275. 
     
276.         align   @WordSize
     
277. TrailUp3:
     
278.         mov     al,[esi]        ;U - get first byte from source
     
279.                                 ;V - spare
     
280.         mov     [edi],al        ;U - put first byte into destination
     
281.         mov     al,[esi+1]      ;V - get second byte from source
     
282.         mov     [edi+1],al      ;U - put second byte into destination
     
283.         mov     al,[esi+2]      ;V - get third byte from source
     
284.         mov     [edi+2],al      ;U - put third byte into destination
     
285.         mov     eax,[dst]       ;V - return pointer to destination
     
286.         pop     esi             ;U - restore esi
     
287.         pop     edi             ;V - restore edi
     
288.         M_EXIT
     
289. 
     
290. ;-----------------------------------------------------------------------------
     
291. ;-----------------------------------------------------------------------------
     
292. ;-----------------------------------------------------------------------------
     
293. 
     
294. ;
     
295. ; Copy down to avoid propogation in overlapping buffers.
     
296. ;
     
297.         align   @WordSize
     
298. CopyDown:
     
299.         lea     esi,[esi+ecx-4] ;U - point to 4 bytes before src buffer end
     
300.         lea     edi,[edi+ecx-4] ;V - point to 4 bytes before dest buffer end
     
301. ;
     
302. ; See if the destination start is dword aligned
     
303. ;
     
304. 
     
305.         test    edi,11b         ;U - test if dword aligned
     
306.         jnz     short CopyLeadDown ;V - if not, jump
     
307. 
     
308.         shr     ecx,2           ;U - shift down to dword count
     
309.         and     edx,11b         ;V - trailing byte count
     
310. 
     
311.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
312.         jb      short CopyUnwindDown ;V - if so, then jump
     
313. 
     
314.         std                     ;N - set direction flag
     
315.         rep     movsd           ;N - move all of our dwords
     
316.         cld                     ;N - clear direction flag back
     
317. 
     
318.         jmp     dword ptr TrailDownVec[edx*4] ;N - process trailing bytes
     
319. 
     
320.         align   @WordSize
     
321. CopyUnwindDown:
     
322.         neg     ecx             ;U - negate dword count for table merging
     
323.                                 ;V - spare
     
324. 
     
325.         jmp     dword ptr UnwindDownVec[ecx*4+28] ;N - unwind copy
     
326. 
     
327.         align   @WordSize
     
328. CopyLeadDown:
     
329. 
     
330.         mov     eax,edi         ;U - get destination offset
     
331.         mov     edx,11b         ;V - prepare for mask
     
332. 
     
333.         cmp     ecx,4           ;U - check for really short string
     
334.         jb      short ByteCopyDown ;V - branch to just copy bytes
     
335. 
     
336.         and     eax,11b         ;U - get offset within first dword
     
337.         sub     ecx,eax         ;U - to update size after lead copied
     
338. 
     
339.         jmp     dword ptr LeadDownVec[eax*4-4] ;N - process leading bytes
     
340. 
     
341.         align   @WordSize
     
342. ByteCopyDown:
     
343.         jmp     dword ptr TrailDownVec[ecx*4] ;N - process just bytes
     
344. 
     
345.         align   @WordSize
     
346. LeadDownVec     dd      LeadDown1, LeadDown2, LeadDown3
     
347. 
     
348.         align   @WordSize
     
349. LeadDown1:
     
350.         mov     al,[esi+3]      ;U - load first byte
     
351.         and     edx,ecx         ;V - trailing byte count
     
352. 
     
353.         mov     [edi+3],al      ;U - write out first byte
     
354.         sub     esi,1           ;V - point to last src dword
     
355. 
     
356.         shr     ecx,2           ;U - shift down to dword count
     
357.         sub     edi,1           ;V - point to last dest dword
     
358. 
     
359.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
360.         jb      short CopyUnwindDown ;V - if so, then jump
     
361. 
     
362.         std                     ;N - set direction flag
     
363.         rep     movsd           ;N - move all of our dwords
     
364.         cld                     ;N - clear direction flag
     
365. 
     
366.         jmp     dword ptr TrailDownVec[edx*4] ;N - process trailing bytes
     
367. 
     
368.         align   @WordSize
     
369. LeadDown2:
     
370.         mov     al,[esi+3]      ;U - load first byte
     
371.         and     edx,ecx         ;V - trailing byte count
     
372. 
     
373.         mov     [edi+3],al      ;U - write out first byte
     
374.         mov     al,[esi+2]      ;V - get second byte from source
     
375. 
     
376.         shr     ecx,2           ;U - shift down to dword count
     
377.         mov     [edi+2],al      ;V - write second byte to destination
     
378. 
     
379.         sub     esi,2           ;U - point to last src dword
     
380.         sub     edi,2           ;V - point to last dest dword
     
381. 
     
382.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
383.         jb      short CopyUnwindDown ;V - if so, then jump
     
384. 
     
385.         std                     ;N - set direction flag
     
386.         rep     movsd           ;N - move all of our dwords
     
387.         cld                     ;N - clear direction flag
     
388. 
     
389.         jmp     dword ptr TrailDownVec[edx*4] ;N - process trailing bytes
     
390. 
     
391.         align   @WordSize
     
392. LeadDown3:
     
393.         mov     al,[esi+3]      ;U - load first byte
     
394.         and     edx,ecx         ;V - trailing byte count
     
395. 
     
396.         mov     [edi+3],al      ;U - write out first byte
     
397.         mov     al,[esi+2]      ;V - get second byte from source
     
398. 
     
399.         mov     [edi+2],al      ;U - write second byte to destination
     
400.         mov     al,[esi+1]      ;V - get third byte from source
     
401. 
     
402.         shr     ecx,2           ;U - shift down to dword count
     
403.         mov     [edi+1],al      ;V - write third byte to destination
     
404. 
     
405.         sub     esi,3           ;U - point to last src dword
     
406.         sub     edi,3           ;V - point to last dest dword
     
407. 
     
408.         cmp     ecx,8           ;U - test if small enough for unwind copy
     
409.         jb      CopyUnwindDown  ;V - if so, then jump
     
410. 
     
411.         std                     ;N - set direction flag
     
412.         rep     movsd           ;N - move all of our dwords
     
413.         cld                     ;N - clear direction flag
     
414. 
     
415.         jmp     dword ptr TrailDownVec[edx*4] ;N - process trailing bytes
     
416. 
     
417. ;------------------------------------------------------------------
     
418. 
     
419.         align   @WordSize
     
420. UnwindDownVec   dd      UnwindDown7, UnwindDown6, UnwindDown5, UnwindDown4
     
421.                 dd      UnwindDown3, UnwindDown2, UnwindDown1, UnwindDown0
     
422. 
     
423. UnwindDown7:
     
424.         mov     eax,[esi+ecx*4+28] ;U - get dword from source
     
425.                                    ;V - spare
     
426.         mov     [edi+ecx*4+28],eax ;U - put dword into destination
     
427. UnwindDown6:
     
428.         mov     eax,[esi+ecx*4+24] ;U(entry)/V(not) - get dword from source
     
429.                                    ;V(entry) - spare
     
430.         mov     [edi+ecx*4+24],eax ;U - put dword into destination
     
431. UnwindDown5:
     
432.         mov     eax,[esi+ecx*4+20] ;U(entry)/V(not) - get dword from source
     
433.                                    ;V(entry) - spare
     
434.         mov     [edi+ecx*4+20],eax ;U - put dword into destination
     
435. UnwindDown4:
     
436.         mov     eax,[esi+ecx*4+16] ;U(entry)/V(not) - get dword from source
     
437.                                    ;V(entry) - spare
     
438.         mov     [edi+ecx*4+16],eax ;U - put dword into destination
     
439. UnwindDown3:
     
440.         mov     eax,[esi+ecx*4+12] ;U(entry)/V(not) - get dword from source
     
441.                                    ;V(entry) - spare
     
442.         mov     [edi+ecx*4+12],eax ;U - put dword into destination
     
443. UnwindDown2:
     
444.         mov     eax,[esi+ecx*4+8] ;U(entry)/V(not) - get dword from source
     
445.                                    ;V(entry) - spare
     
446.         mov     [edi+ecx*4+8],eax ;U - put dword into destination
     
447. UnwindDown1:
     
448.         mov     eax,[esi+ecx*4+4] ;U(entry)/V(not) - get dword from source
     
449.                                   ;V(entry) - spare
     
450.         mov     [edi+ecx*4+4],eax ;U - put dword into destination
     
451. 
     
452.         lea     eax,[ecx*4]     ;V - compute update for pointer
     
453. 
     
454.         add     esi,eax         ;U - update source pointer
     
455.         add     edi,eax         ;V - update destination pointer
     
456. UnwindDown0:
     
457.         jmp     dword ptr TrailDownVec[edx*4] ;N - process trailing bytes
     
458. 
     
459. ;-----------------------------------------------------------------------------
     
460. 
     
461.         align   @WordSize
     
462. TrailDownVec    dd      TrailDown0, TrailDown1, TrailDown2, TrailDown3
     
463. 
     
464.         align   @WordSize
     
465. TrailDown0:
     
466.         mov     eax,[dst]       ;U - return pointer to destination
     
467.                                 ;V - spare
     
468.         pop     esi             ;U - restore esi
     
469.         pop     edi             ;V - restore edi
     
470.         M_EXIT
     
471. 
     
472.         align   @WordSize
     
473. TrailDown1:
     
474.         mov     al,[esi+3]      ;U - get byte from source
     
475.                                 ;V - spare
     
476.         mov     [edi+3],al      ;U - put byte in destination
     
477.         mov     eax,[dst]       ;V - return pointer to destination
     
478.         pop     esi             ;U - restore esi
     
479.         pop     edi             ;V - restore edi
     
480.         M_EXIT
     
481. 
     
482.         align   @WordSize
     
483. TrailDown2:
     
484.         mov     al,[esi+3]      ;U - get first byte from source
     
485.                                 ;V - spare
     
486.         mov     [edi+3],al      ;U - put first byte into destination
     
487.         mov     al,[esi+2]      ;V - get second byte from source
     
488.         mov     [edi+2],al      ;U - put second byte into destination
     
489.         mov     eax,[dst]       ;V - return pointer to destination
     
490.         pop     esi             ;U - restore esi
     
491.         pop     edi             ;V - restore edi
     
492.         M_EXIT
     
493. 
     
494.         align   @WordSize
     
495. TrailDown3:
     
496.         mov     al,[esi+3]      ;U - get first byte from source
     
497.                                 ;V - spare
     
498.         mov     [edi+3],al      ;U - put first byte into destination
     
499.         mov     al,[esi+2]      ;V - get second byte from source
     
500.         mov     [edi+2],al      ;U - put second byte into destination
     
501.         mov     al,[esi+1]      ;V - get third byte from source
     
502.         mov     [edi+1],al      ;U - put third byte into destination
     
503.         mov     eax,[dst]       ;V - return pointer to destination
     
504.         pop     esi             ;U - restore esi
     
505.         pop     edi             ;V - restore edi
     
506.         M_EXIT
     
507. 
     
508. _MEM_   endp
     
509.         end
     

复制代码

langue

1. /*      $NetBSD: bcopy.c,v 1.6 1997/07/13 20:24:12 christos Exp $       */
   
2. ...
   
3. /*
   
4. * Copy a block of memory, handling overlap.
   
5. * This is the routine that actually implements
   
6. * (the portable versions of) bcopy, memcpy, and memmove.
   
7. */
   
8. #ifdef MEMCOPY
   
9. void *
   
10. memcpy(dst0, src0, length)
    
11. #else
    
12. #ifdef MEMMOVE
    
13. void *
    
14. memmove(dst0, src0, length)
    
15. #else
    
16. void
    
17. bcopy(src0, dst0, length)
    
18. #endif
    
19. #endif
    
20.         void *dst0;
    
21.         const void *src0;
    
22.         register size_t length;
    
23. {
    
24.         register char *dst = dst0;
    
25.         register const char *src = src0;
    
26.         register size_t t;
    
27. 
    
28.         if (length == 0 || dst == src)          /* nothing to do */
    
29.                 goto done;
    
30. 
    
31.         /*
    
32.          * Macros: loop-t-times; and loop-t-times, t>0
    
33.          */
    
34. #define TLOOP(s) if (t) TLOOP1(s)
    
35. #define TLOOP1(s) do { s; } while (--t)
    
36. 
    
37.         if ((unsigned long)dst < (unsigned long)src) {
    
38.                 /*
    
39.                  * Copy forward.
    
40.                  */
    
41.                 t = (long)src;  /* only need low bits */
    
42.                 if ((t | (long)dst) & wmask) {
    
43.                         /*
    
44.                          * Try to align operands.  This cannot be done
    
45.                          * unless the low bits match.
    
46.                          */
    
47.                         if ((t ^ (long)dst) & wmask || length < wsize)
    
48.                                 t = length;
    
49.                         else
    
50.                                 t = wsize - (t & wmask);
    
51.                         length -= t;
    
52.                         TLOOP1(*dst++ = *src++);
    
53.                 }
    
54.                 /*
    
55.                  * Copy whole words, then mop up any trailing bytes.
    
56.                  */
    
57.                 t = length / wsize;
    
58.                 TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
    
59.                 t = length & wmask;
    
60.                 TLOOP(*dst++ = *src++);
    
61.         } else {
    
62.                 /*
    
63.                  * Copy backwards.  Otherwise essentially the same.
    
64.                  * Alignment works as before, except that it takes
    
65.                  * (t&wmask) bytes to align, not wsize-(t&wmask).
    
66.                  */
    
67.                 src += length;
    
68.                 dst += length;
    
69.                 t = (long)src;
    
70.                 if ((t | (long)dst) & wmask) {
    
71.                         if ((t ^ (long)dst) & wmask || length <= wsize)
    
72.                                 t = length;
    
73.                         else
    
74.                                 t &= wmask;
    
75.                         length -= t;
    
76.                         TLOOP1(*--dst = *--src);
    
77.                 }
    
78.                 t = length / wsize;
    
79.                 TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
    
80.                 t = length & wmask;
    
81.                 TLOOP(*--dst = *--src);
    
82.         }
    
83. done:
    
84. #if defined(MEMCOPY) || defined(MEMMOVE)
    
85.         return (dst0);
    
86. #else
    
87.         return;
    
88. #endif

复制代码

gvim

原帖由 langue 于 2006-12-28 18:32 发表
[code]/*      $NetBSD: bcopy.c,v 1.6 1997/07/13 20:24:12 christos Exp $       */
...
/*
* Copy a block of memory, handling overlap.
* This is the routine that actually implements
* (the por ...

NetBSD的代码注重跨平台，首先需要在他所支持的平台上都能编译，其次才是效率。
MS的代码注重效率，只需要在i386上，自然可以强力优化，比如优化UV流水线、借助SSE指令等，移植性为0
两种设计，很有意思。

gvim

http://blog.codingnow.com/2005/10/vc_memcpy.html

mik

这个算法用C写，不知编译器会怎样生成代码，倒不如直接用汇编
不考虑其它条件的话：
#define do_mem_copy(dest, src, size)                        \
        __asm__ __volatile__ ("movl %0, %%edi; movl %1, %%esi;                \
                movl %2, %%ecx; movl %%ecx, %%eax;        \
                shr $2, %%ecx; rep movsl;                \
                movl %%eax, %%ecx; andl $3, %%ecx;        \
                rep movsb"                                \
                :                                        \
                : "r" (dest), "r" (src), "r" (size)        \
        );


再看看 sun 在 Solaris 的实现：

        ENTRY(memcpy)
        movl        %edi,%edx        / save register variables
        pushl        %esi
        movl        8(%esp),%edi        / %edi = dest address
        movl        12(%esp),%esi        / %esi = source address
        movl        16(%esp),%ecx        / %ecx = length of string
        movl        %edi,%eax        / return value from the call

        shrl        $2,%ecx                / %ecx = number of words to move
        rep ; smovl                / move the words

        movl        16(%esp),%ecx        / %ecx = number of bytes to move
        andl        $0x3,%ecx        / %ecx = number of bytes left to move
        rep ; smovb                / move the bytes

        popl        %esi                / restore register variables
        movl        %edx,%edi
        ret
        SET_SIZE(memcpy)

nully

原帖由 gvim 于 2006-12-28 18:37 发表


NetBSD的代码注重跨平台，首先需要在他所支持的平台上都能编译，其次才是效率。
MS的代码注重效率，只需要在i386上，自然可以强力优化，比如优化UV流水线、借助SSE指令等，移植性为0
两种设计，很有意思。

确实是有趣的问题。

不过NetBSD也可以这么做，首先调查在哪些平台上用得比较多，然后针对这些平台上：
#ifdef _I686_
...
使用UV流水线
#ifdef _MMX_
使用mmx...
#ifdef _SSE_
使用sse...
...

不过代码就太不美观了。。。不可取，呵呵