CLI приложения #28. JIT против Native AOT: сравниваем на практике
В предыдущей части мы разобрались, чем отличается привычная компиляция с JIT от Native AOT, какие преимущества даёт предварительная компиляция в машинный код и почему использовать её повсеместно — не самая лучшая идея. Но теория теорией, а мне стало интересно, насколько велика разница на практике. Причём не на очередном Hello World, который ничего полезного не делает, а на настоящем CLI-приложении.
Для эксперимента я взял один из своих проектов — CodeLines. Это небольшая утилита для подсчёта строк исходного кода. Она умеет сканировать каталоги, исключать ненужные файлы, сохранять историю и сравнивать результаты предыдущих запусков. Приложение существует уже довольно давно, поэтому перед экспериментом пришлось немного привести его в порядок, обновить зависимости и адаптировать к актуальной версии System.CommandLine. В результате мы получили вполне подходящий пример для сравнения.
И результаты оказались довольно любопытными.
Что будем сравнивать?#
Я подготовил три варианта одного и того же приложения:
**JIT-FDD**— обычнаяframework-dependentсборка, для запуска которой требуется установленный.NET Runtime.**JIT-SCD**—self-containedсборка, содержащая необходимые компоненты среды выполнения.**Native AOT**— нативный исполняемый файл, подготовленный заранее, без необходимостиJIT-компиляции при запуске.
Все три варианта собраны для Windows x64 в конфигурации Release на .NET 10. Для чистоты сравнения отключены ReadyToRun и упаковка в single-file. Почему именно три варианта? Потому что хотелось отделить влияние способа компиляции от способа распространения приложения. Например, self-contained сам по себе не означает, что приложение использует Native AOT.
Как проводились измерения#
Эксперимент выполнялся на Windows x64 с .NET SDK 10.0.404.
Для каждого варианта использовались одинаковые наборы тестовых файлов:
| Набор | Файлов | Строк кода |
|---|---|---|
| Small | 20 | 480 |
| Medium | 500 | 12 000 |
| Large | 5 000 | 120 000 |
Размер исходных данных составлял от 20 КБ до 5,12 МБ.
Измерялось полное время работы процесса: от запуска приложения до его завершения. Для каждого сценария выполнялись два прогревочных запуска и десять измеряемых. В таблицах ниже приведены медианные значения, без учёта прогревов.
В итоговом эксперименте порядок запуска трёх вариантов чередовался, чтобы уменьшить влияние того, какая сборка выполнялась первой.
Но здесь есть важное уточнение: мы измеряем не чистую скорость выполнения машинного кода и не отдельно время запуска CLR, а всё время работы приложения, включая инициализацию, чтение файлов и прочие операции. Кроме того, файловый кеш Windows специально не очищался, а сам эксперимент проводился одной серией. Поэтому результаты стоит рассматривать как практическое сравнение конкретной утилиты в конкретных условиях, а не как универсальный рейтинг JIT и Native AOT.
Начнём с простого: --help#
Первым делом я измерил время выполнения команды --help. Здесь приложение практически не выполняет полезной работы: запускается, формирует справку и завершается. Именно поэтому такой сценарий хорошо показывает накладные расходы короткоживущей CLI-утилиты.
Получилось следующее:
| Вариант | Время |
|---|---|
JIT-FDD |
83,20 мс |
JIT-SCD |
86,30 мс |
Native AOT |
11,79 мс |
Разница впечатляющая: Native AOT выполнил команду примерно в семь раз быстрее. Конечно, в абсолютных цифрах речь идёт всего о 70 миллисекундах. Пользователь при одиночном запуске может этого даже не заметить. Но если утилита вызывается многократно из скриптов или других приложений, такие задержки уже могут иметь значение.
А если приложение выполняет полезную работу?#
Теперь попробуем сканирование исходного кода. Для начала — небольшой каталог из 20 файлов.
| Вариант | Первое сканирование |
|---|---|
JIT-FDD |
141,15 мс |
JIT-SCD |
141,40 мс |
Native AOT |
34,82 мс |
Здесь Native AOT оказался примерно в четыре раза быстрее.
Но давайте увеличим количество файлов до 500.
| Вариант | Первое сканирование |
|---|---|
JIT-FDD |
1 375,69 мс |
JIT-SCD |
1 345,76 мс |
Native AOT |
1 202,85 мс |
Разница всё ещё есть, но теперь преимущество перед JIT-FDD составляет около 14%, а не 300–600%.
Почему так?
Потому что с увеличением объёма работы всё большую часть времени занимают операции самого приложения: обход каталогов, чтение файлов, обработка содержимого и сохранение результатов. А затраты на запуск процесса становятся относительно менее заметными. И здесь мы подходим к самому интересному результату.
5 000 файлов — неожиданная картина#
Увеличим набор до 5 000 файлов и 120 тысяч строк кода.
| Вариант | Время |
|---|---|
JIT-FDD |
53,277 с |
JIT-SCD |
53,971 с |
Native AOT |
53,167 с |
Практически одинаково! Разница между JIT-FDD и Native AOT составила около 0,2%. Для нашего эксперимента это слишком мало, чтобы уверенно говорить о преимуществе одного варианта. Здесь становится понятно, почему утверждение «Native AOT делает приложение быстрее» требует уточнений. Да, предварительная компиляция может существенно сократить время запуска. Но если приложение большую часть времени занято другой работой, экономия на старте практически растворяется в общем времени выполнения. Причём нельзя автоматически утверждать, что все эти 53 секунды приложение ожидало диск. Для такого вывода потребовалось бы отдельное профилирование. Мы измерили продолжительность процесса, а не распределение времени между файловыми операциями, вычислениями и другими действиями.

