转自：http://www.aiuxian.com/article/p-1309055.html
偶尔看到一个说法，说，小内存的拷贝，使用等号直接赋值比memcpy快得多。结合自己搜集到的资料，整理成此文。
事实：strcpy等函数的逐字节拷贝，memcpy是按照机器字长逐字进行拷贝的，一个字等于4（32位机）或8（64位机）个字节。CPU存取一个字节和存取一个字一样，都是在一条指令、一个内存周期内完成的。显然，按字拷贝效率更高。
先给出一个程序：
08 |
char src[TESTSIZE] = {0}; |
10 |
*(struct node*)dst = *(struct node*)src; |
编译：gcc -g -o test test.c
获得汇编：objdump -S test
可以看到有这么一些汇编，对应的是等号赋值操作：
*(struct node*)dst = *(struct node*)src;
4004b6: 48 8d 85 00 ff ff ff lea 0xffffffffffffff00(%rbp),%rax
4004bd: 48 8d 55 80 lea 0xffffffffffffff80(%rbp),%rdx
4004c1: 48 8b 0a mov (%rdx),%rcx
4004c4: 48 89 08 mov %rcx,(%rax)
4004c7: 48 8b 4a 08 mov 0x8(%rdx),%rcx
4004cb: 48 89 48 08 mov %rcx,0x8(%rax)
4004cf: 48 8b 4a 10 mov 0x10(%rdx),%rcx
4004d3: 48 89 48 10 mov %rcx,0x10(%rax)
4004d7: 48 8b 4a 18 mov 0x18(%rdx),%rcx
4004db: 48 89 48 18 mov %rcx,0x18(%rax)
4004df: 48 8b 4a 20 mov 0x20(%rdx),%rcx
4004e3: 48 89 48 20 mov %rcx,0x20(%rax)
4004e7: 48 8b 4a 28 mov 0x28(%rdx),%rcx
4004eb: 48 89 48 28 mov %rcx,0x28(%rax)
4004ef: 48 8b 4a 30 mov 0x30(%rdx),%rcx
4004f3: 48 89 48 30 mov %rcx,0x30(%rax)
4004f7: 48 8b 4a 38 mov 0x38(%rdx),%rcx
4004fb: 48 89 48 38 mov %rcx,0x38(%rax)
4004ff: 48 8b 4a 40 mov 0x40(%rdx),%rcx
400503: 48 89 48 40 mov %rcx,0x40(%rax)
400507: 48 8b 4a 48 mov 0x48(%rdx),%rcx
40050b: 48 89 48 48 mov %rcx,0x48(%rax)
40050f: 48 8b 4a 50 mov 0x50(%rdx),%rcx
400513: 48 89 48 50 mov %rcx,0x50(%rax)
400517: 48 8b 4a 58 mov 0x58(%rdx),%rcx
40051b: 48 89 48 58 mov %rcx,0x58(%rax)
40051f: 48 8b 4a 60 mov 0x60(%rdx),%rcx
400523: 48 89 48 60 mov %rcx,0x60(%rax)
400527: 48 8b 4a 68 mov 0x68(%rdx),%rcx
40052b: 48 89 48 68 mov %rcx,0x68(%rax)
40052f: 48 8b 4a 70 mov 0x70(%rdx),%rcx
400533: 48 89 48 70 mov %rcx,0x70(%rax)
400537: 48 8b 52 78 mov 0x78(%rdx),%rdx
40053b: 48 89 50 78 mov %rdx,0x78(%rax)
获得libc的memcpy汇编代码：objdump -S /lib/libc.so.6
00973a30 <memcpy>:
973a30: 8b 4c 24 0c mov 0xc(%esp),%ecx
973a34: 89 f8 mov %edi,%eax
973a36: 8b 7c 24 04 mov 0x4(%esp),%edi
973a3a: 89 f2 mov %esi,%edx
973a3c: 8b 74 24 08 mov 0x8(%esp),%esi
973a40: fc cld
973a41: d1 e9 shr %ecx
973a43: 73 01 jae 973a46 <memcpy+0x16>
973a45: a4 movsb %ds:(%esi),%es:(%edi)
973a46: d1 e9 shr %ecx
973a48: 73 02 jae 973a4c <memcpy+0x1c>
973a4a: 66 a5 movsw %ds:(%esi),%es:(%edi)
973a4c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
973a4e: 89 c7 mov %eax,%edi
973a50: 89 d6 mov %edx,%esi
973a52: 8b 44 24 04 mov 0x4(%esp),%eax
973a56: c3 ret
973a57: 90 nop
原来两者都是通过逐字拷贝来实现的。但是“等号赋值”被编译器翻译成一连串的MOV指令，而memcpy则是一个循环。“等号赋值”比memcpy快，并不是快在拷贝方式上，而是快在程序流程上。
测试发现，“等号赋值”的长度必须小于等于128，并且是机器字长的倍数，才会被编译成连续MOV形式，否则会被编译成调用memcpy。而同样的，如果memcpy复制的长度小于等于128且是机器字长的整数倍，会被编译成MOV形式。所以，无论你的代码中如何写，编译器都会做好优化工作。
而为什么同样是按机器字长拷贝，连续的MOV指令就要比循环MOV快呢？
在循环方式下，每一次MOV过后，需要：1、判断是否拷贝完成；2、跳转以便继续拷贝。
循环还是比较浪费的。如果效率要求很高，很多情况下，我们需要把循环展开（比如在本例中，每次循环拷贝N个字节），以避免判断与跳转占用大量的CPU时间。这算是一种以空间换时间的做法。GCC就有自动将循环展开的编译选项（如：-funroll-loops）。
循环展开也是应该有个度的，并不是越展开越好（即使不考虑对空间的浪费）。因为CPU的快速执行很依赖于cache，如果cache不命中，CPU将浪费不少的时钟周期在等待内存上（内存的速度一般比CPU低一个数量级）。而小段循环结构就比较有利于cache命中，因为重复执行的一段代码很容易被硬件放在cache中，这就是代码局部性带来的好处。而过度的循环展开就打破了代码的局部性。如果要拷贝的字节更多，则全部展开成连续的MOV指令的做法未必会很高效。
综上所述，“等号赋值”之所以比memcpy快，就是因为它省略了CPU对于判断与跳转的处理，消除了分支对CPU流水的影响。而这一切都是通过适度展开内存拷贝的循环来实现的。
如果将libc的memcpy换成时等号循环赋值，效率会如何，程序如下timememcpy.c：
004 |
#include <sys/time.h> |
012 |
typedef struct memcpy_data_size |
015 |
}DATA_SIZE, *P_DATA_SIZE; |
017 |
void *mymemcpy(void *to, const void *from, size_t size) |
019 |
P_DATA_SIZE dst = (P_DATA_SIZE)to; |
020 |
P_DATA_SIZE src = (P_DATA_SIZE)from; |
022 |
int new_len = size/sizeof(DATA_SIZE)-1; |
023 |
int remain = size%sizeof(DATA_SIZE)-1; |
035 |
new_len = new_len -2; |
044 |
*((char *)dst + remain) = *((char *)src + remain); |
052 |
int main(int argc, char const* argv[]) |
055 |
struct timeval start, end; |
058 |
gettimeofday(&start, NULL); |
060 |
printf("you should run it as : ./run 1(or 0)\n"); |
061 |
printf("1: run my memcpy\n"); |
062 |
printf("0: run lib memcpy\n"); |
065 |
type = atoi(argv[1]); |
066 |
if(MYM != type && LIBM != type){ |
067 |
printf("you should run it as : ./run 1(or 0)\n"); |
068 |
printf("1: run my memcpy\n"); |
069 |
printf("0: run lib memcpy\n"); |
073 |
dst = malloc(sizeof(char)*LEN); |
075 |
perror("dst malloc"); |
079 |
src = malloc(sizeof(char)*LEN); |
081 |
perror("src malloc"); |
085 |
mymemcpy(dst, src, LEN); |
086 |
printf("my memcpy:\n"); |
089 |
memcpy(dst, src, LEN); |
090 |
printf("lib memcpy:\n"); |
095 |
gettimeofday(&end, NULL); |
096 |
diff = 1000000*(end.tv_sec - start.tv_sec)+ end.tv_usec - start.tv_usec; |
097 |
printf("run time is %ld us\n",diff); |
被注释掉的几行代码本来是用来循环展开的，可测试结果并没发现有什么好处，故，先注释掉。
在测试程序中，经过多次测试，并无法真正确定libc和自己实现的memcpy效率谁优谁劣。可能是由于运行时间太短以及进程调度所致。
目前为止，还没找到更好的测试方法，去验证效率的优劣。
现将我的测试数据粘贴至此，仅供参考：
编译程序：gcc -g -o timememcpy timememcpy.c
执行测试脚本为:run.sh
[root@SPA c]# ./run.sh
my memcpy:
run time is 435 us
my memcpy:
run time is 237 us
my memcpy:
run time is 249 us
my memcpy:
run time is 304 us
my memcpy:
run time is 300 us
lib memcpy:
run time is 262 us
lib memcpy:
run time is 222 us
lib memcpy:
run time is 335 us
lib memcpy:
run time is 281 us
lib memcpy:
run time is 247 us
脚本内容修改为：
[root@SPA c]# ./run.sh
lib memcpy:
run time is 479 us
lib memcpy:
run time is 461 us
lib memcpy:
run time is 512 us
lib memcpy:
run time is 405 us
lib memcpy:
run time is 365 us
my memcpy:
run time is 399 us
my memcpy:
run time is 314 us
my memcpy:
run time is 309 us
my memcpy:
run time is 510 us
my memcpy:
run time is 324 us
参考：
注：这个程序是起了一个计数线程，与实际的memcpy线程并发执行。本人感觉运行时间这么短的程序，要是使用一个线程去计数的话，由于进程调度机制并无法保证计数线程和该程序运行时间相同，误差会更大，所以，在本文的程序中摒弃理论这种计数方式。
- .net 表达式返回值和等号赋值的区别
.net 7.0的新特性中,有一个使用表达式体返回值的操作.请看如下代码: private string _userName=""; public string UserName{ ...
- [Python] 等号赋值, copy, deepcopy的区别
参考链接: 1. 介绍python中的可变类型与不可变类型:https://blog.csdn.net/answer3lin/article/details/86430074 (也可以参考转载博客 P ...
- Java中自增（++）和赋值（=）运算效率比较
前言 将一个int型数组x[]从初值0变成1.有两种做法: // 只考虑后自增 int length = x.length; for (int i = 0; i < length; i++) ...
- js对象等号赋值的bug
var a = {n: 1}; var b = a; a.x = a = {n: 2}; console.log(a.x); console.log(b.x); 有道题是这样的,觉得很奇葩,分析一下 ...
- SQL 两表关联查询 where 条件中等号两端字段顺序对效率的影响
现有两表A(大).B(小)作关联查询,SQL语句如下: SQL1:select * from A,B where A.id = B.id SQL2:select * from A,B where B. ...
- memmove和memcpy
1.memmove 函数原型:void *memmove(void *dest, const void *source, size_t count) 返回值说明:返回指向dest的void *指针 参 ...
- memmove和memcpy 以及strcmp strcpy几个库函数的实现
memmove和memcpy 1.memmove 函数原型:void *memmove(void *dest, const void *source, size_t count) 返回值说明:返回指向 ...
- C的memset,memcpy,strcpy 的区别 及memset memcpy memmove源码
extern void *memcpy(void *dest,void *src,unsigned int count);#include <string.h> 功能:由src所指内存 ...
- C++，对象的 =赋值 以及 复制构造函数赋值
1. C++默认实现了 = 号赋值:operator=只要将一个对象的内容的内容逐位复制给另外一个对象即可. 2. C++默认实现了复制构造函数:同样,只要将一个对象的内容的内容逐位复制给另外一个对象 ...
随机推荐
- ubuntu查看端口占用
查看端口号 sudo netstat -ltnp | 结束进程 sudo kill pid
- Linux下安装Scala
Linux下安装Scala和Windows下安装类似,步骤如下: 首先访问下载链接:http://www.scala-lang.org/download/默认这里下载的是Windows版本,这时点击上 ...
- FastReport里面正确调用函数的方法
FastReport里面正确调用函数的方法 错误: [FormatDateTime('yyyy-mm-dd',[frxDBDataset1."日期"])] --------- ...
- 【数据结构】book3_3 表达式求值
#include<iostream> #include <stdlib.h> using namespace std; typedef int Status; ; ; ; ; ...
- 调用c++接口类
调用c++接口类 public class CarDeviceDll { /*对dll库进行一些初始化*/ [DllImport("IDI.dll")] public static ...
- storyboard pushViewController 的时候，新的界面黑屏
storyboard 创建的一级界面需要通过代码跳转到另一 storyboard 创建的界面的时候,通常我们会这样 其实 alloc init 相当于重新创建一个界面,所以我们 push 进入之后会发 ...
- JavaScript对象与数组
一．Object 类型到目前为止,我们使用的引用类型最多的可能就是 Object 类型了.虽然 Object 的实例不具备多少功能,但对于在应用程序中的存储和传输数据而言,它确实是非常理想的选择.创建 ...
- NYOJ题目1045看美女
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAskAAAK5CAIAAADCdSR7AAAgAElEQVR4nO3dP3Lbuv434HcT7r2Q1F
- hdu 2546饭卡
用5块钱去买最贵的物品,用剩下的m-5块去买尽量多的物品 #include<stdio.h> #include<math.h> #include<vector> # ...
- C#学习笔记----C#中的闭包机制
http://www.cnblogs.com/jiejie_peng/p/3701070.html http://www.cnblogs.com/Ribbon/p/3611457.html “ 若匿名 ...
