Linus Torvalds développe des correctifs du noyau avec Claude Code et triple les performances

Une vraie expérience noyau, pas un slogan

Le sujet est précis: Linus Torvalds a utilisé Claude Code dans une expérience de performance du noyau Linux, d’abord sous la forme d’une branche expérimentale de huit correctifs visant la scalabilité des lectures depuis le cache de pages, avec un gain d’environ 3x dans un benchmark spécifique sur ordinateur portable [1]. Cette branche, nommée noref-filemap-read-with-llm, s’attaquait à un goulet d’étranglement étroit mais réel: lorsque plusieurs threads lisent de très petites portions du même fichier déjà en cache, ils peuvent tous se retrouver à se battre sur la même ligne de cache liée au compteur de références d’un folio [1].

Cette nuance est essentielle. Il ne s’agit pas de dire que “Linux est trois fois plus rapide” de manière générale. Le test initial était un cas de stress concentré: huit threads lisaient de façon répétée le même petit fichier en cache, et l’ancien chemin devait prendre puis relâcher des références de folio à chaque passage [1]. Dans ce scénario, le débit serait passé d’environ 10 millions de lectures par seconde à 31–33 millions, tandis que le coût en cycles noyau par lecture chutait d’environ 2 950 à environ 720–725 [1].

L’affaire est aussi importante à cause de son auteur. Torvalds n’est pas un développeur quelconque qui teste un assistant de codage; il est le créateur et mainteneur principal du noyau Linux. Le premier compte rendu indiquait que le code, les tests, les notes de revue et la première version du texte avaient été produits avec Claude Code sous sa direction, tandis que les mesures avaient été exécutées sur sa propre machine [1]. Autrement dit, ce n’est pas “l’IA remplace le mainteneur”. C’est plutôt “le mainteneur définit le problème, dirige l’outil, mesure le résultat et expose les risques non résolus”.

De huit correctifs à une branche rcu-free-v3 de dix correctifs

L’état actuel est plus subtil que les premiers articles. Le 13 octobre, Torvalds a décrit dans son arbre public une nouvelle branche rcu-free-v3, devenue selon lui une “assez courte série de dix correctifs” [2]. Il a expliqué que ce travail faisait suite à plusieurs tentatives antérieures d’améliorer la scalabilité de la gestion des références de pages autour des appels normaux read() et pread(), y compris des approches plus anciennes finalement jugées cassées ou incomplètes [2].

L’idée révisée consiste à repérer les folios “chauds”, à différer leur libération jusqu’après une période de grâce RCU, puis à étendre la zone protégée par RCU au-delà de la simple recherche pour couvrir l’accès réel aux données, à condition que la copie vers l’espace utilisateur ne provoque pas de faute de page [2]. L’objectif est d’éviter la prise de référence sur le folio dans le chemin rapide. Si l’entrée du cache de pages reste sûre à lire pendant cette fenêtre RCU, le code peut se passer des écritures partagées sur le compteur de références qui provoquaient le mur de scalabilité [2].

Torvalds s’est montré prudent dans l’interprétation du chiffre le plus spectaculaire. Dans le même message, il a rapporté une amélioration de 23x sur son Ryzen Threadripper: dans un benchmark synthétique à 64 threads, le débit passait de 13,3 millions à 304 millions de lectures par seconde, et le coût par lecture tombait de près de 20 000 cycles à environ 735–736 [2]. Mais il a aussi souligné que ce test était très artificiel, car il relisait sans cesse la même petite portion d’une page sur tous les CPU, de sorte que l’impact réel serait “beaucoup, beaucoup” plus faible [2].

Cette réserve est la phrase la plus importante de toute l’histoire des performances. Le gain de 3x sur portable est déjà propre à une charge particulière, et le 23x sur Threadripper l’est encore davantage. Ces chiffres prouvent que l’ancien chemin de comptage de références peut devenir un sérieux limiteur sous contention extrême. Ils ne prouvent pas que les postes de travail, serveurs, bases de données ou fermes de compilation verront un gain proportionnel.

Pourquoi les références du cache de pages sont difficiles

Le cache de pages est l’un des sous-systèmes les plus sensibles aux performances dans Linux. Il garde en mémoire les données de fichiers récemment utilisées afin d’éviter des accès plus lents au stockage. Mais la correction ne laisse presque aucune marge d’erreur: le noyau ne doit jamais permettre à un lecteur d’accéder à une mémoire récupérée, remplacée, tronquée ou réutilisée.

Le comptage de références traditionnel donne une règle de sécurité claire. Un lecteur prend une référence sur le folio, l’utilise, puis relâche la référence. Le coût est que ces opérations sont des écritures atomiques sur un état partagé. Sous forte contention multithread, les données peuvent déjà être chaudes en cache, mais le compteur de références devient l’embouteillage.

