Que signifie Linux io ?

Linux io fait référence à une opération sur un fichier ; sous Linux, un fichier est une série de flux binaires. Lors de l'échange d'informations, nous effectuons tous des opérations d'envoi et de réception de données sur ces flux. Ces opérations sont appelées opérations d'E/S. . Puisque Linux utilise un mécanisme de mémoire virtuelle, le noyau doit être demandé via des appels système pour terminer les opérations d'E/S.

L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.

Que signifie Linux io ?

Nous savons tous que dans le monde Linux, tout est un fichier.

Et un fichier est une série de flux binaires, peu importe Socket, FIFO, pipe ou terminal, pour nous, tout est un flux.

• Dans le processus d'échange d'informations, nous effectuons tous des opérations d'envoi et de réception de données sur ces flux, appelées opérations d'E/S.

• Lisez les données du flux, le système appelle Read, écrit les données et le système appelle Write.

Habituellement, une IO complète du processus utilisateur est divisée en deux étapes :

E/S disque :

E/S réseau :

Le système d'exploitation et le pilote s'exécutent dans l'espace du noyau, et l'application fonctionnant dans l'espace utilisateur, les deux ne peuvent pas utiliser de pointeurs pour transférer des données, car le mécanisme de mémoire virtuelle utilisé par Linux doit demander au noyau via des appels système d'effectuer des actions d'E/S.

IO a trois types : IO mémoire, IO réseau et IO disque Habituellement, lorsque nous parlons d'IO, nous faisons référence aux deux derniers !

Pourquoi le modèle IO est nécessaire

Si vous utilisez synchrone pour communiquer, toutes les opérations seront exécutées séquentiellement dans un thread. Les inconvénients sont évidents :

• Parce que les opérations de communication synchrones bloqueront toute autre opération sur. le même thread, seulement une fois cette opération terminée, les opérations suivantes peuvent être terminées, donc blocage synchrone + multi-threading (chaque Socket crée un thread correspondant), mais le nombre de threads dans le système est Il y a des limites, et le thread la commutation est en même temps une perte de temps, elle convient donc aux situations où il y a peu de Sockets.

Le modèle IO doit apparaître.

Modèle Linux IO

Avant de décrire le modèle Linux IO, comprenons d'abord le processus de lecture des données du système Linux :

Prenons l'exemple de l'utilisateur qui demande le fichier index.html

Concepts de base

Espace utilisateur et espace noyau

Le cœur du système d'exploitation est le noyau, qui est indépendant des applications ordinaires et peut accéder à l'espace mémoire protégé et dispose également de toutes les autorisations pour accéder aux périphériques matériels sous-jacents.

• Afin d'assurer la sécurité du noyau, les processus utilisateur ne peuvent pas faire fonctionner directement le noyau. Le système d'exploitation divise l'espace virtuel en deux parties, l'une est l'espace noyau et l'autre est l'espace utilisateur.

Commutation de processus

Afin de contrôler l'exécution d'un processus, le noyau doit avoir la capacité de suspendre le processus en cours d'exécution sur le CPU et de reprendre l'exécution d'un processus précédemment suspendu.

Ce comportement est appelé changement de processus.

On peut donc dire que tout processus s'exécute avec le support du noyau du système d'exploitation et est étroitement lié au noyau.

Blocage du processus

Le processus en cours d'exécution, en raison de certains événements attendus qui ne se produisent pas, tels que l'échec de la demande de ressources système, l'attente de la fin d'une certaine opération, de nouvelles données qui ne sont pas encore arrivées ou aucun nouveau travail à effectuer, etc. ., sera bloqué par le système Exécuter automatiquement la primitive de blocage (Bloquer) pour passer de l'état d'exécution à l'état de blocage.

On voit que le blocage d'un processus est un comportement actif du processus lui-même, et donc seul un processus en état d'exécution (obtention du CPU) peut le transformer en état bloqué.

Lorsque le processus entre dans l'état de blocage, il n'occupe pas les ressources CPU.

Descripteur de fichier

Descripteur de fichier (Descripteur de fichier) est un terme en informatique et est un concept abstrait utilisé pour exprimer une référence à un fichier.

Le descripteur de fichier est formellement un entier non négatif. En fait, il s'agit d'une valeur d'index pointant vers la table d'enregistrement des fichiers ouverts par le processus maintenu par le noyau pour chaque processus.

• Lorsqu'un programme ouvre un fichier existant ou crée un nouveau fichier, le noyau renvoie un descripteur de fichier au processus.

