Le noyau Linux 7.2 atteint 43 millions de lignes : vérifié avec 4 compteurs de code
Le noyau Linux a atteint un autre jalon majeur. Le dernier arbre de développement Linux 7.2 contient environ 43,2 millions de lignes au total dans tous les fichiers suivis, soit environ 42,6 millions de lignes conscientes du langage selon les outils tokei et scc.
Nous avons vérifié ces chiffres de manière indépendante sur le tag officiel v7.2-rc1 en utilisant 4 outils différents de comptage de code. D'après nos mesures, il s'agit de l'arborescence de code source du noyau Linux la plus grande à ce jour.
À première vue, ce nombre peut sembler énorme. Mais cela ne signifie pas que Linux est devenu gonflé. Au lieu de cela, cela montre deux choses : combien de matériel Linux prend en charge aujourd'hui, et à quel point le noyau continue d'évoluer activement.
Voyons ce qui a changé.
Linux 7.2 franchit la barre des 42 millions de lignes
J'ai mesuré le Linux 7.2-rc1 Git tree en utilisant plusieurs outils de comptage de code. À des fins de démonstration, j'ai utilisé le commit du tag exact v7.2-rc1 (dc59e4fea9d8).
ostechnix@fedora:~/linux$ git log --oneline -1
dc59e4fea9d8 (HEAD -> master, tag: v7.2-rc1, origin/master, origin/HEAD) Linux 7.2-rc1ostechnix@fedora:~/linux$ git describe --tags
v7.2-rc1ostechnix@fedora:~/linux$ git rev-parse HEAD
dc59e4fea9d83f03bad6bddf3fa2e52491777482Voici ce que chaque outil a trouvé :
| Outil | Fichiers | Lignes totales | Lignes de code | Commentaires | Espaces vides |
|---|---|---|---|---|---|
| cloc v2.08 | 82 309 | 40 416 242 | 30 509 981 | 4 840 469 | 5 065 792 |
| montre | 89 042 | 42 584 526 | 32 359 896 | 4 893 147 | 5 331 483 |
| scc | 88 988 | 42 582 367 | 32 451 089 | 4 807 573 | 5 323 705 |
| wc -l (tous les fichiers) | - | 43 179 595 | - | - | - |
J'ai exécuté les quatre outils dans la même session Fedora VM contre le même checkout Git (dc59e4fea9d8) en utilisant des versions d'outils identiques. Cela rend les résultats directement comparables et reproductibles.
Un test précédent avec cloc v1.96 a produit un total presque identique de 40 414 638 lignes. La petite différence provient des améliorations de cloc v2.08, qui reconnaît quelques formats de fichiers supplémentaires tels que Jinja Template et Snakemake.
Tokei et scc sont presque parfaitement d'accord, rapportant tous deux environ 42,58 millions de lignes au total. Leurs résultats indépendants ne diffèrent que de 2 159 lignes (environ 0,005%), ce qui en fait les mesures conscientes du langage les plus cohérentes du code source de Linux.
En comparaison, l'exécution par défaut de cloc sous-estime le noyau d'environ 2,17 millions de lignes car elle ne reconnaît pas par défaut les fichiers source du Device Tree de Linux (.dts/.dtsi). J'ai vérifié cela en relançant cloc avec :
cloc --force-lang="C",dts --force-lang="C",dtsi .Cela a augmenté les totaux de cloc d'environ 2,1 millions de lignes, rapprochant ses résultats de ceux de tokei et scc.
J'ai reproduit le même comportement sur Linux 7.1 et 7.2-rc1, confirmant que la différence provient de la reconnaissance de la langue par défaut de cloc plutôt que d'un changement dans le noyau lui-même.
Comment le titre « 43 millions » est dérivé
Un décompte brut wc -l sur chaque fichier suivi dans le dépôt produit 43 179 595 lignes. C'est de là que vient le titre « 43 millions de lignes ».
Il y a un écart d'environ 597 000 lignes entre ce chiffre et les totaux rapportés par tokei et scc. Cette différence existe parce que wc -l compte chaque ligne de chaque fichier suivi, tandis que les outils conscients des langages excluent intentionnellement ou classifient différemment de nombreux fichiers non sources. Parmi les exemples : la documentation, les métadonnées, les images, les certificats et d'autres formats non sources ou non reconnus dans le dépôt.
Il convient de noter qu'un checkout Git du noyau Linux propre ne contient linux-firmware). Par conséquent, ces fichiers ne contribuent pas à cette différence.
En bref, le chiffre de 43 millions est techniquement exact car il reflète chaque ligne stockée dans l'arborescence Git. Cependant, le chiffre de 42,58 millions rapporté par tokei et scc est la mesure la plus précise du code source du noyau.
Linux 7.2 Continue la Croissance du Noyau
Pour mesurer combien le noyau a grandi au cours de ce cycle de développement, j'ai répété les mêmes mesures sur la version finale de Linux 7.1 en utilisant la même machine virtuelle Fedora, les mêmes versions des outils et la même méthodologie.
| Métrique | Linux 7.1 | Linux 7.2-rc1 | Croissance |
|---|---|---|---|
montre | 42 021 677 | 42 584 526 | +562 849 |
scc | 42 019 634 | 42 582 367 | +562 733 |
wc -l | 42 606 918 | 43 179 595 | +572,677 |
Les résultats montrent un accord remarquable entre les trois méthodes de mesure. Tant tokei que scc indiquent que Linux a gagné environ 563 000 lignes sensibles au langage entre Linux 7.1 et 7.2-rc1, ce qui représente une croissance d'environ 1,3% au cours d'un seul cycle de développement. Un décompte brut avec wc -l montre une augmentation de taille similaire de 572 677 lignes.
Cela semble dramatique, mais c'est tout à fait attendu. Chaque version du noyau Linux ajoute la prise en charge de nouveaux processeurs, plateformes, systèmes de fichiers, pilotes, technologies de virtualisation et améliorations de la sécurité tout en continuant à affiner les sous-systèmes existants.
Selon les notes de version finale de Linux 7.1, plus de 2 000 développeurs ont contribué à des changements, y compris plus de 300 contributeurs pour la première fois. Des contributions soutenues à cette échelle se traduisent naturellement par une croissance régulière de l'arbre source au fil du temps.
Linux continue de croître même après la suppression du code ancien
Un aspect surprenant de cette étape est que le code du noyau Linux continue de croître même en supprimant le code hérité.
Linux 7.1 a commencé à abandonner le support des processeurs i486 d'Intel, en supprimant plus de 140 000 lignes de code obsolète, y compris les contrôleurs hôtes PCMCIA hérités et les pilotes RNIS. Linux 7.2 poursuit ce nettoyage en supprimant du code supplémentaire lié à l'i486 ainsi que plusieurs pilotes obsolètes et composants x86 hérités.
En d'autres termes, les développeurs Linux équilibrent continuellement les ajouts avec les suppressions. Alors que le support de nouveau matériel, les architectures, les pilotes, les systèmes de fichiers et les fonctionnalités de sécurité étendent le noyau, le code obsolète est régulièrement retiré pour réduire la charge de maintenance et maintenir le projet moderne.
Pourquoi le noyau Linux est-il si volumineux ?
La réponse est conducteurs.
Le noyau Linux prend en charge une incroyable variété de matériels. Chaque carte graphique, contrôleur de stockage, adaptateur réseau, fonctionnalité de portable, périphérique USB et plateforme embarquée a besoin du support du noyau.
À mesure que de nouveaux matériels arrivent sur le marché, les développeurs ajoutent de nouveaux pilotes. En même temps, ils maintiennent la compatibilité avec les appareils existants. À cause de cela, la majeure partie de la croissance du noyau provient du support matériel. Très peu de croissance provient du code central du noyau pour la planification ou la gestion de la mémoire.
AMDGPU reste le plus grand pilote
Le plus grand contributeur est toujours le sous-système graphique AMD.
Le pilote combiné AMDGPU et AMDKFD contient environ 6,35 millions de lignes de code. Cela en fait le plus grand pilote de tout le noyau Linux.
Linus Torvalds a signalé quelque chose d'intéressant. Environ un tiers d'une grande demande de fusion était constitué de fichiers de définition de registres GPU AMD. Ces fichiers sont principalement des données générées. Ils aident Linux à communiquer avec le matériel graphique AMD moderne.
Plus grand ne signifie pas plus lent
Beaucoup de gens supposent que plus de lignes de code signifient un logiciel plus lent. Ce n'est pas ainsi que fonctionne le noyau Linux.
La plupart du code supplémentaire existe pour prendre en charge du matériel que de nombreux utilisateurs ne posséderont jamais. Une grande partie de ce code se trouve dans des modules chargeables. Ces modules ne s'activent que lorsque le matériel correspondant est présent.
En conséquence, le noyau continue de s'améliorer tout en élargissant la compatibilité matérielle. Cela s'applique aux ordinateurs de bureau, serveurs, ordinateurs portables, systèmes embarqués, plateformes cloud et superordinateurs.
Compter le nombre total de lignes dans le code du noyau Linux
N'importe qui peut cloner le dépôt du noyau Linux et le mesurer. Tout d'abord, obtenez le code source du noyau :
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
cd linuxUn clone complet fait environ 5 Go. Vous pouvez ajouter --depth=1 à la commande git pour un clone superficiel à la place (environ 1,5 Go) :
git clone --depth=1 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.gitPour ce guide, j'ai utilisé un clone complet.
Méthode 1 : cloc (l'outil de référence largement cité)
cloc est l'outil le plus couramment utilisé pour le comptage des lignes du noyau.
# Install
sudo apt install cloc # Debian/Ubuntu
sudo dnf install cloc # Fedora/RHEL
sudo pacman -S cloc # ArchMaintenant, exécutez :
cloc --progress=1 .Remarquez le point (.) à la fin. Cela signifie que nous instructons le cloc à analyser le répertoire actuel.
Selon votre matériel, cloc peut prendre plusieurs minutes pour analyser l'intégralité de l'arborescence source de Linux. Sur ma VM Fedora, cela s'est terminé en environ 3 à 4 minutes.
Exemple de sortie :
94718 text files.
82309 unique files.
12415 files ignored.
github.com/AlDanial/cloc v 2.08 T=276.85 s (297.3 files/s, 145986.6 lines/s)
----------------------------------------------------------------------------------------
Language files blank comment code
----------------------------------------------------------------------------------------
C 36898 3801120 2908960 19610084
C/C++ Header 26648 791061 1600637 8405094
JSON 833 2 0 553530
reStructuredText 4011 197901 81994 540661
YAML 5675 104970 25957 518427
Assembly 1343 47625 99191 230030
Bourne Shell 1321 40912 27301 159379
Rust 473 15277 52795 114347
Python 428 21148 18854 90203
Text 975 19724 0 89632
make 3188 12948 13377 60578
SVG 87 98 1311 56094
Perl 69 6811 4558 34796
XML 32 1514 1706 23049
yacc 10 723 442 4848
PO File 7 1106 1269 4336
Bourne Again Shell 63 631 416 2584
lex 10 366 355 2219
C++ 9 356 143 1917
awk 16 374 480 1743
CSV 11 126 0 1413
Jinja Template 102 69 98 794
NAnt script 2 167 0 610
Logos 4 115 0 547
Markdown 9 162 3 514
XML (Qt/GTK) 1 50 0 486
XSD 1 46 9 349
CSS 4 71 96 244
Cucumber 1 40 97 199
TeX 1 6 73 155
TNSDL 2 33 0 140
Windows Module Definition 2 20 0 137
Linker Script 5 25 11 126
Snakemake 5 15 13 125
Clojure 36 1 0 95
m4 1 15 1 95
XSLT 5 13 26 61
BitBake 5 65 178 58
Umka 2 20 0 54
TOML 3 9 12 36
MATLAB 1 17 37 35
INI 3 6 0 34
sed 2 23 52 31
vim script 1 3 12 27
HTML 2 4 5 25
Ruby 1 4 0 25
Velocity Template Language 1 0 0 15
----------------------------------------------------------------------------------------
SUM: 82309 5065792 4840469 30509981
----------------------------------------------------------------------------------------
Remarque : cloc ne reconnaît pas les fichiers sources Device Tree (.dts/.dtsi). Cela fait partie des raisons pour lesquelles il sous-estime le noyau (voir la répartition plus tôt dans ce guide).
Pour mesurer uniquement le pilote graphique AMD, exécutez :
cloc drivers/gpu/drm/amdMéthode 2 : tokei (plus rapide et plus précis, recommandé)
tokei est nettement plus rapide que cloc. Il compte également correctement les fichiers Device Tree. Cela en fait un choix plus précis pour le noyau Linux.
Tout d'abord, assurez-vous que Rust est installé sur votre système. Ensuite, installez tokei en utilisant le gestionnaire de paquets cargo :
cargo install tokeitokei est également disponible dans les dépôts officiels de certaines distributions, vous pouvez donc l’installer en utilisant le gestionnaire de paquets par défaut comme ci-dessous :
sudo apt install tokeibrew install tokeiMaintenant, exécutez :
tokei .Exemple de sortie :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Language Files Lines Code Comments Blanks
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AWK 13 2805 1923 500 382
Alex 4 662 547 0 115
ASN.1 15 656 441 87 128
Assembly 11 5781 5445 0 336
GNU Style Assembly 1337 371255 270423 56888 43944
Autoconf 6 459 395 30 34
Automake 3 31 23 3 5
BASH 62 3038 2094 437 507
Bazel 81 1829 1474 54 301
Bitbake 3 13 4 6 3
C 36910 26320472 19615926 2909605 3794941
C Header 26813 10822880 8416361 1615212 791307
C++ 7 2291 1969 81 241
C++ Header 2 125 59 55 11
CSS 4 411 244 97 70
Device Tree 6343 2097441 1724154 92401 280886
Forge Config 15 1352 321 744 287
Gherkin (Cucumber) 1 336 199 97 40
Happy 10 6013 5290 0 723
HEX 2 173 173 0 0
INI 2 13 6 5 2
Jinja2 149 1187 966 145 76
JSON 1043 607008 607006 0 2
Lex 10 2940 2218 356 366
LD Script 13 552 427 40 85
Makefile 3203 87274 60667 13531 13076
Module-Definition 2 157 137 0 20
Objective-C 1 89 72 0 17
Pacman's makepkg 1 134 91 13 30
Perl 61 43189 33862 4009 5318
PO File 7 6711 3346 2259 1106
Python 439 130209 102002 8291 19916
RPM Specfile 1 215 174 14 27
ReStructuredText 4011 820556 622655 0 197901
Ruby 1 29 25 0 4
Shell 1172 219683 153221 27411 39051
Snakemake 5 153 125 13 15
SVG 87 57503 56094 1311 98
SWIG 1 252 154 27 71
TeX 1 234 155 73 6
Plain Text 981 109702 0 89924 19778
TOML 3 57 36 12 9
Unreal Script 5 618 371 156 91
Apache Velocity 1 15 15 0 0
Vim Script 1 42 33 6 3
XSL 10 200 122 52 26
XML 32 26269 23572 1452 1245
YAML 5673 648526 529448 23888 95190
─────────────────────────────────────────────────────────────────────────────────
HTML 2 29 25 0 4
|- JavaScript 1 7 7 0 0
(Total) 36 32 0 4
─────────────────────────────────────────────────────────────────────────────────
Markdown 9 534 0 385 149
|- BASH 1 2 2 0 0
|- C 1 20 12 6 2
|- Rust 1 98 76 13 9
|- YAML 1 25 22 0 3
(Total) 679 112 404 163
─────────────────────────────────────────────────────────────────────────────────
Rust 473 143187 114374 13573 15240
|- Markdown 351 39084 913 29885 8286
(Total) 182271 115287 43458 23526
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total 89042 42584526 32359896 4893147 5331483
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Il se termine en moins d'une minute et correspond étroitement aux résultats de scc (voir la section suivante).
Méthode 3 : scc (la plus rapide, avec mesures de complexité)
scc correspond à la précision de tokei. Il rapporte également la complexité cyclomatique par langage. Cela est utile pour comprendre quelles parties du noyau sont les plus difficiles à maintenir.
Assurez-vous que Golang est installé sur votre système, puis exécutez la commande suivante pour installer scc :
go install github.com/boyter/scc/v3@latestMaintenant, exécutez :
scc .Exemple de sortie :
───────────────────────────────────────────────────────────────────────────────
Language Files Lines Blanks Comments Code Complexity
───────────────────────────────────────────────────────────────────────────────
C 36,910 26,320,472 3,795,058 2,909,421 19,615,993 2,566,279
C Header 26,813 10,822,880 791,303 1,614,799 8,416,778 66,444
Device Tree 6,343 2,097,441 280,886 92,367 1,724,188 36
YAML 5,672 648,427 104,949 25,934 517,544 0
ReStructuredTe… 4,011 820,556 197,878 0 622,678 0
Makefile 3,203 87,274 13,076 13,531 60,667 464
Assembly 1,348 377,036 41,691 49,680 285,665 3,505
Shell 1,174 220,250 37,034 26,897 156,319 12,925
JSON 1,043 607,008 2 0 607,006 0
Plain Text 981 109,702 19,777 0 89,925 0
Rust 473 182,419 15,156 52,407 114,856 10,808
Python 439 130,209 15,774 13,048 101,387 15,323
Jinja 149 1,187 76 145 966 193
SVG 87 57,503 98 1,311 56,094 2
Perl 67 46,073 6,048 4,183 35,842 5,246
BASH 63 3,399 513 413 2,473 324
DOT 36 1,261 81 62 1,118 0
XML 32 26,269 1,465 1,755 23,049 0
AWK 17 3,102 311 232 2,559 532
CSV 11 1,539 126 0 1,413 0
Extensible Sty… 10 200 26 0 174 0
Happy 10 6,013 723 0 5,290 0
LEX 10 2,940 366 355 2,219 0
Markdown 9 679 162 0 517 0
LD Script 8 390 60 29 301 0
C++ 7 2,291 241 81 1,969 332
Autoconf 6 459 34 30 395 11
License 5 422 84 0 338 0
Snakemake 5 153 15 13 125 0
Unreal Script 5 618 91 156 371 21
Alex 4 662 115 0 547 0
CSS 4 411 70 97 244 0
Raku 3 213 19 21 173 33
Systemd 3 167 25 63 79 0
TOML 3 57 8 12 37 0
Bazel 2 777 167 177 433 6
C++ Header 2 125 11 55 59 2
HEX 2 173 0 0 173 0
HTML 2 34 4 5 25 0
INI 2 13 2 5 6 0
Module-Definit… 2 157 20 0 137 4
bait 2 64 4 15 45 9
sed 2 106 23 53 30 0
CloudFormation… 1 99 17 2 80 0
Gherkin Specif… 1 336 40 97 199 0
MATLAB 1 89 17 37 35 3
Ruby 1 29 4 0 25 1
Scallop 1 3 0 0 3 0
TeX 1 234 6 73 155 0
Vim Script 1 42 3 12 27 5
XML Schema 1 404 46 0 358 0
───────────────────────────────────────────────────────────────────────────────
Total 88,988 42,582,367 5,323,705 4,807,573 32,451,089 2,682,508
───────────────────────────────────────────────────────────────────────────────
Estimated Cost to Develop (organic) $1,473,621,894
Estimated Schedule Effort (organic) 219.99 months
Estimated People Required (organic) 595.12
───────────────────────────────────────────────────────────────────────────────
Processed 1595970277 bytes, 1595.970 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────Sur l'arbre v7.2-rc1, scc estime également le coût de reconstruction du noyau à partir de zéro. L'estimation est d'environ 1,47 milliard de dollars, en utilisant le modèle organique COCOMO. Vous pouvez voir ce détail presque à la fin de la sortie.
Méthode 4 : wc -l (vérification rapide de tous les fichiers)
La commande wc compte chaque ligne dans chaque fichier, quel que soit le type. Cela inclut les fichiers binaires et non textuels. Elle produit le plus grand nombre parmi les quatre outils.
find . -not -path './.git/*' -type f \
| xargs wc -l 2>/dev/null \
| awk '/total/{sum += $1} END{print sum}'Exemple de sortie :
43179595Veuillez noter que wc n'est pas un compteur de code conscient des langues. Mais il fournit une limite supérieure utile pour le nombre total de lignes stockées dans l'arbre Git.
Remarque : Ne pas ajouter | tail -1 à la fin. Lorsqu'il y a des dizaines de milliers de fichiers, xargs les divise en plusieurs lots. Chaque lot affiche sa propre ligne total. Utiliser tail -1 capture seulement le sous-total du dernier lot. Cela produit un résultat très incorrect.
Comparaison des outils
| Outil | Vitesse | Conscient de la langue | Notes |
|---|---|---|---|
wc -l | Le plus rapide | ❌ | Compte tous les fichiers, y compris les fichiers binaires |
montre | Très rapide | ✅ | Meilleur équilibre entre vitesse et précision |
scc | Rapide | ✅ | Signale également la complexité cyclomatique |
cloc | Lent (15-30 min) | ✅ | Sous-estime le noyau ; ne reconnaît pas les fichiers Device Tree |
Résumé des statistiques de code Linux 7.2
Mesuré sur le commit dc59e4fea9d8 (tag : v7.2-rc1), le 30 juin 2026 :
| Statistique | Valeur |
|---|---|
Nombre total de lignes, tous fichiers (wc -l) | 43 179 595 |
| Total de lignes, conscient de la source (tokei/scc) | ~42 583 000 |
| Lignes de code source | ~32 400 000 |
| Commenter des lignes | ~4 850 000 |
| Lignes vides | ~5 327 000 |
Différence entre wc -l et tokei/scc | ~597 000 lignes (fichiers non sources et fichiers classés différemment par des outils conscients du langage) |
| Plus grand conducteur | AMDGPU + AMDKFD |
| Pilote graphique AMD | ~6,35 millions de lignes |
| Principale source de croissance | Pilotes de périphérique |
| Nettoyage des héritages | Suppression continue du code Intel i486 et des pilotes obsolètes |
| Coût de développement estimé | ~1,47 milliard de dollars (COCOMO, via scc) |
Conclusion
Franchir 42 millions de lignes est plus qu'une simple statistique amusante. Cela reflète l'ampleur de l'un des plus grands projets logiciels collaboratifs au monde.
Les mainteneurs du noyau Linux continuent d'ajouter le support pour de nouveaux matériels. En même temps, ils suppriment le code pour les plateformes qui ont atteint la fin de leur vie utile. Le résultat est un noyau qui croît là où c'est nécessaire et devient plus propre là où c'est possible.
Pour les passionnés de Linux, cette étape est un rappel supplémentaire de la rapidité avec laquelle le développement du noyau progresse. Elle montre également combien de travail est nécessaire pour supporter tout, des petites cartes embarquées aux superordinateurs les plus rapides du monde.
Source :
- Linux 7.2 dépasse plus de 43 millions de lignes dans l'arborescence du noyau