La série assistée par Claude est intéressante parce qu’elle attaque directement cet embouteillage. Au lieu de rendre le compteur de références moins coûteux, elle tente de ne pas y toucher dans le chemin rapide. Le mécanisme utilisé est RCU, pour Read-Copy-Update, une technique de synchronisation du noyau qui permet aux lecteurs d’avancer pendant que la libération est différée jusqu’à ce que les lecteurs susceptibles d’avoir vu l’ancien objet aient terminé. Dans la description récente de Torvalds, la branche diffère la libération des données du folio, puis lit ces données dans une région protégée par RCU [2].

C’est aussi ce qui rend le travail risqué. Dès qu’un correctif de performance modifie les règles de durée de vie des objets, la communauté noyau pose une question brutale: quel entrelacement exact peut casser ce raisonnement? Les lectures du cache de pages interagissent avec la troncature, le hole punching, la récupération mémoire, les fautes de page, le comportement des systèmes de fichiers et la taille logique du fichier. Une seule opération ordonnée au mauvais moment peut transformer une optimisation en fuite de données ou en corruption.

La revue a trouvé une course avant l’intégration

Les éléments récents montrent que le processus du noyau fonctionne comme prévu. LWN a résumé la série comme la première série de correctifs de Torvalds assistée par LLM et a noté qu’une condition de concurrence avait déjà été identifiée en revue, ce qui imposait un travail supplémentaire [3]. Ce point doit tempérer le récit selon lequel “l’IA a écrit une optimisation du noyau”. La série n’est pas entrée tranquillement dans la branche principale; elle est soumise à la même culture de revue adversariale que tout changement risqué de gestion mémoire.

La course a été discutée directement sur la liste du noyau. Kiryl Shutsemau a décrit un problème dans filemap_read_rcu_batch(): si un folio est remplacé puis que i_size est agrandi, le chemin de lecture pourrait renvoyer des données qui n’ont jamais été écrites à cet emplacement [5]. Torvalds a suggéré d’avancer la vérification de la taille du fichier et de consolider les tests de validité; Shutsemau a répondu que l’approche était possible et a inclus un ajustement de correctif [5].

Cet échange est le vrai signal. L’assistance IA a peut-être aidé à produire du code, des tests et de la documentation, mais des mainteneurs humains ont encore trouvé un danger de concurrence. Le modèle de revue du noyau n’est pas devenu obsolète; il reste le filet de sécurité qui décide si un code assisté par IA est utile ou dangereux.

Les mainteneurs débattent de la conception, pas seulement de l’outil

Le désaccord technique ne se limite pas à la condition de concurrence. Matthew Wilcox a jugé les chiffres convaincants, mais a critiqué le nouveau drapeau PG_rcu_free, en suggérant qu’un type de page pourrait être plus approprié et en soulevant des questions sur la manière dont les folios du cache de pages devraient passer par les états de récupération après une période RCU [4]. Shutsemau a ensuite proposé de limiter le drapeau aux systèmes 64 bits, où la rareté des bits de drapeau est moins problématique [5].

Ces objections ne sont pas cosmétiques. La conception de la gestion mémoire du noyau consiste souvent à arbitrer entre vitesse, correction, contraintes d’architecture et maintenabilité. Un nouveau drapeau peut résoudre le problème immédiat tout en consommant un espace de métadonnées rare ou en compliquant le comportement sur certains systèmes. Une approche fondée sur un type de page ou sur la liste inactive peut être plus propre sous un angle et plus délicate sous un autre. Le fait que les mainteneurs débattent à ce niveau montre que la série reste un travail de conception, pas un produit fini.

Cela clarifie aussi le rôle de Claude Code. L’assistant a pu accélérer l’exploration et produire un prototype cohérent, mais le débat porte sur des invariants: quand un folio peut être mappé, quand il peut être libéré, quelles barrières mémoire suffisent et quelles architectures doivent participer. Ces questions exigent une connaissance profonde du sous-système et un jugement conservateur.

Ce que l’expérience prouve vraiment

L’expérience prouve trois choses, pas davantage.

Premièrement, le codage assisté par IA peut désormais participer à un vrai travail de programmation système lorsqu’il est dirigé par quelqu’un qui comprend le sous-système. Torvalds a choisi un véritable goulet d’étranglement, pas un exercice jouet, et les correctifs obtenus étaient suffisamment sérieux pour lancer une discussion technique substantielle dans le noyau [2].

Deuxièmement, des benchmarks peuvent être à la fois impressionnants et étroits. La branche initiale de huit correctifs a donné environ 3x dans un test de stress sur portable [1]. La branche ultérieure de dix correctifs a produit un résultat de 23x sur un test synthétique Threadripper [2]. Les deux chiffres sont significatifs; aucun ne doit être généralisé en “les lectures Linux sont maintenant 3x ou 23x plus rapides”.