E/S en cache

L'opération d'E/S par défaut pour la plupart des systèmes de fichiers est l'E/S en cache.

Le processus de lecture et d'écriture est le suivant :

• Opération de lecture : Le système d'exploitation vérifie si le tampon du noyau contient les données requises. S'il a été mis en cache, il sera renvoyé directement depuis le cache, sinon il sera lu à partir du disque, de la carte réseau, etc. ., puis mis en cache dans le système d'exploitation Dans le cache ;

• Opération d'écriture : Copier les données de l'espace utilisateur vers le cache dans l'espace noyau. À ce stade, l'opération d'écriture est terminée pour le programme utilisateur. Quant au moment d'écrire sur le disque, la carte réseau, etc., cela est déterminé par le système d'exploitation, à moins que la commande de synchronisation sync ne soit explicitement appelée.

En supposant qu'il n'y a pas de données requises dans le cache spatial du noyau, le processus utilisateur lit les données du disque ou du réseau en deux étapes :

• Phase 1 : Le programme du noyau lit les données du disque, du réseau carte, etc. dans la zone de cache de l'espace noyau ;

• Phase 2 : Le programme utilisateur copie les données du cache de l'espace noyau vers l'espace utilisateur.

Inconvénients des E/S mises en cache :

Les données doivent être copiées plusieurs fois dans l'espace d'adressage de l'application et dans l'espace du noyau pendant le processus de transmission. La surcharge du processeur et de la mémoire causée par ces opérations de copie de données est très importante.

Blocage synchrone

L'application de l'espace utilisateur exécute un appel système, ce qui provoque le blocage de l'application et ne fait rien jusqu'à ce que les données soient prêtes, et les données sont copiées du noyau vers le processus utilisateur, et enfin le processus traite les données Dans les deux étapes d'attente des données et de traitement des données, l'ensemble du processus est bloqué et ne peut pas gérer les autres E/S du réseau.

• L'application appelante est dans un état où elle ne consomme plus de CPU et attend simplement une réponse, donc du point de vue du traitement, c'est très efficace.

C'est aussi le modèle IO le plus simple. Ce n'est pas un problème de l'utiliser lorsqu'il y a généralement peu de FD et que la préparation est rapide.

Non bloquant synchrone

Après l'appel du système non bloquant, le processus n'est pas bloqué et le noyau revient immédiatement au processus. Si les données ne sont pas prêtes, une erreur sera renvoyée. temps.

• Après le retour du processus, il peut faire autre chose avant de passer un appel système.

• Répétez le processus ci-dessus et effectuez des appels système dans un cycle. Ce processus est souvent appelé sondage.

• Interrogez et vérifiez les données du noyau jusqu'à ce que les données soient prêtes, puis copiez les données dans le processus pour le traitement des données.

• Il convient de noter que pendant tout le processus de copie des données, le processus est toujours bloqué.

• De cette façon, vous pouvez définir O_NONBLOCK sur le Socket en programmation. O_NONBLOCK即可。

IO多路复用

IO多路复用，这是一种进程预先告知内核的能力，让内核发现进程指定的一个或多个IO条件就绪了，就通知进程。

使得一个进程能在一连串的事件上等待。

IO复用的实现方式目前主要有Select、Poll和Epoll。

伪代码描述IO多路复用：

