等号赋值与memcpy的效率问题

原创 2013年12月05日 16:00:42

偶尔看到一个说法,说,小内存的拷贝,使用等号直接赋值比memcpy快得多。结合自己搜集到的资料,整理成此文。

事实:strcpy等函数的逐字节拷贝,memcpy是按照机器字长逐字进行拷贝的,一个字等于4(32位机)或8(64位机)个字节。CPU存取一个字节和存取一个字一样,都是在一条指令、一个内存周期内完成的。显然,按字拷贝效率更高。

先给出一个程序:

#include <stdio.h>
#define TESTSIZE        128
struct node {
        char buf[TESTSIZE];
};
int main()
{
        char src[TESTSIZE] = {0};
        char dst[TESTSIZE];
        *(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:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>

#define LEN 0x20000
#define MYM 1
#define LIBM 0
char *dst;
char *src;

typedef struct memcpy_data_size
{
	int a[16];
}DATA_SIZE, *P_DATA_SIZE;

void *mymemcpy(void *to, const void *from, size_t size)
{
	P_DATA_SIZE dst = (P_DATA_SIZE)to;
	P_DATA_SIZE src = (P_DATA_SIZE)from;

	int new_len  = size/sizeof(DATA_SIZE)-1;
	int remain  = size%sizeof(DATA_SIZE)-1;
	
	while (new_len >= 1)
	{
		*dst++ = *src++;
		new_len--;
	}
#if 0
	while (new_len >= 2)
	{
		*dst++ = *src++;
		*dst++ = *src++;
		new_len = new_len -2;
	}
	if(new_len == 1)
	{
		*dst++ = *src++;
	}
#endif
	while (remain >= 0)
	{
		*((char *)dst + remain) = *((char *)src + remain);
		remain--;
	}

	return to;
}


int main(int argc, char const* argv[])
{
	int type = 0;
	struct timeval start, end;
	unsigned long diff;

	gettimeofday(&start, NULL);
	if(argc != 2){
		printf("you should run it as : ./run 1(or 0)\n");
		printf("1: run my memcpy\n");
		printf("0: run lib memcpy\n");
		exit(0);
	}
	type = atoi(argv[1]);
	if(MYM != type && LIBM != type){
		printf("you should run it as : ./run 1(or 0)\n");
		printf("1: run my memcpy\n");
		printf("0: run lib memcpy\n");
		exit(0);
	}

	dst = malloc(sizeof(char)*LEN);
	if (NULL == dst) {
		perror("dst malloc");
		exit(1);
	}

	src = malloc(sizeof(char)*LEN);
	if (NULL == src) {
		perror("src malloc");
		exit(1);
	}
	if(MYM == type){
		mymemcpy(dst, src, LEN);
		printf("my memcpy:\n");
	}
	else{
		memcpy(dst, src, LEN);	
		printf("lib memcpy:\n");
	}
	free(dst);
	free(src);
	
	gettimeofday(&end, NULL);
	diff = 1000000*(end.tv_sec - start.tv_sec)+ end.tv_usec - start.tv_usec;
	printf("run time is %ld us\n",diff);
	
	return 0;
}

被注释掉的几行代码本来是用来循环展开的,可测试结果并没发现有什么好处,故,先注释掉。
在测试程序中,经过多次测试,并无法真正确定libc和自己实现的memcpy效率谁优谁劣。可能是由于运行时间太短以及进程调度所致。
 
目前为止,还没找到更好的测试方法,去验证效率的优劣。
现将我的测试数据粘贴至此,仅供参考:
编译程序:gcc -g -o timememcpy timememcpy.c
执行测试脚本为:run.sh
#!/bin/sh
./timememcpy 1
./timememcpy 1
./timememcpy 1
./timememcpy 1
./timememcpy 1
./timememcpy 0
./timememcpy 0
./timememcpy 0
./timememcpy 0
./timememcpy 0
运行该脚本,得结果如下:
[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
 脚本内容修改为:
#!/bin/sh
./timememcpy 0
./timememcpy 0
./timememcpy 0
./timememcpy 0
./timememcpy 0
./timememcpy 1
./timememcpy 1
./timememcpy 1
./timememcpy 1
./timememcpy 1

再次运行,得结果:
[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线程并发执行。本人感觉运行时间这么短的程序,要是使用一个线程去计数的话,由于进程调度机制并无法保证计数线程和该程序运行时间相同,误差会更大,所以,在本文的程序中摒弃理论这种计数方式。
 

相关文章推荐

memcpy的用法总结

1、memcpy 函数用于 把资源内存(src所指向的内存区域) 拷贝到目标内存(dest所指向的内存区域);拷贝多少个?有一个size变量控制拷贝的字节数;函数原型:void *memcpy(voi...

关于memcpy拷贝结构体、结构体数组到字符数组(字符串)的问题

memcpy可以将结构体拷贝到字符数组中,但直接从字符数组中是不能取出想要的结果的。因为结构体中数据类型和字符类型是不一致的, 如果真要取出数据内容,有两种方法:1.再次使用memcpy进行解析 2....

memcpy的速度测试

想把一组char a[4096]的数组拷贝到short b[6][256]中,尝试过用循环移位的方式,还用中间变量short c[2048]的方式。得出的结论: 1. 移位方式效率最低 2. ...

memcpy和strcpy区别以及它们的效率分析

1、首先介绍这两个函数的原型: #include char *strcpy( char *to, const char *from ); #include void *memc...
  • vgxpm
  • vgxpm
  • 2015年08月13日 17:46
  • 2245

比memcpy更快的内存拷贝

比memcpy更快的内存拷贝 2009-07-09 22:14 偶然间看到一个叫xmemcpy的工具,用做内存拷贝。号称在拷贝120字节以内时,比glibc提供的memcpy快...

寻找更快的内存拷贝方式

memcpy strcpy xmemcopy

c语言中的memcpy实现

本文通过汇总一些网上搜集到的资料,总结c语言中的memcpy实现 背景 想必大多数人在面试时被要求写 memcpy的实现,很不幸,我也吃过这个亏(这种题要是写的一塌糊涂后面完全没戏),所以还是得提前准...

duilib动画按钮实现

在工作中遇到一个要实现动画按钮的问题,在网上搜索了一圈,也没有找到比较合适的解决方法。于是就自己花点时间写了一个。现在把实现方法贡献给大家,希望您有用。 实现方式为定义一个类“CButtonUIEx...

多线程断点续传(文件保存进度方式)

public class MainActivity extends Activity { private static final String TAG = "MainActivity"; ...

在Word2016公式编辑器中一招搞定等号对齐问题

微软OFFICE套装中的公式编辑器历来为人所诟病,但有时还不得不用它来编辑文档。 有时在Word中我们会遇到多行等式对不齐的情况,这让人非常抓狂: 而我们希望是: ⎧⎩⎨⎪⎪⎪⎪⎪⎪⎪⎪s0...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:等号赋值与memcpy的效率问题
举报原因:
原因补充:

(最多只允许输入30个字)