Le processeur compte en nanosecondes, le disque et le réseau en millisecondes. Quand le programme attend, c'est souvent une entrée-sortie qu'il attend.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : avancé · 🏅 Badge : Plombier des entrées-sorties
🎬 L'histoire
L'export des factures de HashBox écrit 200 000 lignes dans un fichier. Il prend 38 secondes sur le serveur de production, alors que la même opération dure 0,4 s sur l'ordinateur de Kodi. Après enquête, Sam trouve la cause : le code appelle flush() après chaque ligne, et le serveur de production utilise un disque réseau où chaque vidage coûte 0,2 ms.
« 200 000 vidages × 0,2 ms, ça fait 40 secondes, dit Sam. Le calcul ne coûtait rien. Ce qui coûtait, c'était d'aller voir le disque 200 000 fois au lieu de une. En entrée-sortie, on gagne en regroupant : moins d'appels, plus gros, plus séquentiels. »
Tu apprends comment un programme parle au disque (tampons, appels système, page cache), pourquoi regrouper et lire séquentiellement, et quels formats et compressions rendent le stockage plus efficace.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer la hiérarchie tampon / cache de pages / disque et le coût d'un appel système
- regrouper lectures et écritures pour réduire le nombre d'appels
- comparer accès séquentiel et aléatoire, tailles de blocs
- comparer formats de sérialisation (texte, binaire) et compression en taille et en temps
- savoir quand utiliser
mmap,fsyncet des écritures atomiques
🧩 Défi d'échauffement (5 XP)
Tu dois déplacer 10 000 briques d'un tas à un autre, à 50 m de distance. Tu peux en porter 1 à la fois, ou 50 avec une brouette. Le trajet coûte plus que le chargement. Calcule le nombre de trajets dans chaque cas. Si en plus on te demande de signer un reçu à chaque trajet, où est la vraie perte de temps ?
💡 Le concept
La pile des entrées-sorties
flowchart TB
A["Ton code : f.write(...)"] --> B["Tampon du langage (Python)"]
B --> C["Appel système : write()"]
C --> D["Cache de pages du noyau (RAM)"]
D --> E["Pilote et contrôleur"]
E --> F["Disque (SSD / HDD / réseau)"]
Description du schéma : une écriture traverse le tampon du langage, un appel système, le cache de pages du noyau (en mémoire vive), puis le pilote et enfin le disque physique.
- Le tampon regroupe plusieurs petites écritures en une grosse.
- L'appel système (
read,write) coûte ~0,2 à 2 µs à lui seul (bascule en mode noyau). - Le cache de pages garde en mémoire les fichiers récemment lus ou écrits : une relecture est quasi instantanée.
flush()vide le tampon Python vers le noyau ;os.fsync()force le noyau à écrire sur le disque (coûteux, mais nécessaire pour la durabilité).
Le coût d'une opération
| Opération | Ordre de grandeur |
|---|---|
| Appel système | ~1 µs |
| Lecture dans le cache de pages | ~1 µs par Ko |
| Lecture aléatoire SSD | ~100 µs |
fsync sur SSD | ~1 ms |
| Lecture aléatoire disque dur | ~10 ms |
Les règles d'or
- Moins d'appels, plus gros : regrouper (batching). 1 écriture de 1 Mo vaut mieux que 1 000 000 d'écritures de 1 octet.
- Séquentiel plutôt qu'aléatoire : surtout sur disque dur ; sur SSD aussi (lecture anticipée, blocs).
- Taille de bloc adaptée : 64 Ko à 1 Mo pour des lectures de flux (pas 1 octet, pas 1 Go).
- Éviter de relire : garder en mémoire ce qui sert plusieurs fois.
- Ne flusher/fsyncer que si nécessaire (durabilité) et le faire par lot.
- Écrire de façon atomique : écrire dans un fichier temporaire,
fsync, puis renommer (os.replace) : un lecteur voit l'ancien fichier ou le nouveau, jamais un fichier à moitié écrit.
Formats de stockage
| Format | Lisible ? | Taille | Vitesse | Usage |
|---|---|---|---|---|
| CSV / texte | oui | grande | moyenne | échange, débogage |
| JSON | oui | grande (noms répétés) | moyenne | API, configuration |
Binaire structuré (struct, MessagePack, Protocol Buffers) | non | petite | rapide | échanges internes, grandes quantités |
| Colonnaire (Parquet) | non | très petite | rapide pour l'analyse | analyses, entrepôts |
| SQLite / base |
Compression
Compresser réduit la taille (donc le temps de lecture disque/réseau) mais coûte du CPU. Selon le débit du support :
| Algorithme | Rapport | Vitesse |
|---|---|---|
zlib / gzip niveau 1 | moyen | rapide |
zlib niveau 9 | meilleur | lent |
lzma | très bon | très lent |
| zstd, lz4 (hors bibliothèque standard) | bon / moyen | très rapide |
Pour des données très redondantes (texte, JSON, journaux), le gain est de ×5 à ×20. Pour des données déjà compressées (images, vidéos), pas de gain.
Projection en mémoire : mmap
mmap associe un fichier à l'espace d'adressage : on le lit comme un tableau d'octets, le système charge les pages à la demande. Utile pour de grandes recherches en lecture sans copies, ou pour partager des données entre processus.
Durabilité et cohérence
- Écriture atomique (fichier temporaire + renommage) ;
- Journal d'écriture (write-ahead log) : consigner l'opération avant de l'appliquer, pour pouvoir la rejouer après une panne (c'est ce que font les bases de données, HEF-070) ;
fsyncdu fichier et du dossier pour garantir qu'un renommage survit à une coupure de courant.
🧠 Astuce : pour trouver un problème d'E/S, compte les appels système (
strace -csous Linux) : un nombre énorme d'appels minuscules est le signe d'un manque de regroupement.
🔍 Exemple pas à pas
Problème : compter les écritures réelles avec un fichier instrumenté, montrer l'effet du regroupement, comparer des tailles de blocs, des formats et des compressions, et écrire un fichier de façon atomique.
import io, json, os, struct, tempfile, time, zlib
# ---------------- un fichier qui compte les écritures « système » ----------------
class FichierCompteur(io.RawIOBase):
def __init__(self, chemin):
self.f = open(chemin, "wb", buffering=0) # non tamponné : chaque write() est un appel système
self.appels, self.octets = 0, 0
def writable(self): return True
def write(self, donnees):
self.appels += 1; self.octets += len(donnees)
return self.f.write(donnees)
def close(self): self.f.close(); super().close()
LIGNES = [f"{i};m{i % 800};HEF-{i % 90:03d};{(i * 37) % 200}\n" for i in range(20000)]
tempfile.TemporaryDirectory() d:
brut = FichierCompteur(os.path.join(d, ))
l LIGNES: brut.write(l.encode())
brut.close()
brut2 = FichierCompteur(os.path.join(d, ))
tampon = io.BufferedWriter(brut2, buffer_size= * )
l LIGNES: tampon.write(l.encode())
tampon.close()
()
brut.appels == brut2.appels < brut.octets == brut2.octets
(os.path.join(d, ), ).read() == (os.path.join(d, ), ).read()
():
(chemin, ) f:
l LIGNES:
f.write(l); f.flush()
():
(chemin, ) f:
f.write(.join(LIGNES))
():
t = ()
_ (n):
d0 = time.perf_counter(); f(chemin); t = (t, time.perf_counter() - d0)
t
t_flush, t_groupe = meilleur(ecrire_flush, os.path.join(d, )), meilleur(ecrire_groupe, os.path.join(d, ))
()
t_flush > * t_groupe
chemin = os.path.join(d, )
taille (, , , ):
n =
(chemin, , buffering=) f:
f.read(taille):
n +=
taille == n > :
total = os.path.getsize(chemin)
()
enregistrements = [{: , : , : (i * ) % } i ()]
en_json = json.dumps(enregistrements).encode()
en_csv = .join( e enregistrements).encode()
en_binaire = .join(struct.pack(, (e[][:]), (e[][:]), e[]) e enregistrements)
nom, donnees ((, en_json), (, en_csv), (, en_binaire)):
z1, z9 = zlib.compress(donnees, ), zlib.compress(donnees, )
()
(en_binaire) < (en_csv) < (en_json)
(zlib.compress(en_json, )) < (en_json) /
():
temporaire = chemin +
(temporaire, ) f:
f.write(texte); f.flush(); os.fsync(f.fileno())
os.replace(temporaire, chemin)
cible = os.path.join(d, )
ecrire_atomique(cible, )
ecrire_atomique(cible, )
json.load((cible)) == {: } os.path.exists(cible + )
()
Lecture :
- Sans tampon : 20 000 appels système pour 20 000 lignes. Avec un tampon de 64 Ko : moins de 100 appels, même contenu octet pour octet.
- Flusher à chaque ligne est plusieurs fois plus lent que d'écrire en un bloc, même sur un disque local rapide ; sur un disque réseau, l'écart se compte en dizaines de fois.
- Plus la taille de bloc est petite, plus le nombre de lectures explose (1 octet par lecture → des centaines de milliers d'appels).
- Format : le binaire est le plus compact, puis CSV, puis JSON (noms répétés). La compression
zlibréduit le JSON de plus de cinq fois : les données répétitives se compressent très bien. - L'écriture atomique (fichier temporaire,
fsync,os.replace) garantit qu'un lecteur ne voit jamais un état partiel.
✍️ À toi, avec aide (10 XP)
Mesure l'effet de la taille du tampon de lecture sur la lecture d'un fichier de 20 Mo, pour des tailles de 1 Ko, 16 Ko, 256 Ko, 4 Mo. Compte le nombre d'appels read (fichier non tamponné + compteur) et le temps. Quelle taille choisirais-tu, et pourquoi ne pas simplement prendre la plus grande ?
💡 Indice 1
Ouvre avec open(chemin, 'rb', buffering=0) et compte tes propres appels à read(taille).
💡 Indice 2
Génère le fichier avec des octets pseudo-aléatoires de graine fixée.
💡 Indice 3
Au-delà d'une certaine taille, le gain est nul.
✅ Réponse
import os, random, tempfile, time
with tempfile.TemporaryDirectory() as d:
chemin = os.path.join(d, "donnees.bin")
rng = random.Random(1)
with open(chemin, "wb") as f:
for _ in range(20):
f.write(rng.randbytes(1024 * 1024))
for taille in (1024, 16 * 1024, 256 * 1024, 4 * 1024 * 1024):
meilleur, appels = float("inf"), 0
for _ in range(3):
appels = 0; debut = time.perf_counter()
with open(chemin, "rb", buffering=0) as f:
while f.read(taille):
appels += 1
meilleur = min(meilleur, time.perf_counter() - debut)
print(f"bloc {taille // 1024:5d} Ko : {appels:6d} lectures, ms")
🚀 À toi, en solo (20 XP)
Un petit journal d'écritures (write-ahead log) durable. Implémente JournalDurable :
ajouter(enregistrement)écrit une ligne JSON avec somme de contrôle (CRC32) ;- écritures groupées :
fsyncseulement tous les N enregistrements ou àvalider()(compromis latence/durabilité) ; relire()renvoie les enregistrements valides et s'arrête au premier enregistrement corrompu ou incomplet (cas d'une coupure en cours d'écriture) ;- simule une coupure en tronquant le fichier au milieu de la dernière ligne, et vérifie que
relire()renvoie tout sauf la dernière ; - compte les
fsyncpour 10 000 enregistrements avec N = 1, 100, 1000 et conclus sur le compromis.
✅ Pistes de correction
import json, os, tempfile, zlib
class JournalDurable:
def __init__(self, chemin, fsync_tous_les=100):
self.chemin, self.n_fsync, self.fsyncs, self.en_attente = chemin, fsync_tous_les, 0, 0
self.f = open(chemin, "ab")
def _synchroniser(self):
self.f.flush(); os.fsync(self.f.fileno()); self.fsyncs += 1; self.en_attente = 0
def ajouter(self, enregistrement):
corps = json.dumps(enregistrement, sort_keys=True)
self.f.write(f"{zlib.crc32(corps.encode()):08x} {corps}\n".encode())
self.en_attente += 1
if self.en_attente >= self.n_fsync:
self._synchroniser()
def valider(self):
.en_attente:
._synchroniser()
():
.valider(); .f.close()
():
valides = []
(chemin, ) f:
ligne f:
:
texte = ligne.decode()
texte.endswith():
crc, corps = texte[:-].split(, )
(crc, ) != zlib.crc32(corps.encode()):
valides.append(json.loads(corps))
(ValueError, UnicodeDecodeError):
valides
tempfile.TemporaryDirectory() d:
chemin = os.path.join(d, )
j = JournalDurable(chemin, fsync_tous_les=)
i (): j.ajouter({: i, : })
j.fermer()
[r[] r relire(chemin)] == (())
taille = os.path.getsize(chemin)
(chemin, ) f:
f.truncate(taille - )
reste = relire(chemin)
(, (reste), )
[r[] r reste] == (())
n (, , ):
j = JournalDurable(os.path.join(d, ), fsync_tous_les=n)
i (): j.ajouter({: i})
j.fermer()
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
flush() ou fsync() à chaque ligne | Des milliers d'appels coûteux | Regrouper ; synchroniser par lot |
| Lire octet par octet | Appels système en masse | Blocs de 64 Ko à 1 Mo, tampon |
| Écrire un fichier en place | Lecteur voyant un état partiel, perte en cas de panne | Fichier temporaire + fsync + os.replace |
| Format texte verbeux pour de gros volumes | Taille, temps de lecture et d'analyse | Binaire ou colonnaire, compression adaptée |
🐉 Mini-boss (40 XP)
Optimiser l'export des factures. Écris un exporteur lent (200 000 factures, une ligne JSON par facture, flush à chaque ligne, lecture octet par octet pour recompter), puis améliore-le en 5 étapes mesurées :
- écriture groupée avec tampon ;
- format plus compact (CSV ou binaire) ;
- compression adaptée (justifie le niveau) ;
- écriture atomique du fichier final ;
- lecture par blocs et projection
mmappour retrouver une facture par son numéro grâce à un index d'offsets.
Pour chaque étape : appels système comptés, taille, temps (meilleur de 5), facteur cumulé. Termine par un test de relecture complète prouvant que les données sont identiques et une conclusion sur ce qui compte le plus (nombre d'appels, taille, format).
✅ Pistes de correction
Un bon travail : fichier instrumenté pour compter les appels, tableau final avec des gains cumulés (nombre d'appels divisé par plus de 1000, taille divisée par 5 à 10 avec binaire + zlib), index d'offsets (liste d'int) et mmap pour accéder à la facture n en O(1) sans lire le reste. La conclusion attendue : le facteur dominant est le nombre d'opérations d'E/S, puis la taille des données, puis le format.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour accélérer l'écriture d'un gros volume de lignes, on :
- A. appelle flush après chaque ligne
- B. écrit octet par octet
- C. regroupe les écritures dans un tampon
2. Une écriture atomique de fichier se fait en :
- A. écrivant dans un fichier temporaire puis en le renommant
- B. écrivant directement sur place
- C. désactivant le disque
3. Compresser des données :
- A. est toujours plus rapide
- B. réduit la taille mais coûte du CPU
- C. n'a jamais d'intérêt
4. 🔁 Révision mission 04 : Pour traiter un fichier plus gros que la mémoire, on utilise :
- A. une liste de toutes les lignes
- B. un second écran
- C. un flux ou un générateur, ligne par ligne
5. 🔁 Révision mission 04 : Une fuite mémoire en Python correspond le plus souvent à :
- A. des objets encore référencés (cache, historique) qu'on n'utilise plus
- B. un manque de RAM sur la machine
- C. une erreur de syntaxe
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Dans ton code, où écris-tu ou lis-tu en petites quantités un grand nombre de fois ?
- Quelle donnée critique de ton application pourrait être perdue en cas de coupure de courant maintenant ?
🎒 À retenir
- Tampon → appel système → cache de pages → disque.
- Moins d'appels, plus gros, plus séquentiels.
flush(vers le noyau) contrefsync(vers le disque) : à utiliser par lot.- Formats binaires et compression : taille contre CPU.
- Écriture atomique et journal avec somme de contrôle pour la durabilité.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Plombier des entrées-sorties
← Mission 04 — Mémoire et allocations · Mission 06 — Réseau et latence →
HEF-130 — Performance

