Eine kurze Analyse der Zero-Copy-Technologie in Linux

In diesem Artikel werden diewichtigsten Zero-Copy-Technologienund die anwendbaren Szenariender Zero-Copy-Technologie unter Linux erläutert. Um das Konzept der Nullkopie schnell zu etablieren, stellen wir ein häufig verwendetes Szenario vor: Zu diesem Zeitpunkt besteht die Aufgabe des Servers darin, die Dateien auf der Server-Host-Festplatte ohne Änderungen vom angeschlossenen Socket zu senden. Wir verwenden normalerweise den folgenden Code, um dies abzuschließen:

while((n = read(diskfd, buf, BUF_SIZE)) > 0) write(sockfd, buf , n);

Der grundlegende Vorgang besteht darin, Dateien von zu lesen Schreiben Sie den Inhalt der Festplatte in einer Schleife in den Puffer und senden Sie dann den Inhalt des Puffers an den Socket. Linux-E/A-Vorgänge sind jedoch standardmäßig gepufferte E/A. Die beiden hier verwendeten Hauptsystemaufrufe sind Lesen und Schreiben. Wir wissen nicht, was das Betriebssystem darin macht. Tatsächlich kam es während der oben genannten E/A-Vorgänge zu mehreren Datenkopien.Wenn eine Anwendung auf ein bestimmtes Datenelement zugreift, prüft das Betriebssystem zunächst, ob kürzlich auf die Datei zugegriffen wurde und ob der Dateiinhalt im Kernelpuffer zwischengespeichert ist. Wenn ja, verwendet das Betriebssystem direkt den Puffer Kopieren Sie den Inhalt des Kernel-Puffers in den durch buf angegebenen Benutzerraumpuffer. Wenn nicht, kopiert das Betriebssystem zunächst die Daten auf der Festplatte in den Kernel-Puffer. Dieser Schritt basiert derzeit hauptsächlich auf DMA für die Übertragung und kopiert dann den Inhalt des Kernel-Puffers in den Benutzerpuffer.

Als nächstes kopiert der Schreibsystemaufruf den Inhalt des Benutzerpuffers in den Kernelpuffer, der sich auf den Netzwerkstapel bezieht, und schließlich sendet der Socket den Inhalt des Kernelpuffers an die Netzwerkkarte. Nachdem wir so viel gesagt haben, schauen wir uns zur Verdeutlichung das Bild an:

Datenkopie

从上图中可以看出，共产生了四次数据拷贝，即使使用了DMA来处理了与硬件的通讯，CPU仍然需要处理两次数据拷贝，与此同时，在用户态与内核态也发生了多次上下文切换，无疑也加重了CPU负担。

在此过程中，我们没有对文件内容做任何修改，那么在内核空间和用户空间来回拷贝数据无疑就是一种浪费，而零拷贝主要就是为了解决这种低效性。

什么是零拷贝技术（zero-copy）？

零拷贝主要的任务就是避免CPU将数据从一块存储拷贝到另外一块存储，主要就是利用各种零拷贝技术，避免让CPU做大量的数据拷贝任务，减少不必要的拷贝，或者让别的组件来做这一类简单的数据传输任务，让CPU解脱出来专注于别的任务。这样就可以让系统资源的利用更加有效。

我们继续回到引文中的例子，我们如何减少数据拷贝的次数呢？一个很明显的着力点就是减少数据在内核空间和用户空间来回拷贝，这也引入了零拷贝的一个类型：

让数据传输不需要经过 user space。

使用 mmap

我们减少拷贝次数的一种方法是调用mmap()来代替read调用：

buf = mmap(diskfd, len); write(sockfd, buf, len);

应用程序调用mmap()，磁盘上的数据会通过DMA被拷贝的内核缓冲区，接着操作系统会把这段内核缓冲区与应用程序共享，这样就不需要把内核缓冲区的内容往用户空间拷贝。应用程序再调用write(),操作系统直接将内核缓冲区的内容拷贝到socket缓冲区中，这一切都发生在内核态，最后，socket缓冲区再把数据发到网卡去。同样的，看图很简单：

