CLI приложения #27. JIT против Native AOT: что выбрать?
В предыдущих постах мы разобрались, как собрать наше CLI-приложение, упаковать его и даже создать полноценный установщик. Но есть ещё одна интересная тема, которую мы пока практически не затрагивали, — компиляция.
Наверняка многие слышали про JIT и Native AOT. Особенно про последний: о нём довольно часто говорят в контексте производительности .NET-приложений. Мол, собрали приложение с Native AOT — и оно стало быстрее запускаться, меньше потреблять памяти и вообще работать лучше.
Но всё ли так просто? И зачем нам вообще менять привычный способ компиляции?
Как работает JIT?#
Когда мы компилируем приложение на C#, компилятор обычно не превращает исходный код непосредственно в машинные инструкции процессора. Вместо этого он создаёт промежуточный код — CIL (Common Intermediate Language), который часто называют просто IL. Этот код хранится в сборках .dll или .exe. А когда мы запускаем приложение, среда выполнения .NET загружает необходимые сборки, и в дело вступает JIT (Just-In-Time Compiler). Его задача — преобразовать IL в машинный код, который уже может выполнить процессор. Причём JIT обычно не компилирует всю программу сразу. Методы компилируются по мере необходимости, а в современных версиях .NET часто используется многоуровневая компиляция (Tiered Compilation). Сначала можно получить код быстрее, а затем оптимизировать часто выполняемые методы.
Это позволяет среде выполнения учитывать особенности конкретного процессора и поведение программы. Но за такую гибкость приходится платить: на запуск и компиляцию методов требуется дополнительное время и память. Для долго работающего веб-сервиса эти затраты могут оказаться относительно небольшими. А вот для CLI-утилиты, которая запускается, выполняет одну команду и сразу завершается, ситуация несколько другая.
А что делает Native AOT?#
AOT расшифровывается как Ahead-of-Time — компиляция заранее, до запуска приложения. При использовании Native AOT код преобразуется в машинные инструкции ещё на этапе публикации. В результате мы получаем нативный исполняемый файл, которому не нужен JIT для компиляции методов во время работы.
Для этого в .NET предусмотрен параметр PublishAot.
Например, для Windows:
dotnet publish -c Release -r win-x64 -p:PublishAot=true
В результате получим исполняемый файл, который не требует отдельно установленного .NET Runtime. Необходимые компоненты среды выполнения включаются в нативную сборку.
Но есть нюанс: для Native AOT нужны соответствующие нативные инструменты компиляции. Например, на Windows — компоненты компилятора и линкера C++, а на Linux — соответствующий toolchain.
И ещё одно отличие от обычного dotnet publish: напрямую собрать Native AOT для macOS из Windows стандартным способом не получится. Понадобится среда сборки на macOS.
Что мы получаем?#
Для CLI-приложений у Native AOT есть несколько интересных преимуществ.
Во-первых, скорость запуска. Поскольку не требуется JIT-компиляция методов при выполнении, приложение часто стартует заметно быстрее. Особенно это интересно для небольших утилит, которые запускаются сотни или тысячи раз.
Во-вторых, потребление памяти. Нативному приложению не нужна инфраструктура JIT во время выполнения, поэтому в ряде сценариев оно использует меньше памяти.
В-третьих, распространение. Мы получаем самостоятельный исполняемый файл без необходимости устанавливать .NET на компьютер пользователя. Правда, последнее преимущество не уникально для Native AOT: ранее мы уже собирали self-contained приложения, которые тоже работают без отдельно установленной среды выполнения.
А вот размер сборки — вопрос интересный. Native AOT использует анализ достижимого кода и удаление неиспользуемых частей приложения (trimming). Поэтому итоговый файл может оказаться существенно меньше обычной self-contained сборки. Но это не гарантировано. Размер зависит от используемых библиотек, платформы и самого приложения.
Почему тогда не использовать Native AOT всегда?#
Потому что у него есть ограничения. Главное связано с динамическими возможностями .NET. Представьте, что приложение во время работы получает имя типа, загружает неизвестную заранее сборку или пытается создать объект через рефлексию. При обычном запуске с JIT такие сценарии могут работать вполне нормально. А при Native AOT компилятор должен заранее определить, какой код понадобится приложению. Если необходимый код не удалось обнаружить при анализе, он может не попасть в итоговую сборку. Поэтому проблемы могут возникнуть с библиотеками, активно использующими рефлексию, динамическую генерацию кода и некоторые механизмы сериализации. Например, привычная сериализация через System.Text.Json с использованием рефлексии не подходит для Native AOT в том же виде, что и для обычного приложения. Вместо неё можно использовать генерацию метаданных сериализации на этапе компиляции — source generation. Кстати, именно поэтому при разработке библиотек всё чаще обращают внимание на совместимость с trimming и Native AOT.
Помните я говорил про одну из главных фишек
IronMapper- генерация кода? )) Так вот она в том числе используется дляNative AOTсборки. Всё для ускорения работы.
И ещё: быстрый запуск не означает, что вся программа обязательно будет работать быстрее. Для длительных вычислений JIT может применять оптимизации с учётом поведения программы во время выполнения. Поэтому результаты зависят от конкретной задачи.
Что выбрать для CLI?#
Я бы ориентировался прежде всего на то, как используется приложение.
| Сценарий | Что рассмотреть |
|---|---|
| Небольшая утилита, часто запускаемая из скриптов | Native AOT |
| Приложение, где важны скорость холодного старта и память | Native AOT |
| Сложный CLI с динамической загрузкой расширений | JIT |
| Инструмент с зависимостями, не совместимыми с AOT | JIT |
| Обычная утилита без особых требований к запуску | Начать с JIT |
При этом не нужно забывать, что JIT-приложение тоже можно распространять как self-contained или single-file. Поэтому выбор компиляции и способ распространения — связанные, но не одинаковые вопросы. Лично я бы не стал переводить каждый CLI-проект на Native AOT только потому, что такая возможность существует. Сначала стоит проверить совместимость библиотек, а затем сравнить реальные показатели.
Итого#
JIT и Native AOT — это не просто два режима сборки с разной скоростью запуска. Это разные подходы к подготовке и выполнению кода, каждый со своими преимуществами и ограничениями.
Для небольших CLI-утилит Native AOT действительно может оказаться очень удачным выбором. Но если приложение активно использует динамические возможности .NET, переход может потребовать существенной переработки кода или зависимостей.
И здесь возникает вполне закономерный вопрос: а насколько велика разница на практике?
В следующей части возьмём одно и то же CLI-приложение, соберём его в нескольких вариантах и сравним скорость запуска, размер файлов и потребление памяти. Заодно посмотрим, какие проблемы могут возникнуть при публикации с Native AOT и как их обнаруживать ещё на этапе разработки.