ArtFX - Parallelism and GE
La plupart du temps, les exercices de programmation système restent simples : un compteur partagé, deux threads, un mutex. Ça démontre le mécanisme. Ça prépare mal à ce qui casse vraiment une fois le programme en production. Pour le TP de programmation système à ARTFX, année 2026–2027, on a voulu autre chose : une vraie problématique d’ingénierie. Le programme sur lequel les étudiants travaillent est un spooler d’impression.
Imprimer n’est pas écrire sur un périphérique
Entre la demande et la marque sur le papier, il y a une file, des conversions de format, et une machine qui ne traite qu’un travail à la fois. Le composant qui organise cette attente est le spooler. Sous Unix, c’est CUPS.
Trois propriétés de ce service suffisent à poser le problème de synchronisation.
La file est partagée. Plusieurs clients déposent, plusieurs imprimantes retirent. Deux dépôts qui se croisent ne doivent pas faire disparaître un travail.
La soumission doit rester brève. L’impression est longue et exclusive. On ne bloque pas celui qui envoie un document le temps que le papier sorte.
Le périphérique est une ressource à un seul jeton. Une imprimante n’imprime qu’un travail. Devant elle, la file a une taille de 1, et une machine à états dit si ce jeton est pris, rendu ou gelé : arrêt, marche, impression, suspension.
CUPS réel isole en général chaque filtre dans un processus, relié aux autres par des tubes. Un filtre qui échoue n’écrit pas dans la mémoire du planificateur. Ici, le TP regarde l’autre côté. server, client et printer restent trois processus distincts et ne communiquent que par sockets. À l’intérieur du serveur, les étages de la file sont des threads du même processus. Ils voient le même tampon. C’est pour cela qu’il faut une synchronisation, et non un fork par étage.
Le squelette montre le métier. Il ne le protège pas.
Le code métier est déjà en place : le réseau, les clients, la file de travaux, la machine à états de l’imprimante. La synchronisation en a été retirée.
Dans cet état, le serveur traite un client à la fois, dans le thread qui vient d’accepter la connexion. L’imprimante distante bloque l’écoute le temps d’envoyer un fichier. Le tampon partagé n’a ni mutex ni sémaphore.
Le comportement séquentiel est volontaire. Il montre ce que le service fait. Le travail des étudiants est de le remplacer par le modèle concurrent, pas de laisser l’appel direct à run() à côté des threads.
Les outils imposés sont ceux du cours : pthread_create, pthread_join, pthread_cancel, pthread_mutex_t, sem_t. Pas d’attente active. Pas de std::thread, de std::mutex ni de std::condition_variable dans le module de synchronisation, donc pas trop d'abstraction.
Ce qui casse, une fois que plusieurs fils tournent
Quatre fils se partagent le serveur. Le fil principal ne fait qu’une chose : boucler sur accept. Chaque connexion continue ailleurs. Un fil par client lit la requête puis dépose le travail. Un fil par imprimante retire puis imprime. Un répartiteur passe la main.
User::run ne revient qu’à la déconnexion. Si start() appelle encore run() dans le fil qui vient de faire accept, ce fil reste dans le premier client. Personne ne revient à accept. pthread_create coupe cet enchaînement : l’appel rend la main tout de suite, Spooler::run peut accepter le client suivant, et User::run continue sur le fil nouveau. Joindre ce fil juste après l’avoir créé produit le même blocage. Joindre, c’est attendre la fin. On ne joint un utilisateur qu’une fois le client parti. Les boucles de l’imprimante et du répartiteur, elles, ne reviennent pas.
used++ n’est pas une action indivisible. Lire, augmenter, réécrire. Si deux dépôts lisent la même valeur, tous deux réécrivent le même résultat. Deux travaux entrent, le compteur reste à 1. C’est une course. Une variable booléenne testée dans une boucle ne la ferme pas : le test et l’écriture ne sont pas atomiques, et la boucle occupe un cœur pour ne rien calculer.
Le tampon est protégé par un sémaphore initialisé à 1. Un autre, initialisé à 0, compte les éléments qu’un consommateur a le droit de retirer. On attend cet événement sans tenir le verrou du tampon. On prend le verrou, on lit, on le rend, et seulement alors on passe la main. Attendre l’élément en tenant le tampon bloque le producteur qui doit prendre le même tampon pour déposer. Deux ressources, le verrou et le jeton, prises dans deux ordres : un interblocage.
Le répartiteur a le même genre de piège au démarrage. Un fil qui commence par sem_wait sur un sémaphore nul reste bloqué tant que personne n’a publié. Il faut donc un rendez-vous initial : réveiller le processus qui vient de s’enregistrer, et réveiller le premier producteur et le premier consommateur s’ils existent déjà. Sans cela, la synchronisation est correcte et le système ne démarre pas.
Ce qu’on demande de voir tourner
Quatre essais suffisent à dire si le service tient.
- L’imprimante distante sert deux clients lancés en même temps. Le second ne doit pas attendre que le premier ait fini de recevoir son fichier.
- Le serveur accepte un second client pendant que le premier est encore connecté. La boucle d’acceptation n’est plus dans User::run.
- Un travail déposé par un utilisateur est retiré par le thread de l’imprimante, sans lecture d’un tampon vide et sans course sur used.
- Quand un client se déconnecte, son retrait de la liste des producteurs ne corrompt pas l’indice du producteur courant.
Le quota, les filtres de document, les backends USB ou IPP : le sujet les nomme, parce que c’est le métier d’un spooler. Le squelette du TP n’en demande pas l’écriture. Le cœur à remettre en place est le tampon multi-producteurs, multi-consommateurs, les listes sous mutex, les attentes sous sémaphore.
Un exercice de threads peut tenir en quelques fichiers. Le problème, lui, est celui d’un service qui accepte, range, choisit une imprimante et n’imprime qu’un travail à la fois.