mmap

Die Verwendung von mmap anstelle von read reduziert offensichtlich eine Kopie, wenn die Menge der kopierten Daten groß ist, was zweifellos die Effizienz verbessert. Die Verwendung von mmap ist jedoch mit Kosten verbunden. Wenn Sie mmap verwenden, können einige versteckte Fallstricke auftreten. Wenn Ihr Programm beispielsweise eine Datei zuordnet, die Datei jedoch von einem anderen Prozess abgeschnitten (truncate) wird, wird der Schreibsystemaufruf durch das SIGBUS-Signal beendet, da er auf eine ungültige Adresse zugreift. Das SIGBUS-Signal bricht Ihren Prozess standardmäßig ab und generiert einen Coredump. Wenn Ihr Server auf diese Weise gestoppt wird, führt dies zu einem Verlust.

Normalerweise verwenden wir die folgenden Lösungen, um dieses Problem zu vermeiden:

1. Erstellen Sie einen Signalhandler für das SIGBUS-Signal.

Wenn ein SIGBUS-Signal auftritt, kehrt der Signalhandler einfach zurück und der Schreibsystemaufruf is Die Anzahl der geschriebenen Bytes vor der Unterbrechung wird zurückgegeben und errno wird auf Erfolg gesetzt. Dies ist jedoch ein schlechter Ansatz, da Sie nicht den eigentlichen Kern des Problems lösen.

2. Datei-Lease-Sperre verwenden

Normalerweise verwenden wir diese Methode, um eine Lease-Sperre vom Kernel für die Datei zu beantragen , Der Kernel sendet uns ein Echtzeit-RTSIGNALLEASE-Signal und teilt uns mit, dass der Kernel die Lese-/Schreibsperre zerstört, die Sie für die Datei festgelegt haben. Auf diese Weise wird Ihr Schreibsystemaufruf unterbrochen, bevor das Programm auf illegalen Speicher zugreift und von SIGBUS beendet wird. write gibt die Anzahl der geschriebenen Bytes zurück und setzt errno auf success.

Wir sollten die mmap-Datei vor dem Öffnen der Datei sperren und nach dem Bearbeiten der Datei entsperren:

if(fcntl(diskfd, F_SETSIG, RT_SIGNAL_LEASE) == -1) { perror("kernel lease set signal"); return -1; } /* l_type can be F_RDLCK F_WRLCK 加锁*/ /* l_type can be F_UNLCK 解锁*/ if(fcntl(diskfd, F_SETLEASE, l_type)){ perror("kernel lease set type"); return -1; }

使用sendfile

从2.1版内核开始，Linux引入了sendfile来简化操作:

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

系统调用sendfile()在代表输入文件的描述符infd和代表输出文件的描述符outfd之间传送文件内容（字节）。描述符outfd必须指向一个套接字，而infd指向的文件必须是可以mmap的。这些局限限制了sendfile的使用，使sendfile只能将数据从文件传递到套接字上，反之则不行。

使用sendfile不仅减少了数据拷贝的次数，还减少了上下文切换，数据传送始终只发生在kernel space。

sendfile系统调用过程

在我们调用sendfile时，如果有其它进程截断了文件会发生什么呢？假设我们没有设置任何信号处理程序，sendfile调用仅仅返回它在被中断之前已经传输的字节数，errno会被置为success。如果我们在调用sendfile之前给文件加了锁，sendfile的行为仍然和之前相同，我们还会收到RTSIGNALLEASE的信号。

目前为止，我们已经减少了数据拷贝的次数了，但是仍然存在一次拷贝，就是页缓存到socket缓存的拷贝。那么能不能把这个拷贝也省略呢？

借助于硬件上的帮助，我们是可以办到的。之前我们是把页缓存的数据拷贝到socket缓存中，实际上，我们仅仅需要把缓冲区描述符传到socket缓冲区，再把数据长度传过去，这样DMA控制器直接将页缓存中的数据打包发送到网络中就可以了。

