Six pictures explain Linux zero-copy technology clearly

Hello everyone, today let us talk about Linux zero-copy technology. We will use the sendfile system call as an entry point to deeply explore the basic principles of zero-copy technology. The core idea of ​​zero-copy technology is to minimize the copying of data between memories and improve the efficiency and performance of data transmission by optimizing the data transmission path.

1. Introduction to zero-copy technology

Linux zero-copy technology is a technology used to optimize data transmission. It improves the efficiency of data transmission by reducing the number of data copies between kernel mode and user mode.

During the process of data transmission, it is usually necessary to copy the data from the kernel buffer to the application buffer, and then from the application buffer to the buffer of the network device before the transmission can be completed.

The advantage of zero-copy technology is that it can directly transmit data without the need for intermediate copying steps, which helps improve the efficiency of data transmission.

Linux zero-copy technology implementation:

• sendfile system call: The sendfile system call can directly send the file content to the buffer of the network device in the kernel state, avoiding the copying of data between the user state and the kernel state.
• splice system call: The splice system call can directly transfer data from one file descriptor to another file descriptor, or can also transfer data from one file descriptor to the buffer of a network device, avoiding the intermediate copy process. .
• mmap and write system calls: The mmap system call can map files into memory, and then use the write system call to send the data in the memory directly to the buffer of the network device, avoiding the data between the user state and the kernel state. copy.
• DMA (Direct Memory Access): DMA is a hardware technology that can directly transfer data from memory to the buffer of a network device, avoiding CPU intervention and improving the efficiency of data transmission.

2.sendfile system call

The sendfile system call can transfer file data directly within kernel space by copying data from one file descriptor to the send buffer of another file descriptor. In this way, data can be sent directly through the network protocol stack, avoiding frequent data copy operations between user space and kernel space.

This avoids the copying of data between the kernel and user space and improves transmission efficiency.

sendfile system call function prototype:

#include 
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

参数说明：
out_fd：目标文件描述符，用于发送数据。
in_fd：源文件描述符，从该文件读取数据。
offset：指定从源文件的哪个位置开始读取数据，可以为NULL表示从当前位置开始。
count：要传输的字节数。

返回值：
成功：返回写入out_fd文件的字节数。
失败：返回-1，并设置errno。

3.sendfile implementation principle

3.1 Send files via traditional method

To use the traditional method to send a file through socket, we need to execute a relatively long path.

Path: Disk->File Page Cache->User Buffer->Socket Buffer->Network Card.

Context switching and memory copy conditions are as follows:

• Context switch: 4 times (read call, read return, write call, write return)
• DMA copy: 2 times
• CPU copy: 2 times (file page cache->user buffer, user buffer->socket buffer)

picture

3.2 sendfile sends file

Use sendfile to send files. Relatively speaking, the entire path will be shorter.

Path: Disk->File Page Cache->Socket Buffer->Network Card.

Context switching and memory copy conditions are as follows:

Context switch: 2 times (sendfile call, sendfile return)

DMA copy: 2 times

CPU copy: 1 time (file page cache->socket buffer)

picture

3.3 Sendfile implementation principle

The core of sendfile implementation is pipes, which are widely used in Linux systems, such as inter-process communication through pipes.

When file data needs to be copied to the socket buffer, a pipe (ring buffer) will be temporarily created, the file data will be copied to the pipe first, and then the pipe data will be migrated to the socket buffer. Data migration is not a data copy. , just points the pointer to the memory address.

picture

3.4 Section

By using sendfile to send files, we can reduce two context switches and one CPU copy. If our actual application scenario requires sending a large number of files, using sendfile can greatly improve system performance.

4. Pipeline

4.1 Pipeline Introduction

Pipes are widely used in Linux systems. In addition to zero-copy technology using pipes, inter-process communication also uses pipes. So what exactly are pipes?

picture

What is a pipeline?

A pipe is actually a ring buffer, through which data can be copied from one file to another.

The pipe is defined by the struct pipe_inode_info structure. This data structure has 4 important members:

• pipe_buffer: Pipe buffer array, a fixed-length array, each array member is a buffer, corresponding to a struct pipe_buffer structure.
• head: Head serial number, indicating the location of the current writable buffer, which needs to be used in conjunction with mask.
• tail: Tail serial number, indicating the position of the current readable buffer, which needs to be used in conjunction with mask.
• ring_size: Pipe buffer array length, ring_size – 1 calculates mask, head & mask obtains the current writable buffer array subscript, tail & mask obtains the current readable buffer array subscript.

The pipe buffer is defined by struct pipe_buffer, which has three important members:

• page: page pointer
• offset: Data offset in the page
• len: data length

Determine whether the pipe is full or empty?

Pipeline full judgment:

head – tail >= ring_size, indicating that the pipe is full.

Judgement if the pipe is empty:

head == tail, indicating that the pipe is empty.

The above is the detailed content of Six pictures explain Linux zero-copy technology clearly. For more information, please follow other related articles on the PHP Chinese website!