while(status == OK) { // 不断轮询 ready_fd_list = io_wait(fd_list); //内核缓冲区是否有准备好的数据 for(fd in ready_fd_list) {  data = read(fd) // 有准备好的数据读取到用户缓冲区  process(data) }}

信号驱动

首先我们允许Socket进行信号驱动IO，并安装一个信号处理函数，进程继续运行并不阻塞。

当数据准备好时，进程会收到一个SIGIO信号，可以在信号处理函数中调用I/O操作函数处理数据。

流程如下：

• 开启套接字信号驱动IO功能

• 系统调用Sigaction执行信号处理函数（非阻塞，立刻返回）

• 数据就绪，生成Sigio信号，通过信号回调通知应用来读取数据

此种IO方式存在的一个很大的问题：Linux中信号队列是有限制的，如果超过这个数字问题就无法读取数据

异步非阻塞

异步IO流程如下所示：

• 当用户线程调用了aio_read

• 

  Multiplexage IO

Multiplexage IO, c'est la capacité d'un processus à informer le noyau à l'avance, permettant au noyau de découvrir qu'une ou plusieurs conditions IO spécifiées par le processus sont prêtes , avertissez le processus.

• Permet à un processus d'attendre une série d'événements.

• Les principales méthodes de mise en œuvre de la réutilisation des IO incluent actuellement Select, Poll et Epoll. " />
  Le pseudocode décrit le multiplexage IO :
rrreee

Pilote de signal

Nous autorisons d'abord Socket à effectuer des IO pilotées par le signal et à installer une fonction de traitement du signal. Le processus continue de s'exécuter sans blocage.

Lorsque les données sont prêtes, le processus recevra un signal SIGIO et pourra appeler la fonction d'opération d'E/S dans la fonction de traitement du signal pour traiter les données. 🎜🎜🎜Le processus est le suivant : 🎜🎜🎜🎜🎜Activer la fonction IO du pilote de signal de prise 🎜🎜🎜🎜Le système appelle Sigaction pour exécuter la fonction de traitement du signal (non bloquant, retour immédiat) 🎜🎜🎜🎜Les données sont prêt, générez le signal Sigio et transmettez le signal L'application de notification de rappel est utilisée pour lire les données🎜🎜🎜🎜Il y a un gros problème avec cette méthode IO : la file d'attente des signaux sous Linux est limitée si ce nombre est dépassé, les données. ne peut pas être lu🎜🎜 h

Asynchrone non bloquant🎜🎜🎜Le processus d'E/S asynchrone est le suivant : 🎜🎜🎜🎜🎜Lorsque le thread utilisateur appelle le système aio_read appel, il peut commencer à faire autre chose immédiatement et le thread utilisateur n'est pas bloqué 🎜🎜🎜🎜Le noyau commence la première phase des IO : préparer les données. Lorsque le noyau attend que les données soient prêtes, il copiera les données du tampon du noyau vers le tampon utilisateur🎜🎜🎜🎜Le noyau enverra un signal au thread utilisateur ou rappellera l'interface de rappel enregistrée par le thread utilisateur pour dire au thread utilisateur L'opération de lecture est terminée🎜🎜🎜🎜Le thread utilisateur lit les données dans le tampon utilisateur et termine les opérations commerciales ultérieures🎜🎜🎜🎜🎜Par rapport aux IO synchrones, les IO asynchrones ne sont pas exécutées séquentiellement. 🎜

Une fois que le processus utilisateur a effectué l'appel système aio_read, que les données du noyau soient prêtes ou non, elles seront renvoyées directement au processus utilisateur, puis le processus en mode utilisateur pourra faire d'autres choses. . aio_read系统调用之后，无论内核数据是否准备好，都会直接返回给用户进程，然后用户态进程可以去做别的事情。

等到数据准备好了，内核直接复制数据给进程，然后从内核向进程发送通知。

对比信号驱动IO，异步IO的主要区别在于：

• 信号驱动由内核告诉我们何时可以开始一个IO操作(数据在内核缓冲区中)，而异步IO则由内核通知IO操作何时已经完成(数据已经在用户空间中)。

异步IO又叫做事件驱动IO，在Unix中，为异步方式访问文件定义了一套库函数，定义了AIO的一系列接口。

• 使用aio_read或者aio_write发起异步IO操作，使用aio_error
Lorsque les données sont prêtes, le noyau copie directement les données dans le processus, puis envoie une notification du noyau au processus.

Par rapport aux IO pilotées par signal, la principale différence entre les IO asynchrones est :

• Le pilote de signal nous indique quand une opération IO peut être démarrée par le noyau (les données sont dans le tampon du noyau), Asynchronous IO informe le noyau lorsque l'opération IO est terminée (les données sont déjà dans l'espace utilisateur).

  Les IO asynchrones sont également appelées IO pilotées par événements Sous Unix, un ensemble de fonctions de bibliothèque sont définies pour l'accès asynchrone aux fichiers, et une série d'interfaces AIO sont définies.

  • Utilisez aio_read ou aio_write pour lancer une opération d'E/S asynchrone et utilisez aio_error pour vérifier l'état de l'E/S en cours d'exécution. opération.

    L'implémentation actuelle du noyau d'AIO sous Linux n'est efficace que pour les fichiers IO Si vous souhaitez implémenter un véritable AIO, vous devez l'implémenter vous-même.

    Il existe actuellement de nombreuses bibliothèques d'E/S asynchrones open source, telles que libevent, libev et libuv.

🎜🎜🎜🎜Recommandations associées : "🎜Tutoriel vidéo Linux🎜"🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!