总结一下，sendfile系统调用利用DMA引擎将文件内容拷贝到内核缓冲区去，然后将带有文件位置和长度信息的缓冲区描述符添加socket缓冲区去，这一步不会将内核中的数据拷贝到socket缓冲区中，DMA引擎会将内核缓冲区的数据拷贝到协议引擎中去，避免了最后一次拷贝。

带DMA的sendfile

不过这一种收集拷贝功能是需要硬件以及驱动程序支持的。

使用splice

sendfile只适用于将数据从文件拷贝到套接字上，限定了它的使用范围。Linux在2.6.17版本引入splice系统调用，用于在两个文件描述符中移动数据：

#define _GNU_SOURCE /* See feature_test_macros(7) */ #include ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsignedint flags);

splice调用在两个文件描述符之间移动数据，而不需要数据在内核空间和用户空间来回拷贝。他从fdin拷贝len长度的数据到fdout，但是有一方必须是管道设备，这也是目前splice的一些局限性。flags参数有以下几种取值：

• SPLICEFMOVE：尝试去移动数据而不是拷贝数据。这仅仅是对内核的一个小提示：如果内核不能从pipe移动数据或者pipe的缓存不是一个整页面，仍然需要拷贝数据。Linux最初的实现有些问题，所以从2.6.21开始这个选项不起作用，后面的Linux版本应该会实现。

• SPLICEFNONBLOCK：splice 操作不会被阻塞。然而，如果文件描述符没有被设置为不可被阻塞方式的 I/O ，那么调用 splice 有可能仍然被阻塞。

• SPLICEFMEHR: In nachfolgenden Spleißaufrufen werden mehr Daten vorhanden sein.

Der Spleißaufruf nutzt den von Linux vorgeschlagenen Pipe-Puffer-Mechanismus, daher muss mindestens ein Deskriptor eine Pipe sein.

Die oben genannten Zero-Copy-Technologien werden alle implementiert, indem das Kopieren von Daten zwischen Benutzerraum und Kernelraum reduziert wird, aber manchmal müssen Daten zwischen Benutzerraum und Kernelraum kopiert werden. Derzeit können wir nur am Timing des Datenkopierens im User-Space und Kernel-Space arbeiten. Linux verwendet normalerweise Copy-on-Write, um den Systemaufwand zu reduzieren. Diese Technologie wird oft als COW bezeichnet.

Aus Platzgründen wird Copy-on-Write in diesem Artikel nicht im Detail vorgestellt. Eine grobe Beschreibung lautet: Wenn mehrere Programme gleichzeitig auf dasselbe Datenelement zugreifen, verfügt jedes Programm über einen Zeiger auf dieses Datenelement. Aus Sicht jedes Programms besitzt es dieses Datenelement nur dann, wenn das Programm Wenn der Dateninhalt geändert wird, wird er in den eigenen Anwendungsbereich des Programms kopiert. Zu diesem Zeitpunkt werden die Daten zu privaten Daten des Programms. Wenn das Programm die Daten nicht ändern muss, muss es die Daten auch nie in seinen eigenen Anwendungsbereich kopieren. Dies reduziert das Kopieren von Daten. Der beim Schreiben kopierte Inhalt kann zum Schreiben eines weiteren Artikels verwendet werden. . .

Darüber hinaus gibt es einige Zero-Copy-Technologien, wie das Hinzufügen der O_DIRECT-Markierung zu herkömmlichem Linux-I/O, um direktes I/O zu ermöglichen, automatisches Caching zu vermeiden, und die unausgereifte fbufs-Technologie, die in diesem Artikel noch nicht behandelt wird Alle abgedeckten Zero-Copy-Technologien sind nur einige der gängigen. Wenn Sie interessiert sind, können Sie sie selbst studieren. Im Allgemeinen ändern ausgereifte serverseitige Projekte auch die E/A-bezogenen Teile des Kernels Übertragungsraten.