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

思一克

INTEL 上的REPZ MOVSB
快。memcpy等就可能优化成了这些。
用C写的慢。4个字节一起做也快不了多少

dulao5

嗯,看起来的确是这样, MOVSB指令就是为了移动串而生的,用它的确应该快.

mik

原帖由 星尘细雨 于 2006-12-29 10:18 发表
使用了mmx/sse/sse2的汇编来写memcpy肯定是更快的，
就是在非x86的CPU移植麻烦，
还有我记得性能还和cpu有关，
Intel的cpu在执行sse2指令比amd的cpu的sse2指令快。

既然提到 MMX 指令，就贴一段使用MMX指令copy内存块的代码：

1. // block copy: copy a number of DWORDs from DWORD aligned source
   
2. // to DWORD aligned destination using cacheable stores.
   
3. __asm {
   
4.     MOV ESI, [src_ptr]             ;pointer to src, DWORD aligned
   
5.     MOV EDI, [dst_ptr]             ;pointer to dst, DWORD aligned
   
6.     MOV ECX, [blk_size]             ;number of DWORDs to copy
   
7.     PREFETCH (ESI)                     ;PREFetch first src cache line
   
8.     CMP ECX, 1                     ;less than one DWORD to copy ?
   
9.     JB $copydone2_cc             ;yes, must be no DWORDs to copy, done
   
10.     TEST EDI, 7                     ;dst QWORD aligned?
    
11.     JZ $dstqaligned2_cc             ;yes
    
12.     MOVD MM0, [ESI]                     ;read one DWORD from src
    
13.     MOVD [EDI], MM0             ;store one DWORD to dst
    
14.     ADD ESI, 4                    ;src++
    
15.     ADD EDI, 4                    ;dst++
    
16.     DEC ECX                     ;number of DWORDs to copy
    
17. 
    
18. $dstqaligned2_cc:
    
19.     MOV EBX, ECX                     ;number of DWORDs to copy
    
20.     SHR ECX, 4                     ;number of cache lines to copy
    
21.     JZ $copyqwords2_cc             ;no whole cache lines to copy, maybe QWORDs
    
22.     PREFetchm (ESI,64)             ;PREFetch src cache line one ahead
    
23.     PREFetchmlong (ESI,128)     ;PREFetch src cache line two ahead
    
24. 
    
25.     ALIGN 16                     ;align loop for optimal performance
    
26. 
    
27. $cloop2_cc:
    
28.     PREFetchmlong (ESI, 192)    ;prefetch cache line three ahead
    
29.     MOVQ MM0, [ESI]             ;load first QWORD in cache line from src
    
30.     ADD EDI, 64                     ;src++
    
31.     MOVQ MM1, [ESI+8]             ;load second QWORD in cache line from src
    
32.     ADD ESI, 64                     ;dst++
    
33.     MOVQ MM2, [ESI-48]             ;load third QWORD in cache line from src
    
34.     MOVQ [EDI-64], MM0             ;store first DWORD in cache line to dst
    
35.     MOVQ MM0, [ESI-40]             ;load fourth QWORD in cache line from src
    
36.     MOVQ [EDI-56], MM1             ;store second DWORD in cache line to dst
    
37.     MOVQ MM1, [ESI-32]             ;load fifth QWORD in cache line from src
    
38.     MOVQ [EDI-48], MM2             ;store third DWORD in cache line to dst
    
39.     MOVQ MM2, [ESI-24]             ;load sixth QWORD in cache line from src
    
40.     MOVQ [EDI-40], MM0             ;store fourth DWORD in cache line to dst
    
41.     MOVQ MM0, [ESI-16]             ;load seventh QWORD in cache line from src
    
42.     MOVQ [EDI-32], MM1             ;store fifth DWORD in cache line to dst
    
43.     MOVQ MM1, [ESI-8]             ;load eight QWORD in cache line from src
    
44.     MOVQ [EDI-24], MM2             ;store sixth DWORD in cache line to dst
    
45.     MOVQ [EDI-16], MM0             ;store seventh DWORD in cache line to dst
    
46.     DEC ECX                     ;count--
    
47.     MOVQ [EDI-8], MM1             ;store eighth DWORD in cache line to dst
    
48.     JNZ $cloop2_cc                     ;until no more cache lines to copy
    
49. 
    
50. $copyqwords2_cc:
    
51.     MOV ECX, EBX                     ;number of DWORDs to copy
    
52.     AND EBX, 0xE                     ;number of QWORDS left to copy * 2
    
53.     JZ $copydword2_cc             ;no QWORDs left, maybe DWORD left
    
54. 
    
55.      ALIGN 16                   ;align loop for optimal performance
    
56. 
    
57. $qloop2_cc:
    
58.     MOVQ MM0, [ESI]             ;read QWORD from src
    
59.     MOVQ [EDI], MM0             ;store QWORD to dst
    
60.     ADD ESI, 8                     ;src++
    
61.     ADD EDI, 8                     ;dst++
    
62.     SUB EBX, 2                     ;count--
    
63.     JNZ $qloop2_cc                     ;until no more QWORDs left to copy
    
64. 
    
65. $copydword2_cc:
    
66.     TEST ECX, 1                     ;DWORD left to copy ?
    
67.     JZ $copydone2_cc             ;nope, we’re done
    
68.     MOVD MM0, [ESI]             ;read last DWORD from src
    
69.     MOVD [EDI], MM0             ;store last DWORD to dst
    
70. 
    
71. $copydone2_cc:
    
72.     FEMMS     ;clear MMX state
    
73. }

