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 и как их обнаруживать ещё на этапе разработки.