linux的零复制splice、tee

要说零复制，就要先说管道pipe。

pipe在linux的实现中，用的是生产者消费者的模型，在linux/pipe_fs_i.h中我们能看到一下的代码：

#define PIPE_DEF_BUFFERS    16//...
struct pipe_inode_info {
struct mutex mutex;
wait_queue_head_t wait;
unsigned int nrbufs, curbuf, buffers;
unsigned int readers;
unsigned int writers;
unsigned int files;
unsigned int waiting_writers;
unsigned int r_counter;
unsigned int w_counter;
struct page *tmp_page;
struct fasync_struct *fasync_readers;
struct fasync_struct *fasync_writers;
struct pipe_buffer *bufs;
};

其中bufs就是一个指向管道缓冲区的指针，而管道缓冲区的结构如下：

struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};

其中page是指向包含pipe buffer的页，是物理上的页地址，不是虚拟地址，这样方便进程间的通信。

在创建管道缓冲区时，会创建PIPE_DEF_BUFFERS个pipe_buffer大小的空间给bufs，也就是bufs指向一个大小是PIPE_DEF_BUFFERS的pipe_buffer数组。一个页大小是4k，那么linux的管道缓冲区大小就是64k了。

在使用管道缓冲区时，就和生产者消费者的模型一样，一边把数据写进去，另一边把数据取出来，慢时写阻塞，空时读阻塞。在写入的时候，为了效率，linux会倾向于以页为单位的写，因此缓冲区满时未必是64k的数据。

接下来就是说splice了，

#include <fcntl.h>

ssize_t splice(int fd_in, loff_t *off_in, int fd_out,loff_t *off_out, size_t len, unsigned int flags);

成功返回spliced的字节数，出错-1

这个函数中，fd_in和fd_out中有一个要是管道，off_in、off_out分别是两个文件描述符的偏移，如果其对应的文件描述符不是普通文件，那么就不能有偏移量，就要设为NULL，当是NULL时，就是从文件当前位置读/写,结束后会更新偏移的位置。len就是要移动的数据，至于flags自己看manpage。

它之所以能零复制，就是利用了管道作为中介，先把数据“复制”管道，然后再从管道中读取即可：

pipe(fd_pair[2]);

splice(source_file,...,fd_pair[1],...);

splice(fd_pair[0],...,destination_file,...);

可是注意的是，其实我们并没有真的把数据复制进管道缓冲区，我们只是修改了管道缓冲区的page指针、偏移、长度，使它指向源数据的实际物理地址，然后再从管道中读出来，整个过程都没有设计用户空间和内核空间的复制，在内核中也没有多余的复制，因此是零复制（复制了一次，但术语是叫零复制）。

我们要注意用splice传送超过缓冲区64k的文件时，要更新：

while (filesize > 0) {       len = splice(sourcefd,&off_in,pipe_pair[1],NULL,filesize-off_in,SPLICE_F_MOVE);
splice(pipe_pair[0], NULL,dstfd,&off_out,len, SPLICE_F_MOVE);
if (len < 0) {
perror("splice");
break;
}       filesize -= len;
}

还有一个tee函数，这也是一个零复制函数

#include <fcntl.h>

ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);

成功返回“复制”的字节数，出错-1

EINVAL fd_in or fd_out does not refer to a pipe; or fd_in and fd_out refer to the same pipe.

这个函数是用于两个不同管道之间的零复制，就相当于把两个管道连通

测试

下面是段性能比较，测试程序是这样的，读入一个文件，然后分别用read-write、mmap、splice三种方法复制这个文件，我使用的是一个300多mb的视频文件来测试，最终得到的测试结果是：

最上面的数字是真正复制所用的时间，下面的是time的输出，因为还有其他的影响，因此用户时间+系统时间！=函数工作时间

read-write:

0.820000

real 0m11.919s

user 0m0.028s

sys 0m0.996s

mmap:

0.830000

real 0m10.109s

user 0m0.312s

sys 0m0.676s

splice:

0.550000

real 0m10.643s

user 0m0.000s

sys 0m0.732s

