Traditional file transfer

If the server wants to provide the function of file transfer , The simplest way we can think of is ： Read out the files on the disk , And then send it to the client through the network protocol .

Tradition I/O The way we work is , Data read and write are copied back and forth from user space to kernel space , And the kernel space data is through the operating system level I/O Interface to read or write from disk .

First , A total of 4 Context switch between secondary user mode and kernel mode , Because there were two system calls , Once it was read() , Once it was write(), Every system call must first switch from user mode to kernel mode , After the kernel completes its task , Then switch from kernel mode to user mode . The cost of context switching is not small , A switch takes tens of nanoseconds to microseconds , Although the time seems short , But in a high concurrency scenario , This kind of time is easy to accumulate and amplify , This will affect the performance of the system .

secondly , It also happened 4 Secondary data copy , Two of them were DMA A copy of the , The other two were through CPU Copy , Let's talk about the process ： The first copy , Copy the data on the disk into the buffer of the operating system kernel , The process of copying is through DMA Carrying . Second copy , Copy the data from the kernel buffer to the user's buffer , So our application can use this data , This copy to process is done by CPU Accomplished . The third copy , Just copy the data to the user's buffer , And then copy it to the kernel socket In the buffer of , The process is still by CPU Carrying . The fourth copy , Put the kernel of socket Data in the buffer , Copy to the network card buffer , This process is again caused by DMA Carrying .

We're just carrying a piece of data , It turned out to be carrying 4 Time , A lot of unnecessary expenses ,, Greatly reduces system performance . therefore , To improve the performance of file transfer , You need to reduce the number of context switches and memory copies between user state and kernel state .

Zero copy technology

mmap + write

In front of us, we know ,read() During the system call, the data in the kernel buffer will be copied to the user's buffer , So in order to reduce the cost of this step , We can use mmap() Replace read() System call function .mmap() The system call function will directly put the data in the kernel buffer 「 mapping 」 To user space , such , The operating system kernel and user space do not need any data copy operation .

The specific process is as follows ：

1. The application process called mmap() after ,DMA Will copy the disk data to the kernel buffer .
2. next , Application process and operating system kernel 「 share 」 This buffer ;
3. The application process calls again write(), The operating system directly copies the data from the kernel buffer to the socket Buffer zone , All this happens in kernel state , from CPU To carry data ;
4. Last , Put the kernel of socket Data in the buffer , Copy to the network card buffer , This process is driven by DMA Carrying . We can see , By using

mmap() Instead of read(), It can reduce the process of one copy of data . But it's not the ideal zero copy , Because it still needs to pass CPU Copy the data from the kernel buffer to socket In the buffer , And still need to 4 Subcontext switch , Because the system call is still 2 Time .

sendfile

stay Linux Kernel version 2.1 in , Provides a special system call function to send files sendfile(), The function form is ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count); Its first two parameters are the file descriptors on the destination side and the source side respectively , The last two parameters are the offset of the source and the length of the copied data , The return value is the length of the actual copied data .

First , It can replace the front read() and write() These two system calls , This reduces the number of system calls , It's less 2 The overhead of sub context switching .

secondly , The system calls , You can directly copy the data in the kernel buffer to socket In the buffer , No longer copy to user mode , This is the only way 2 Subcontext switch , and 3 Secondary data copy . Here's the picture ：