Ядро Linux 7.2 достигло 43 миллионов строк: проверено с помощью 4 счётчиков кода
Ядро Linux достигло ещё одной важной вехи. Последнее развитие дерева Linux 7.2 содержит примерно 43,2 миллиона строк во всех отслеживаемых файлах, или около 42,6 миллиона строк с учётом языка согласно инструментам tokei и scc.
Мы независимо проверили эти данные на официальном теге v7.2-rc1, используя 4 различных инструмента для подсчёта кода. Согласно нашим измерениям, это самая большая на сегодняшний день исходная кодовая база ядра Linux.
На первый взгляд, это число может показаться огромным. Но это не означает, что Linux стал раздутым. Вместо этого оно показывает две вещи: сколько аппаратного обеспечения поддерживает Linux сегодня и насколько активно продолжает развиваться ядро.
Давайте посмотрим, что изменилось.
Linux 7.2 превышает отметку в 42 миллиона строк
Я измерил Git-дерево Linux 7.2-rc1 с помощью нескольких инструментов подсчета кода. В демонстрационных целях я использовал точный коммит с тегом 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
dc59e4fea9d83f03bad6bddf3fa2e52491777482Вот что нашёл каждый инструмент:
| Инструмент | Файлы | Общее количество строк | Строки кода | Комментарии | Пробелы |
|---|---|---|---|---|---|
| cloc v2.08 | 82 309 | 40 416 242 | 30 509 981 | 4 840 469 | 5 065 792 |
| часы | 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 (все файлы) | - | 43 179 595 | - | - | - |
Я запустил все четыре инструмента в одной сессии Fedora VM против одного и того же состояния Git-репозитория (dc59e4fea9d8), используя одинаковые версии инструментов. Это делает результаты непосредственно сопоставимыми и воспроизводимыми.
Ранее тестирование с cloc v1.96 дало почти идентичное общее количество строк — 40,414,638. Небольшая разница обусловлена улучшениями в cloc v2.08, который распознает несколько дополнительных форматов файлов, таких как Jinja Template и Snakemake.
Tokei и scc почти полностью совпадают, оба сообщают о 42,58 миллиона строк. Их независимые результаты различаются всего на 2 159 строк (около 0,005%), что делает их самыми согласованными измерениями исходного кода Linux с учётом языка.
Для сравнения, стандартный запуск cloc недооценивает количество строк в ядре примерно на 2,17 миллиона, потому что по умолчанию он не распознает исходные файлы Linux Device Tree (.dts/.dtsi). Я это проверил, запустив cloc снова с:
cloc --force-lang="C",dts --force-lang="C",dtsi .Это увеличило общие показатели cloc примерно на 2,1 миллиона строк, приведя его результаты в тесное соответствие с tokei и scc.
Я воспроизвел такое же поведение как на Linux 7.1, так и на 7.2-rc1, подтвердив, что расхождение возникает из-за стандартного распознавания языка cloc, а не из-за изменений в самом ядре.
Как получен заголовок «43 миллиона»
Сырые данные wc -l по каждому отслеживаемому файлу в репозитории дают 43,179,595 строк. Именно отсюда появляется заголовок «43 миллиона строк».
Существует разрыв примерно в 597 000 строк между этой цифрой и суммами, указанными в tokei и scc. Эта разница возникает потому, что wc -l подсчитывает каждую строку во всех отслеживаемых файлах, тогда как инструменты, учитывающие язык программирования, намеренно исключают или классифицируют многие несредовые файлы иначе. Примеры включают документацию, метаданные, изображения, сертификаты и другие несредовые или нераспознанные форматы по всему репозиторию.
Стоит отметить, что чистая проверка исходного кода ядра Linux через Git содержит ни одного скомпилированного бинарного файла .dtb и нет каталога firmware/ (прошивки поддерживаются отдельно в репозитории linux-firmware). Следовательно, эти файлы не влияют на это различие.
Короче говоря, заголовок 43 миллиона технически точен, так как отражает каждую строку, хранящуюся в дереве Git. Тем не менее, цифра 42,58 миллиона, указанная в tokei и scc, является более точной оценкой исходного кода ядра.
Linux 7.2 Продолжает рост ядра
Чтобы измерить, насколько ядро выросло за этот цикл разработки, я повторил те же измерения на финальном выпуске Linux 7.1, используя ту же виртуальную машину Fedora, версии инструментов и методологию.
| Метрическая | Linux 7.1 | Linux 7.2-rc1 | Рост |
|---|---|---|---|
часы | 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 |
Результаты показывают замечательное согласие между всеми тремя методами измерения. Как tokei, так и scc показывают, что Linux приобрёл примерно 563 000 строк кода, учитывающих языковые особенности, между версиями Linux 7.1 и 7.2-rc1, что составляет примерно 1,3% рост за один цикл разработки. Сырая команда wc -l показывает аналогичное увеличение — 572 677 строк.
Звучит драматично, но это вполне ожидаемо. Каждый выпуск ядра Linux добавляет поддержку новых процессоров, платформ, файловых систем, драйверов, технологий виртуализации и улучшений безопасности, одновременно продолжая совершенствовать существующие подсистемы.
Согласно финальным заметкам о выпуске Linux 7.1, более 2 000 разработчиков внесли изменения, включая более 300 новичков. Постоянные вклады в таком объеме естественно приводят к стабильному росту дерева исходного кода с течением времени.
Linux продолжает развиваться даже после удаления старого кода
Одним из удивительных аспектов этого рубежа является то, что код ядра Linux продолжает расти, даже при удалении устаревшего кода.
Linux 7.1 начал прекращать поддержку процессоров Intel i486, удалив более 140 000 строк устаревшего кода, включая устаревшие контроллеры PCMCIA и драйверы ISDN. Linux 7.2 продолжает эту очистку, удаляя дополнительный код, связанный с i486, вместе с несколькими устаревшими драйверами и устаревшими компонентами x86.
Другими словами, разработчики Linux постоянно балансируют между добавлением и удалением. В то время как поддержка нового оборудования, архитектур, драйверов, файловых систем и функций безопасности расширяет ядро, устаревший код регулярно выводится из эксплуатации, чтобы уменьшить нагрузку на обслуживание и сохранить проект современным.
Почему ядро Linux такое большое?
Ответ: водители.
Ядро Linux поддерживает невероятное разнообразие оборудования. Каждая видеокарта, контроллер хранения данных, сетевой адаптер, функция ноутбука, USB-устройство и встроенная платформа требует поддержки ядра.
По мере того как новое оборудование выходит на рынок, разработчики добавляют новые драйверы. В то же время они поддерживают совместимость с существующими устройствами. Из-за этого большая часть роста ядра происходит за счет поддержки оборудования. Очень небольшой рост приходится на основной код планирования или управления памятью ядра.
AMDGPU остаётся крупнейшим драйвером
Наибольшим вкладом по-прежнему является графическая подсистема AMD.
Комбинированный драйвер AMDGPU и AMDKFD содержит примерно 6,35 миллиона строк кода. Это делает его крупнейшим драйвером во всём ядре Linux.
Линус Торвальдс указал на нечто интересное. Примерно треть одного большого запроса на внесение изменений состояла из файлов определения регистров GPU AMD. Эти файлы в основном содержат сгенерированные данные. Они помогают Linux взаимодействовать с современным графическим оборудованием AMD.
Больше не значит медленнее
Многие люди считают, что больше строк кода означает более медленное программное обеспечение. Но в ядре Linux это не так.
Большая часть дополнительного кода существует для поддержки оборудования, которое многие пользователи никогда не будут иметь. Большая часть этого кода находится в загружаемых модулях. Эти модули активируются только тогда, когда присутствует соответствующее оборудование.
В результате ядро продолжает совершенствоваться, одновременно расширяя совместимость с аппаратным обеспечением. Это относится к настольным компьютерам, серверам, ноутбукам, встроенным системам, облачным платформам и суперкомпьютерам.
Посчитайте общее количество строк в коде ядра Linux
Любой человек может клонировать репозиторий ядра Linux и измерить его. Сначала получите исходный код ядра:
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
cd linuxПолный клон занимает около 5 ГБ. Вы можете добавить --depth=1 к команде git для поверхностного клонирования (около 1,5 ГБ):
git clone --depth=1 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.gitДля этого руководства я использовал полный клон.
Метод 1: cloc (широко цитируемый справочный инструмент)
cloc является наиболее часто используемым инструментом для подсчета строк в ядре.
# Install
sudo apt install cloc # Debian/Ubuntu
sudo dnf install cloc # Fedora/RHEL
sudo pacman -S cloc # ArchТеперь запустите:
cloc --progress=1 .Обратите внимание на точку (.) в конце. Это означает, что мы инструктируем cloc анализировать текущий каталог.
В зависимости от вашего оборудования, cloc может занять несколько минут на сканирование полного исходного дерева Linux. На моей виртуальной машине Fedora это завершилось примерно за 3-4 минуты.
Пример вывода:
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
----------------------------------------------------------------------------------------
Примечание: cloc не распознаёт исходные файлы Device Tree (.dts/.dtsi). Это одна из причин, по которой оно занижает количество строк ядра (см. разбор ранее в этом руководстве).
Чтобы измерить только драйвер графики AMD, выполните:
cloc drivers/gpu/drm/amdМетод 2: tokei (быстрее и точнее, рекомендуется)
tokei значительно быстрее, чем cloc. Он также корректно подсчитывает файлы Device Tree. Это делает его более точным выбором для ядра Linux.
Сначала убедитесь, что Rust установлен в вашей системе. А затем установите tokei с помощью пакетного менеджера cargo:
cargo install tokeitokei также доступен в официальных репозиториях некоторых дистрибутивов, поэтому вы можете установить его с помощью стандартного менеджера пакетов, как показано ниже:
sudo apt install tokeibrew install tokeiТеперь запустите:
tokei .Пример вывода:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
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
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Это заканчивается менее чем за минуту и довольно точно соответствует результатам scc (См. следующий раздел).
Метод 3: scc (самый быстрый, с метриками сложности)
scc соответствует точности tokei. Он также сообщает о цикломатической сложности по языкам. Это полезно для понимания, какие части ядра труднее всего поддерживать.
Убедитесь, что Golang установлен в вашей системе, а затем выполните следующую команду для установки scc:
go install github.com/boyter/scc/v3@latestТеперь запустите:
scc .Пример вывода:
───────────────────────────────────────────────────────────────────────────────
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)
───────────────────────────────────────────────────────────────────────────────В дереве v7.2-rc1 scc также оценивает стоимость полной реконструкции ядра с нуля. Оценка составляет около 1,47 миллиарда долларов, с использованием органической модели COCOMO. Вы можете увидеть эту информацию почти в конце вывода.
Метод 4: wc -l (быстрая проверка всех файлов на здравомыслие)
Команда wc считает каждую строку в каждом файле, независимо от типа. Это включает бинарные и нетекстовые файлы. Она дает наибольшее количество среди всех четырёх инструментов.
find . -not -path './.git/*' -type f \
| xargs wc -l 2>/dev/null \
| awk '/total/{sum += $1} END{print sum}'Пример вывода:
43179595Обратите внимание, что wc не является счетчиком кода, учитывающим язык. Но он предоставляет полезную верхнюю границу общего количества строк, хранящихся в дереве Git.
Примечание: Не добавляйте | tail -1 в конце. Когда файлов десятки тысяч, xargs разбивает их на несколько партий. Каждая партия выводит свою собственную строку total. Использование tail -1 захватывает только промежуточный итог последней партии. Это дает очень неправильный результат.
Сравнение инструментов
| Инструмент | Скорость | Осведомлённый о языке | Заметки |
|---|---|---|---|
wc -l | Самый быстрый | ❌ | Считает все файлы, включая бинарные |
часы | Очень быстро | ✅ | Лучший баланс скорости и точности |
scc | Быстрый | ✅ | Также сообщает о цикломатической сложности |
cloc | Медленно (15-30 мин) | ✅ | Недооценивает ядро; не распознает файлы Device Tree |
Сводка статистики кода Linux 7.2
Измерено на коммите dc59e4fea9d8 (тег: v7.2-rc1), 30 июня 2026 года:
| Статистика | Значение |
|---|---|
Всего строк, все файлы (wc -l) | 43 179 595 |
| Общее количество строк, с учётом исходного кода (tokei/scc) | ~42 583 000 |
| Строки исходного кода | ~32 400 000 |
| Комментарии строк | ~4 850 000 |
| Пустые строки | ~5 327 000 |
Разница между wc -l и tokei/scc | ~597 000 строк (несорс-файлы и файлы, классифицированные иначе инструментами, распознающими язык) |
| Самый большой драйвер | AMDGPU + AMDKFD |
| Драйвер графики AMD | ~6,35 миллиона строк |
| Основной источник роста | Драйверы устройств |
| Очистка наследия | Продолжение удаления кода Intel i486 и устаревших драйверов |
| Оценочная стоимость разработки | ~$1,47 миллиарда (COCOMO, через scc) |
Заключение
Превышение 42 миллионов строк — это больше, чем просто интересная статистика. Это отражение масштаба одного из крупнейших совместных программных проектов в мире.
Сопровождающие ядро Linux продолжают добавлять поддержку нового оборудования. В то же время они удаляют код для платформ, срок службы которых подошел к концу. В результате получается ядро, которое растет там, где это необходимо, и становится чище там, где это возможно.
Для энтузиастов Linux этот этап является очередным напоминанием о том, как быстро развивается ядро. Он также показывает, сколько работы идет на поддержку всего, от крошечных встроенных плат до самых быстрых суперкомпьютеров в мире.
Источник:
- Linux 7.2 Превысил Более 43 Миллионов Строк В Дереве Ядра