mmap的时间居然和read-write差不多。。。不过我们可以看出用mmap的系统调用时间比read-write少30%左右，可是用户调用时间比较大，因为mmap这个操作本身就是一个消耗很大的函数，如果与要长时间使用这个文件的话，那么就可以冲淡mmap消耗。splice是最快的方法，用户调用时间很少，因为它的工作就是直接在内核完成，不需要频繁的在用户空间和内核空间之间切换。

更新：

发现mmap分段的复制比较直接复制的快，不过还是慢过splice

int size=8192,total=0;
while(total < statbuf.st_size) {
size = statbuf.st_size-total > 4096 ? 4096 : statbuf.st_size-total;
memcpy(dst,src,size);
dst += size;
src += size;
total += size;
}

编写程序时出现的问题：

在下面的程序中，对于splice，不知为什么说SPLICE_F_MOVE未声明，我只好用0x1来代替。。。

还有mmap时，不知为什么我把它们都设成写，就是permission denied，读写打开文件（mmap也是读写）就可以。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<unistd.h>
#include<time.h>
#include<sys/mman.h>

#define MAX 1024
#define BUF_SIZE 4096

typedef void (*p_func)(void);

int in_fd,out_fd1,out_fd2,out_fd3;
struct stat statbuf;

void do_std_copy();
void do_mmap_copy();
void do_splice_copy();
void testfun(p_func pa);

int main(int argc,char **argv)
{
if(argc!=2) return 1;

char outfile1[MAX],outfile2[MAX],outfile3[MAX];
p_func pa[3] = {do_std_copy,do_mmap_copy,do_splice_copy};

strcpy(outfile1,argv[1]);
strcat(outfile1,"1");
strcpy(outfile2,argv[1]);
strcat(outfile2,"2");
strcpy(outfile3,argv[1]);
strcat(outfile3,"3");

if((in_fd = open(argv[1],O_RDONLY))<0) {
perror("open in_fd faild");
return 1;
}
if((out_fd1 = open(outfile1,O_WRONLY|O_CREAT|O_TRUNC,0777))<0) {
perror("open out_fd1 faild");
return 1;
}
if((out_fd2 = open(outfile2,O_RDWR|O_CREAT|O_TRUNC,0777))<0){//mmap要读写
perror("open out_fd2 faild");
return 1;
}
if((out_fd3 = open(outfile3,O_WRONLY|O_CREAT|O_TRUNC,0777))<0) {
perror("open out_fd3 faild");
return 1;
}

fstat(in_fd,&statbuf);

for(int i = 0; i<3; ++i)
testfun(pa[i]);
close(in_fd);
close(out_fd1);
close(out_fd2);
close(out_fd3);
return 0;
}

void testfun(p_func pa)
{
clock_t begin,end;

lseek(in_fd,0,SEEK_SET);
begin = clock();
pa();
end = clock();
printf("%f\n",(double)(end-begin)/CLOCKS_PER_SEC);
}

void do_std_copy()
{
char buffer[BUF_SIZE];
int bytes;
while((bytes = read(in_fd,buffer,sizeof(buffer))) >0) {
if(write(out_fd1,buffer,bytes) != bytes) {
perror("write errno");
exit(1);
}
}
}

void do_mmap_copy()
{
if(ftruncate(out_fd2,statbuf.st_size) < 0) {
perror("ftruncate faild");
return;
}
//如果是lseek创建空洞，就要write一个空字节进去
void *src = mmap(NULL,statbuf.st_size,PROT_READ,MAP_SHARED,in_fd,0);
if(src==MAP_FAILED) {
perror("mmap map src faild");
return;
}
void *dst = mmap(NULL,statbuf.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,out_fd2,0);
if(dst==MAP_FAILED) {
munmap(src,statbuf.st_size);
perror("mmap map dst faild");
return;
}

memcpy(dst,src,statbuf.st_size);
munmap(src,statbuf.st_size);
munmap(dst,statbuf.st_size);
}

void do_splice_copy()
{
int pipefd[2],len=statbuf.st_size;
pipe(pipefd);

for(;;) {
if((len=splice(in_fd,NULL,pipefd[1],NULL,len,0x1))<0) {
perror("splice in_fd faild");
return;
}
if(len==0) return;
if(splice(pipefd[0],NULL,out_fd3,NULL,len,0x1)<0) {
perror("splice out_fd3 faild");
return;
}
}
}