复制代码

当复制块大于 512 字节时,使用以上代码才有价值


另一个更强悍的手法是使用: 128 位的 xmm 指令

1. movdqa    xmm0,    [rdx+r8*8]         ; Load
   
2. movntdq   [rcx+r8*8], xmm0            ; Store
   
3. movdqa    xmm1, [rdx+r8*8+16]      ; Load
   
4. movntdq   [rcx+r8*8+16], xmm1      ; Store

复制代码

mingyanguo

这种效率很诡异，我认为这些优化中，真值得去做的，就是把byte复制转化成word复制，这是跨平台的方法，而且绝大多数时候都能获得大幅度的效率提升。有时候，asm未必就比C快。
我测试的结果是，哪怕是asm优化过的，在拷贝的大小不同时效率也是不同的，很难说哪个更好。
另外，ia32上的串操作指令未必快，而mmx/sse这些指令又不通用。
代码上的优化还是适可而止的好，过度优化的代码没有生命力。

cobras

不知使用汇编代码如何?
mov di,dest
mov si,src
mov cx,size
cld
rep movsd
不考虑重叠情况

obrire

以前有Intel提供了相关优化的讲义，其间是讲到了C有些地方的写法，有很大的讲究
至于WimmX优化指令等，还是做浮点，积分很牛的哟。内存拷贝对系统而言，是可
以优化的，优化可以针对块拷贝，如512对齐等，具体要看应用了，有些需要大块对
齐，有些是线性的，如果系统允许，地接内存重映射就可以了。具体实现，还与OS的
内存管理有关。

如需大块线性空间，但用户空间已经不可能申请太多时，这时内存管理算法比拷贝可
能更耗时间了。当然，最快也无非DMA，锁存，传输，解锁，且最后换算出来，一定
是线性最好。你想想，如果真要while什么的，一定会慢下来。以后计算机最好用硬
件设计典型的加速器，且有多个适应逻辑，支持4K/BYTE/4M等单位数据迁移。

如果你需要4MB，直接在最短的1个周期中映射过去，力争在10个周期内处理完数据
(POST)。

唉，这些应用与实际要求相结合最好。至于memcpy，一般而言，就用libc的就可以了。
要求同步数据或其它高级应用，当然直接是你管理内存最好。不是以后有高带内存与
NOR一样了吗？可读，可写，可保存，设计一块区域专用于内存拷贝，还可异步完成。
双核心，系统也这样设计，一定是很高效了。
SEND DATA -> EXT LOCK
SEND MSG  -> DATA READY ->READ EXT LOCK DATA->NEXT OP
NEXT OP

扯得太远了。