Troisièmement, la revue reste le mécanisme de filtrage. Une course a été trouvée avant l’intégration, les mainteneurs discutent encore du modèle de récupération mémoire, et la série nécessite davantage de travail [3][5]. Ce n’est pas un échec du processus. C’est le processus.

Le sens plus large pour Linux et l’IA

Pour Linux, le précédent le plus important est peut-être la transparence. La branche initiale explicitait le rôle de l’IA: Claude Code avait aidé à produire l’implémentation, les tests, les notes de revue et le premier texte, tandis que Torvalds dirigeait le travail et exécutait les mesures [1]. La discussion récente sur la liste de diffusion a ensuite déplacé le sujet de la nouveauté vers l’ingénierie: meilleurs chiffres de benchmark, conception RCU révisée, course découverte et débat entre mainteneurs sur la sémantique de récupération mémoire [2][3][4][5].

C’est probablement le modèle que les outils d’IA devront respecter dans les infrastructures critiques. Pas “faire confiance au modèle”, pas “interdire le modèle”, mais “montrer le code, montrer les mesures, déclarer les limites, survivre à la revue”. L’expérience de Torvalds avec Claude Code est importante précisément parce qu’elle ne s’arrête pas au benchmark. Elle continue dans la partie difficile: prouver qu’un chemin de lecture plus rapide du cache de pages est aussi correct.

À ce stade, d’après les éléments frais disponibles dans la fenêtre de 72 heures, la conclusion prudente est claire. Linus Torvalds a montré que Claude Code peut aider à produire une série sérieuse de correctifs du noyau Linux avec des résultats de performance frappants dans des benchmarks ciblés. Mais ce n’est pas encore une accélération intégrée à Linux mainline. C’est un changement expérimental de gestion mémoire, activement relu, dont la promesse dépendra de la correction de la course, de la stabilisation du modèle de récupération et de la preuve que le chemin rapide reste sûr hors des tests synthétiques.

Développements

1. Linus Torvalds Utilise Claude Code pour Patches du Kernel, Amélioration de 3x36Kr · 16 oct. 2026, 06:32 · 8/10
2. Linus Torvalds confirme que Claude Code a écrit des patches du noyau LinuxCyberSecurityNews · 16 oct. 2026, 06:08 · 8/10
3. Linus Torvalds révèle que Claude Code a écrit des correctifs et des programmes de test pour le noyau LinuxCyberSecurityNews · 16 oct. 2026, 06:08 · 8/10
4. Linus Torvalds utilise Claude Code pour le noyau Linux, triple la performance36Kr · 14 oct. 2026, 10:50 · 8/10
5. Linus Torvalds utilise Claude Code pour le noyau Linux, triple performance36Kr · 14 oct. 2026, 10:50 · 9/10
6. Linus Torvalds utilise Claude Code pour tripler le débit de lecture du noyau LinuxBigGo Finance · 12 oct. 2026, 14:05 · 8/10
7. Linus Torvalds utilise Claude Code pour tripler la performance de lecture du noyau Linuxfinance.biggo.com · 12 oct. 2026, 14:05 · 8/10
8. Linus Torvalds affirme que Claude Code a aidé à écrire une mise à jour de noyau LinuxPasquale Pillitteri · 12 oct. 2026, 12:24 · 9/10
9. Linus Torvalds cite Claude Code pour avoir aidé au correctif du noyau LinuxPasquale Pillitteri · 12 oct. 2026, 12:24 · 8/10
10. Linus Torvalds a réécrit la lecture du cache Linux avec Claude CodeStartup Fortune · 12 oct. 2026, 11:21 · 8/10
11. Linus Torvalds développe une mise à jour majeure du kernel Linux avec Claude CodePhoronix · 12 oct. 2026, 02:16 · 8/10
12. Linus Torvalds travaille sur une amélioration du noyau Linux avec Claude CodePhoronix · 12 oct. 2026, 02:16 · 7/10

Sources des dernières 72 heures

1. [1]Linus Torvalds wrote a Linux kernel speedup with Claude Code13 oct. 2026, 14:00
2. [2]Linux-Kernel Archive: Improve page refcount scalability13 oct. 2026, 23:26
3. [3]Linus Torvalds's first LLM-assisted patch series14 oct. 2026, 15:50
4. [4]Linux-Kernel Archive: Re: Improve page refcount scalability14 oct. 2026, 00:08
5. [5]Linux-Kernel Archive: Re: Improve page refcount scalability14 oct. 2026, 14:53

Article généré par IA à partir d’une recherche web récente, puis conservé comme instantané éditorial daté.