Повторные запуски#
У CodeLines есть ещё одна особенность: приложение сохраняет результаты сканирования и может использовать их при последующих запусках. Поэтому я отдельно проверил повторное сканирование небольшого каталога и запуск после изменения одного файла.
| Сценарий | JIT-FDD | JIT-SCD | Native AOT |
|---|---|---|---|
| Повторное сканирование | 127,99 мс | 130,12 мс | 17,88 мс |
| После изменения файла | 130,44 мс | 133,24 мс | 18,23 мс |
Здесь Native AOT снова оказался быстрее примерно в семь раз. На мой взгляд, это хорошо показывает, для каких задач он особенно интересен: короткие команды, быстрые повторные операции и инструменты, которые запускаются часто, но работают недолго.
Размер приложения и время сборки#
Производительность — не единственный критерий. Посмотрим, что получилось с размером дистрибутива.
| Вариант | Размер | Время публикации |
|---|---|---|
JIT-FDD |
0,69 МБ | 4,82 с |
JIT-SCD |
81,10 МБ | 5,49 с |
Native AOT |
28,30 МБ | 13,17 с |
Самый компактный вариант — JIT-FDD. Но здесь нужно помнить, что он не включает среду выполнения .NET. Поэтому сравнивать его напрямую с двумя автономными вариантами не совсем корректно. А вот между JIT-SCD и Native AOT разница уже интереснее: 81 против 28 МБ. Нативная сборка оказалась почти втрое компактнее. Правда, публикация заняла больше времени: около 13 секунд вместо 5–6. Для готового приложения, которое собирается один раз, а затем используется тысячи раз, это вряд ли станет серьёзной проблемой. Но в больших проектах время AOT-компиляции может быть существенно выше.

Отмечу, что размеры измерены для опубликованных каталогов, а время публикации — по одному запуску каждого варианта. Это не отдельный статистический бенчмарк процесса сборки.
Так что же выбрать?#
После этих экспериментов я бы не стал утверждать, что Native AOT однозначно лучше JIT. Скорее, результаты подтвердили то, о чём мы говорили в предыдущей части: всё зависит от характера приложения. Если вы разрабатываете небольшую CLI-утилиту, которая часто запускается, быстро выполняет задачу и завершается, Native AOT действительно может дать ощутимый выигрыш.
Если приложение обрабатывает большие объёмы данных, выполняет длительные вычисления или активно взаимодействует с файловой системой, преимущество может оказаться значительно меньше. А иногда JIT вообще будет предпочтительнее — например, из-за совместимости библиотек или особенностей оптимизации длительно работающего кода.
И ещё не забываем об ограничениях Native AOT: динамическая генерация кода, некоторые сценарии рефлексии и сериализации могут потребовать изменений в приложении. Поэтому подход довольно простой, но потребует времени: сначала проверяем, совместим ли проект с Native AOT, затем собираем оба варианта и измеряем реальные сценарии использования. А уже после этого решаем, стоит ли переходить.
Итого#
Наш эксперимент показал довольно любопытную картину. На коротких операциях Native AOT оказался быстрее примерно в 4–7 раз. На сканировании 500 файлов преимущество сократилось до 12–14%, а на 5 000 файлов практически исчезло. При этом нативная сборка оказалась значительно компактнее автономного JIT-варианта, хотя и потребовала больше времени на публикацию. Получается, что главное преимущество Native AOT для небольших CLI — не абстрактная «скорость машинного кода», а возможность уменьшить накладные расходы на запуск и выполнение коротких команд.
Исходники
CodeLinesдоступны на GitHub. В дальнейшем я планирую выложить и материалы эксперимента, чтобы результаты можно было воспроизвести самостоятельно.
На этом с JIT и Native AOT з акончим. Мы разобрались, чем отличаются эти подходы, и посмотрели на реальные результаты. Как оказалось, всё не так однозначно, как может показаться на первый взгляд.
А в следующей части вернёмся непосредственно к разработке CLI-приложений и поговорим об архитектуре. Ведь пока мы рассматривали отдельные возможности, наши примеры оставались достаточно небольшими. Но что делать, если команд становится много, появляется собственная бизнес-логика, зависимости и настройки? Не складывать же всё это в один огромный Program.cs?
Вот с этим и будем разбираться.