Amélioration multiplexage réseau, regex et Cap'n Proto + corrections documentation

Author: NDXDeveloper

22-networking/03-multiplexage-io.md

@@ -12,8 +12,8 @@ Considérons ce scénario concret :
 // Serveur naïf : bloquant, un seul client à la fois
 int client_fd = accept(server_fd, nullptr, nullptr);  // Bloque jusqu'à une connexion
 
-char buffer[4096];
-ssize_t n = recv(client_fd, buffer, sizeof(buffer), 0);  // Bloque jusqu'à réception
+char buffer[4096];  
+ssize_t n = recv(client_fd, buffer, sizeof(buffer), 0);  // Bloque jusqu'à réception  
 // Pendant ce recv(), AUCUN autre client ne peut être servi
 ```
 

22-networking/03.1-select-poll.md

@@ -45,10 +45,10 @@ Les `fd_set` se manipulent exclusivement via quatre macros :
 ```cpp
 fd_set fds;
 
-FD_ZERO(&fds);          // Initialise l'ensemble à vide (obligatoire)
-FD_SET(fd, &fds);       // Ajoute fd à l'ensemble
-FD_CLR(fd, &fds);       // Retire fd de l'ensemble
-FD_ISSET(fd, &fds);     // Teste si fd est dans l'ensemble (après select)
+FD_ZERO(&fds);          // Initialise l'ensemble à vide (obligatoire)  
+FD_SET(fd, &fds);       // Ajoute fd à l'ensemble  
+FD_CLR(fd, &fds);       // Retire fd de l'ensemble  
+FD_ISSET(fd, &fds);     // Teste si fd est dans l'ensemble (après select)  
 ```
 
 > 🔥 **Piège critique** : `select` **modifie** les `fd_set` passés en paramètre. Après l'appel, seuls les descripteurs effectivement prêts restent dans l'ensemble. Il faut donc **reconstruire les ensembles à chaque itération** de la boucle événementielle.
@@ -218,12 +218,12 @@ La séparation `events` / `revents` est une amélioration majeure par rapport à
 ### Constantes d'événements
 
 ```cpp
-POLLIN      // Données disponibles en lecture
-POLLOUT     // Écriture possible sans blocage
-POLLPRI     // Données urgentes (out-of-band)
-POLLERR     // Erreur sur le descripteur    (revents uniquement)
-POLLHUP     // Déconnexion du pair          (revents uniquement)
-POLLNVAL    // Descripteur invalide          (revents uniquement)
+POLLIN      // Données disponibles en lecture  
+POLLOUT     // Écriture possible sans blocage  
+POLLPRI     // Données urgentes (out-of-band)  
+POLLERR     // Erreur sur le descripteur    (revents uniquement)  
+POLLHUP     // Déconnexion du pair          (revents uniquement)  
+POLLNVAL    // Descripteur invalide          (revents uniquement)  
 ```
 
 `POLLERR`, `POLLHUP` et `POLLNVAL` sont toujours surveillés implicitement — inutile de les spécifier dans `events`, ils apparaissent dans `revents` si la condition se produit.

22-networking/03.2-epoll.md

@@ -60,8 +60,8 @@ Crée une instance epoll et retourne un descripteur de fichier qui la représent
 Le seul flag utile est `EPOLL_CLOEXEC`, qui positionne le flag close-on-exec pour éviter que le descripteur soit hérité par des processus fils créés avec `exec`. C'est une bonne pratique systématique :
 
 ```cpp
