Linux下的几种文件拷贝方式效率对比

红太狼 2022-07-14 10:41 468阅读 0赞

不管是哪种操作系统，要实现文件拷贝，必须陷入内核，从磁盘读取文件内容，然后存储到另一个文件。实现文件拷贝最通常的做法是：读取文件用系统调用read()函数，读取到一定长度的连续的用户层缓冲区，然后 使用write()函数将缓冲区内容 写入文件。也可以用标准库函数fread()和fwrite()，但这两个函数最终还是通过系统调用read()和write()实现拷贝的，因此可以归为一类（不过效率肯定没有直接进行系统调用的高）。 一个更高级的做法是使用虚拟存储映射技术进行，这种方法将源文件以共享方式映射到虚拟存储器中，目的文件也以共享方式映射到虚拟地址空间中，然后使用memcpy高效地将源文件内容复制到目的文件中。

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <sys/mman.h>  
    
4.  \#include <unistd.h>  
    
5.  \#include <sys/types.h>  
    
6.  \#include <sys/stat.h>  
    
7.  \#include <fcntl.h>  
    
8.  \#include <errno.h>  
    
9.  \#include <string.h>  
    
10. \#include <sys/times.h>  
    
11.   
    
12. \#define error(fmt,args...) \\  
    
13. printf(fmt, \#\#args) ; \\  
    
14. printf(":%s\\n",strerror(errno))  
    
15.   
    
16. inline int cp\_rw(int srcfd,int dstfd,char \*buf,int len);  
    
17. inline int cp\_map(int srcfd,int dstfd,size\_t len);  
    
18.   
    
19. int main(int argc,char \*\*argv)  
    
20. \{   
    
21. char buf\[8192\];  
    
22. int srcfd,dstfd;  
    
23. clock\_t start,end;  
    
24. struct tms stm,ntm;  
    
25. struct stat filestat;  
    
26. int tck;  
    
27. char cmdline\[30\];  
    
28.   
    
29. if(argc!=3)  
    
30. printf("usage: cmd ");  
    
31.   
    
32. tck=sysconf(\_SC\_CLK\_TCK);  
    
33.   
    
34.   
    
35. start = times(&stm);  
    
36. if((srcfd=open(argv\[1\],O\_RDONLY))==\-1)  
    
37. \{   
    
38. error("open %s error",argv\[1\]);  
    
39. exit(0);  
    
40. \}  
    
41. if((dstfd=open(argv\[2\],O\_RDWR|O\_CREAT|O\_TRUNC,0666))==\-1)  
    
42. \{   
    
43. error("creat %s error",argv\[2\]);  
    
44. exit(0);  
    
45. \}  
    
46.   
    
47. fstat(srcfd,&filestat);  
    
48. if(lseek(dstfd,filestat.st\_size,SEEK\_SET)==\-1)  
    
49. \{   
    
50. error("lseek error");  
    
51. exit(0);  
    
52. \}  
    
53. if(write(dstfd," ",1)!=1)  
    
54. \{   
    
55. error("write error");  
    
56. exit(0);  
    
57. \}  
    
58. cp\_map(srcfd,dstfd,filestat.st\_size);  
    
59. close(srcfd);  
    
60. close(dstfd);  
    
61. end = times(&ntm);  
    
62. printf("copying %s to %s using cp\_map:filesize=%lu MBytes Using %f seconds\\n"  
    
63. ,argv\[1\],argv\[2\],filestat.st\_size>>20,(end\-start)/(double)tck);  
    
64.   
    
65. sprintf(cmdline,"rm -f %s",argv\[2\]);  
    
66. system(cmdline);  
    
67.   
    
68.   
    
69. start = times(&stm);  
    
70. if((srcfd=open(argv\[1\],O\_RDONLY))==\-1)  
    
71. \{   
    
72. error("open %s error",argv\[1\]);  
    
73. \}  
    
74. if((dstfd=open(argv\[2\],O\_RDWR|O\_CREAT|O\_TRUNC,0666))==\-1)  
    
75. \{   
    
76. error("creat %s error",argv\[2\]);  
    
77. \}  
    
78. cp\_rw(srcfd,dstfd,buf,sizeof(buf));  
    
79. fstat(srcfd,&filestat);  
    
80. close(srcfd);  
    
81. close(dstfd);  
    
82. end = times(&ntm);  
    
83. printf("copying %s to %s using cp\_rw:filesize=%lu MBytes Using %f seconds\\n"  
    
84. ,argv\[1\],argv\[2\],filestat.st\_size>>20,(end\-start)/(double)tck);  
    
85.   
    
86.   
    
87.   
    
88. return 0;  
    
89. \}  
    
90.   
    
91. inline int cp\_rw(int srcfd,int dstfd,char \*buf,int len)  
    
92. \{   
    
93. int nread;  
    
94. while((nread=read(srcfd,buf,len))>0)  
    
95. \{   
    
96. if(write(dstfd,buf,nread)!=nread)  
    
97. \{   
    
98. error("write error");  
    
99. return \-1;  
    
100. \}  
    
101. \}  
    
102. if(nread ==\-1)  
    
103. \{   
    
104. error("read error");  
    
105. return \-1;  
    
106. \}  
    
107. return 0;  
    
108. \}  
    
109.   
    
110. inline int cp\_map(int srcfd,int dstfd,size\_t len)  
    
111. \{   
    
112. char \*src,\*dst;  
    
113. if((src=mmap(0,len,PROT\_READ,MAP\_SHARED,srcfd,0))==MAP\_FAILED)  
    
114. \{   
    
115. error("mmap src error");  
    
116. return \-1;  
    
117. \}  
    
118. if((dst=mmap(0,len,PROT\_WRITE,MAP\_SHARED,dstfd,0))==MAP\_FAILED)  
    
119. \{   
    
120. error("mmap dst error");  
    
121. return \-1;  
    
122. \}  
    
123. if(memcpy(dst,src,len)==NULL)  
    
124. \{   
    
125. error("memcpy error");  
    
126. return \-1;  
    
127. \}  
    
128. munmap(src,len);  
    
129. munmap(dst,len);  
    
130. return 0;  
    
131. \}

运行，拷贝一个1.1G的文件，得到如下结果

\[root@garden copy\]\# ./copy /home/ker.tgz ./ker.tgz

copying /home/ker.tgz to ./ker.tgz using cp\_map:filesize=1030 MBytes Using 61.900000 seconds

copying /home/ker.tgz to ./ker.tgz using cp\_rw:filesize=1030 MBytes Using 34.330000 seconds

使用read/write的方法居然比mmap的快一倍，这是怎么回事呢？理论上mmap系统调用只进行了一次，而且拷贝文件是直接在内核空间进行的，read/write则需要通过系统调用把内核空间的缓存复制到用户空间，再将用户空间缓存复制到内核空间，拷贝次数明显多了一个呢？速度为什么于理论预测的不一致呢？