-int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
-if (epoll_fd == -1) {
+int epoll_fd = epoll_create1(EPOLL_CLOEXEC);  
+if (epoll_fd == -1) {  
     std::print(stderr, "epoll_create1 : {}\n", strerror(errno));
     return 1;
 }
@@ -140,8 +140,8 @@ Commençons par le mode par défaut, level-triggered (LT), qui est le plus simpl
 #include <cstring>
 #include <print>
 
-constexpr int    max_events = 64;
-constexpr size_t buf_size   = 4096;
+constexpr int    max_events = 64;  
+constexpr size_t buf_size   = 4096;  
 
 bool set_nonblocking(int fd) {
     int flags = fcntl(fd, F_GETFL, 0);
@@ -286,10 +286,10 @@ Plusieurs points méritent d'être soulignés dans cet exemple :
 Le mode edge-triggered (ET) s'active en ajoutant le flag `EPOLLET` lors de l'enregistrement :
 
 ```cpp
-epoll_event ev{};
-ev.events  = EPOLLIN | EPOLLET;  // Edge-triggered
-ev.data.fd = client_fd;
-epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
+epoll_event ev{};  
+ev.events  = EPOLLIN | EPOLLET;  // Edge-triggered  
+ev.data.fd = client_fd;  
+epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);  
 ```
 
 En mode ET, le noyau ne vous notifie qu'**une seule fois** lors de la transition de « pas de données disponibles » à « données disponibles ». Si vous ne lisez pas toutes les données lors de cette notification, vous ne serez pas renotifié — même si des données restent dans le buffer — jusqu'à ce que de *nouvelles* données arrivent.
@@ -402,10 +402,10 @@ struct Connection {
 // À l'accept d'une nouvelle connexion :
 auto* conn = new Connection{.fd = client_fd};
 
-epoll_event ev{};
-ev.events  = EPOLLIN;
-ev.data.ptr = conn;  // Le noyau retournera ce pointeur tel quel
-epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
+epoll_event ev{};  
+ev.events  = EPOLLIN;  
+ev.data.ptr = conn;  // Le noyau retournera ce pointeur tel quel  
+epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);  
 
 // Dans la boucle événementielle :
 for (int i = 0; i < n; ++i) {
@@ -417,8 +417,8 @@ for (int i = 0; i < n; ++i) {
 }
 
 // À la déconnexion :
-close(conn->fd);
-delete conn;
+close(conn->fd);  
+delete conn;  
 ```
 
 > ⚠️ `data` est une **union** : `fd`, `ptr`, `u32` et `u64` partagent le même espace mémoire. Si vous utilisez `data.ptr`, vous ne pouvez pas simultanément lire `data.fd` — il faut stocker le descripteur dans votre structure `Connection`.

22-networking/03.3.1-architecture-sq-cq.md

@@ -211,9 +211,9 @@ Les SQ et CQ sont des **files circulaires** (ring buffers) basées sur deux comp
 Producteur : APPLICATION              Consommateur : NOYAU
 ────────────────────────              ────────────────────
 
-L'application écrit des               Le noyau lit les indices
-indices dans sq_array[tail]            depuis sq_array[head]
-puis incrémente tail.                  puis incrémente head.
+L'application écrit des               Le noyau lit les indices  
+indices dans sq_array[tail]            depuis sq_array[head]  
+puis incrémente tail.                  puis incrémente head.  
 
     head                tail
      │                   │
@@ -266,11 +266,11 @@ Ce protocole garantit que le consommateur ne lit jamais une entrée partiellemen
 unsigned idx = sq_tail & sq_mask;  // Masque = taille_ring - 1 (puissance de 2)
 
 // 2. Remplir le SQE
-sqe_array[idx].opcode    = IORING_OP_RECV;
-sqe_array[idx].fd        = client_fd;
-sqe_array[idx].addr      = reinterpret_cast<__u64>(buffer);
-sqe_array[idx].len       = buffer_size;
-sqe_array[idx].user_data = my_context_id;
+sqe_array[idx].opcode    = IORING_OP_RECV;  
+sqe_array[idx].fd        = client_fd;  
+sqe_array[idx].addr      = reinterpret_cast<__u64>(buffer);  
+sqe_array[idx].len       = buffer_size;  
+sqe_array[idx].user_data = my_context_id;  
 
 // 3. Publier l'index dans la SQ
 sq_array[sq_tail & sq_mask] = idx;
@@ -292,9 +292,9 @@ if (head == *cq_tail_ptr) {
 }
 
 // 3. Lire le CQE
-struct io_uring_cqe *cqe = &cq_array[head & cq_mask];
-uint64_t context = cqe->user_data;
-int32_t  result  = cqe->res;
+struct io_uring_cqe *cqe = &cq_array[head & cq_mask];  
+uint64_t context = cqe->user_data;  
+int32_t  result  = cqe->res;  
 
 // 4. Avancer head (consommer le CQE)
 io_uring_smp_store_release(cq_head_ptr, head + 1);
@@ -331,23 +331,23 @@ En pratique, dimensionnez la CQ suffisamment grande pour ne jamais déborder dan
 L'application prépare ses SQE, les pousse dans la SQ, puis appelle `io_uring_enter` pour notifier le noyau. C'est un appel système, mais un seul peut soumettre un lot arbitrairement grand de SQE — le coût est **amorti sur le nombre d'opérations**.
 
 ```
-App: préparer SQE[0], SQE[1], SQE[2]
-App: io_uring_enter(to_submit=3, min_complete=1)  ← 1 seul appel système
+App: préparer SQE[0], SQE[1], SQE[2]  
+App: io_uring_enter(to_submit=3, min_complete=1)  ← 1 seul appel système  
                                                       pour 3 opérations + attente
-Kernel: exécute les 3 opérations
-Kernel: dépose 2 CQE (2 sont terminées)
-App: récolte les 2 CQE
+Kernel: exécute les 3 opérations  
+Kernel: dépose 2 CQE (2 sont terminées)  
+App: récolte les 2 CQE  
 ```
 
 ### Mode SQPOLL : zéro appel système
 
 Avec le flag `IORING_SETUP_SQPOLL`, le noyau crée un **kernel thread dédié** qui scrute la SQ en permanence. L'application n'a qu'à écrire dans la SQ — pas besoin d'appeler `io_uring_enter` pour soumettre.
 
 ```
-App: préparer SQE[0]      ← simple écriture mémoire
-App: préparer SQE[1]      ← simple écriture mémoire
-Kernel thread: détecte les nouvelles SQE, les exécute
-App: récolte les CQE       ← simple lecture mémoire
+App: préparer SQE[0]      ← simple écriture mémoire  
+App: préparer SQE[1]      ← simple écriture mémoire  
+Kernel thread: détecte les nouvelles SQE, les exécute  
+App: récolte les CQE       ← simple lecture mémoire  
 ```
 
 Le kernel thread se met en veille après un délai d'inactivité configurable (`sq_thread_idle` dans `params`). Si l'application détecte que le thread dort (via un flag dans la SQ), elle doit appeler `io_uring_enter` pour le réveiller.
@@ -365,17 +365,17 @@ Le flag `IOSQE_IO_LINK` permet de créer des **chaînes de dépendances** entre
 Un cas d'usage classique : « lire depuis un fichier, puis envoyer sur un socket » :
 
 ```
-SQE[0]: IORING_OP_READ   (fichier → buffer)    flags = IOSQE_IO_LINK
-SQE[1]: IORING_OP_SEND   (buffer → socket)     flags = 0 (fin de chaîne)
+SQE[0]: IORING_OP_READ   (fichier → buffer)    flags = IOSQE_IO_LINK  
+SQE[1]: IORING_OP_SEND   (buffer → socket)     flags = 0 (fin de chaîne)  
 ```
 
 Si la lecture échoue, l'envoi n'est jamais tenté. Sans le chaînage, il faudrait attendre le CQE de la lecture, vérifier le résultat, puis soumettre l'envoi — ce qui double la latence.
 
 On peut aussi ajouter un **timeout** à une chaîne :
 
 ```
-SQE[0]: IORING_OP_RECV        flags = IOSQE_IO_LINK
-SQE[1]: IORING_OP_LINK_TIMEOUT (5 secondes)
+SQE[0]: IORING_OP_RECV        flags = IOSQE_IO_LINK  
+SQE[1]: IORING_OP_LINK_TIMEOUT (5 secondes)  
 ```
 
 Si le `recv` ne se termine pas dans les 5 secondes, il est annulé. Ce pattern remplace les timers manuels courants avec `epoll`.

22-networking/03.3.2-liburing.md

@@ -24,8 +24,8 @@ Ce que liburing gère pour vous :
 
 ```bash
 # Ubuntu 22.04+
-sudo apt update
-sudo apt install liburing-dev
+sudo apt update  
+sudo apt install liburing-dev  
 ```
 
 Le paquet installe les headers (`<liburing.h>`) et la librairie statique/dynamique. Vérifiez la version installée :
@@ -41,37 +41,37 @@ Sur Ubuntu 24.04 LTS, le paquet fournit liburing 2.5+, ce qui est suffisant pour
 Pour accéder aux toutes dernières fonctionnalités (notamment le support des opcodes récents) :
 
 ```bash
-git clone https://github.com/axboe/liburing.git
-cd liburing
+git clone https://github.com/axboe/liburing.git  
+cd liburing  
 ./configure --prefix=/usr/local
-make -j$(nproc)
-sudo make install
+make -j$(nproc)  
+sudo make install  
 ```
 
 ### Intégration CMake
 
 ```cmake
 # Recherche du paquet système
-find_package(PkgConfig REQUIRED)
-pkg_check_modules(URING REQUIRED liburing)
+find_package(PkgConfig REQUIRED)  
+pkg_check_modules(URING REQUIRED liburing)  
 
-add_executable(my_server main.cpp)
-target_link_libraries(my_server PRIVATE ${URING_LIBRARIES})
-target_include_directories(my_server PRIVATE ${URING_INCLUDE_DIRS})
+add_executable(my_server main.cpp)  
+target_link_libraries(my_server PRIVATE ${URING_LIBRARIES})  
+target_include_directories(my_server PRIVATE ${URING_INCLUDE_DIRS})  
 ```
 
 Alternative minimaliste si liburing est installée dans un chemin standard :
 
 ```cmake
-add_executable(my_server main.cpp)
-target_link_libraries(my_server PRIVATE uring)
+add_executable(my_server main.cpp)  
+target_link_libraries(my_server PRIVATE uring)  
 ```
 
 ### Avec FetchContent (sans dépendance système)
 
 ```cmake
-include(FetchContent)
-FetchContent_Declare(
+include(FetchContent)  
+FetchContent_Declare(  
     liburing
     GIT_REPOSITORY https://github.com/axboe/liburing.git
     GIT_TAG        liburing-2.7  # Adapter à la version souhaitée
@@ -280,9 +280,9 @@ int get_fd(uint64_t user_data) {
 
 // ── Buffers de lecture (un par connexion possible) ──
 // Simplification : tableau statique indicé par fd.
-constexpr int    max_conns = 4096;
-constexpr size_t buf_size  = 4096;
-char buffers[max_conns][buf_size];
+constexpr int    max_conns = 4096;  
+constexpr size_t buf_size  = 4096;  
+char buffers[max_conns][buf_size];  
 
 // ── Helpers pour préparer les opérations ──
 
@@ -546,8 +546,8 @@ Les fonctions liburing suivent deux conventions selon la catégorie :
 
 ```cpp
 // Convention liburing : le code d'erreur est dans la valeur de retour
-int ret = io_uring_submit(&ring);
-if (ret < 0) {
+int ret = io_uring_submit(&ring);  
+if (ret < 0) {  
     std::print(stderr, "submit : {}\n", strerror(-ret));  // Notez le -ret
 }
 
@@ -560,8 +560,8 @@ if (cqe->res < 0) {
 **`io_uring_get_sqe`** retourne `nullptr` si la SQ est pleine. Ce cas peut survenir si vous préparez plus de SQE que la taille de la SQ sans soumettre entre-temps. La réponse est soit d'augmenter la taille du ring, soit de soumettre plus fréquemment :
 
 ```cpp
-io_uring_sqe *sqe = io_uring_get_sqe(&ring);
-if (!sqe) {
+io_uring_sqe *sqe = io_uring_get_sqe(&ring);  
+if (!sqe) {  
     // SQ pleine : soumettre les SQE en attente pour libérer de la place
     io_uring_submit(&ring);
     sqe = io_uring_get_sqe(&ring);
@@ -607,8 +607,8 @@ liburing est une bibliothèque C. En C++ idiomatique, on souhaite une gestion RA
 #include <cstring>
 #include <utility>
 
-class IoUring {
-public:
+class IoUring {  
+public:  
     explicit IoUring(unsigned entries, unsigned flags = 0) {
         if (int ret = io_uring_queue_init(entries, &ring_, flags); ret < 0) {
             throw std::runtime_error{

22-networking/03.3.3-cas-usage.md

@@ -325,8 +325,8 @@ void prep_timeout(io_uring* ring, __kernel_timespec* ts, unsigned count) {
 
 // Usage :
 __kernel_timespec ts{.tv_sec = 5, .tv_nsec = 0};
-prep_timeout(&ring, &ts, 0);  // count=0 : ne pas compter les CQE, juste le temps
-io_uring_submit(&ring);
+prep_timeout(&ring, &ts, 0);  // count=0 : ne pas compter les CQE, juste le temps  
+io_uring_submit(&ring);  
 
 // Le CQE du timeout aura res == -ETIME si le délai a expiré,
 // ou res == 0 si le count a été atteint avant.
@@ -445,8 +445,8 @@ uint64_t encode(OpType type, Request* req) {
            (reinterpret_cast<uint64_t>(req) & 0x00FFFFFFFFFFFFFF);
 }
 
-OpType   get_type(uint64_t ud) { return static_cast<OpType>(ud >> 56); }
-Request* get_req(uint64_t ud) {
+OpType   get_type(uint64_t ud) { return static_cast<OpType>(ud >> 56); }  
+Request* get_req(uint64_t ud) {  
     uint64_t addr = ud & 0x00FFFFFFFFFFFFFF;
     return reinterpret_cast<Request*>(addr);
 }

22-networking/exemples/README.md

@@ -108,8 +108,8 @@ io_uring cleanup OK
 - **Execution** : `./ex03_iouring_file /etc/hostname`
 - **Sortie attendue** :
 ```
-Soumission de 1 lectures asynchrones (N octets)
-Lecture terminee : N octets lus, 0 erreurs
+Soumission de 1 lectures asynchrones (N octets)  
+Lecture terminee : N octets lus, 0 erreurs  
 ```
 - **Prerequis** : `sudo apt install liburing-dev`