InquirerDangerous heat index forecast in 3 PH areas on Nov. 17The Jerusalem PostUS releases details of Megaspeed probe, says investigation began in 2024PunchLagos ADC deputy gov candidate warns against rigging, dares riggersCNN TürkSAĞANAK ALARMI! 17 Kasım İstanbul hava durumu son dakika| Bugün hava nasıl olacak? Meteoroloji ve AKOM uyardı!ZDF heuteAktuelle Pressemitteilungen des ZDFNumeramaApple sera jugé en France pour obsolescence programmée en juin 2027 : que reproche-t-on à l’iPhone ?النهارخسارة سلتيكس تمنح سفنتي سيكسرز صدارة الشرقية وإمبيد يتألق بـ37 نقطةKhaosod EnglishThai doctor warns of four potential health risks from cheap tissue paper sold onlineComplete SportsFulham To Demand £50 For BasseyHet Laatste NieuwsWeer nieuwe namen voor Rock Werchter: onder meer JUNGLE en Froukje op de afficheSRF NewsNach Amoktat von Aarau – IV soll gefährliche Personen der Waffenbehörde melden dürfenNotJustOkUEFA Nations League: Quarter-final fixtures
The Daily Newsstand · Free, Always
Tuesday, November 17, 2026

Profile‑Guided Optimization в.NET runtime: как это устроено и чем отличается от Go compiler и HotSpot

Translate

Компилятор может многое узнать о программе, даже не запуская её. Но есть вещи, которые становятся понятны только под реальной нагрузкой — например, какой конкретный класс обычно скрывается за интерфейсом или какая ветка условия выполняется чаще.

Profile‑Guided Optimization (PGO) позволяет учитывать эту информацию при оптимизации. Компилятор получает профиль выполнения и на его основе решает, куда стоит потратить время и ресурсы, а какой код лучше оставить как есть. Разумеется, за это приходится платить: сбор статистики создаёт накладные расходы, а профиль не всегда точно отражает будущую нагрузку.

Меня зовут Дима Егоров. Раньше я разрабатывал на.NET, сейчас пишу на Java в Яндекс 360. Мне интересно, как устроены рантаймы и какие решения принимают JIT‑компиляторы: иногда знание этих деталей помогает разобраться с производительностью вполне обычного сервиса.

В статье покажу, что именно.NET узнаёт о работающем коде и как использует эти сведения. Затем сравню его подход с PGO в Go и с перекомпиляцией в Java HotSpot. По пути разберём девиртуализацию, инлайнинг, счётчики и on‑stack replacement — механизм, позволяющий переключиться на оптимизированный код, не дожидаясь следующего вызова метода.

Что такое Profile‑Guided Optimization

Сначала напомню, как работает JIT‑компилятор.NET. Он переводит промежуточный код IL во внутреннее представление (IR), выполняет оптимизации, затем переходит к более низкоуровневым преобразованиям: lowering, распределению регистров, размещению блоков и генерации машинных инструкций. В реальности этапов больше, но для нашей темы такой упрощённой схемы достаточно.

Основные этапы компиляции в JIT .NET

Основные этапы компиляции в JIT.NET

PGO не заменяет эти этапы и не добавляет отдельный «волшебный оптимизатор». При выборе оптимизаций компилятор может учесть, как часто выполняются разные участки кода.

Общая идея Profile-Guided Optimization: сбор профиля и использование его при оптимизации

Общая идея Profile‑Guided Optimization: сбор профиля и использование его при оптимизации

В бенчмарках компилятора Go сборка с PGO дала ускорение в нескольких сценариях. Но эффект зависит от программы и от того, насколько точно профиль отражает реальную нагрузку. Дополнительные примеры собраны в awesome‑pgo на GitHub.

Пример бенчмарков компилятора Go с PGO

Пример бенчмарков компилятора Go с PGO

Почему статического анализа недостаточно

Разработчик знает, как используется его приложение. При статическом анализе компилятор опирается на свойства, которые может вывести из кода. Например, мы можем знать, что два Span ссылаются на непересекающиеся области памяти. Для компилятора это не всегда очевидно: ему нужно сохранить правильное поведение и в остальных случаях.

Профиль отвечает на другой вопрос: не «что возможно?», а «что чаще всего происходит?». По профилю видно, какие ветки выполняются чаще и с объектами каких типов обычно происходит вызов через интерфейс. Даже если мы хорошо понимаем нагрузку на сервис, распределение типов в конкретном библиотечном методе может оказаться неожиданным.

Представим, что мы копируем данные:

[MethodImpl(MethodImplOptions.NoInlining)]
static void Copy(ReadOnlySpan<int> source, Span<int> destination)
{
    source.CopyTo(destination);
}

Допустим, в большинстве вызовов копируются десять чисел, то есть 40 байт. 

Представим, что JIT собирает статистику о том, сколько байтов копирует Span.CopyTo. Тогда он мог бы выделить быстрый путь для 40 байт и оставить универсальное копирование для остальных размеров.

// Псевдокод гипотетической специализации
if (byteCount == 40)
{
    // Копируем фиксированные 40 байт несколькими SIMD-инструкциями.
}
else
{
    // Используем общий Memmove для произвольного количества байтов.
}

На что потратить бюджет оптимизаций

Компилятор не может бесконечно встраивать методы друг в друга. У него есть ограничения по времени компиляции и размеру итогового машинного кода. Из‑за инлайнинга код может разрастись и хуже помещаться в кеш инструкций.

Это похоже на задачу о рюкзаке: нужно выбрать самые полезные преобразования, которые укладываются в бюджет. Только в компиляторе решения взаимосвязаны. Встроили один метод — появились новые возможности для свёртки констант. Упростили выражение — часть дальнейших оптимизаций стала не нужна.

Метафорическая задача о рюкзаке

Метафорическая задача о рюкзаке

Профиль не принимает решения за компилятор. Зато помогает понять, где более дорогая оптимизация может окупиться. 

Что JIT может оптимизировать по профилю

Девиртуализация и инлайнинг

Рассмотрим небольшой пример на C#:

public interface IWorker
{
    int Work(int x);
}

public sealed class Hot : IWorker
{
    public int Work(int x) => ((x + 1) * 3) - 7;
}

static int Run(IWorker worker, int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += worker.Work(i);

    return sum;
}

Из сигнатуры Run известно только, что worker реализует IWorker. Профиль может показать, что в точке вызова worker.Work(i) почти всегда встречается Hot.

Тогда JIT может применить guarded devirtualization: сначала проверить фактический тип, а при совпадении перейти к специализированному коду. Для остальных объектов сохранится интерфейсный вызов.

if (ExactType(worker) == typeof(Hot))
{
    // Реализация известна: вызов девиртуализирован,
    // а тело Hot.Work встроено прямо сюда.
    sum += ((i + 1) * 3) - 7;
}
else
{
    // Для остальных типов сохраняется интерфейсный вызов.
    sum += worker.Work(i);
}
    // Для остальных типов сохраняется интерфейсный вызов.
    sum += worker.Work(i);
}

Здесь работают две разные оптимизации. После проверки типа JIT знает, что на быстром пути worker.Work(i) вызовет Hot.Work. Это результат девиртуализации. Инлайнинг позволяет вставить тело Hot.Work прямо в цикл. Сам вызов исчезает, а JIT может оптимизировать встроенный код с учётом того, что известно в Run. Например, если аргументы — константы, результат можно вычислить ещё при компиляции:

// До инлайнинга:
int result = Multiply(10, 3);

// После:
int result = 10 * 3;

// После свёртки констант:
int result = 30;

Инлайнинг возможен не всегда, и сам по себе он ещё не гарантирует свёртку констант.

Быстрая проверка типа

Похожая идея пригодится для проверки obj is B. Предположим, C наследуется от B, а профиль показывает, что чаще всего в этом месте встречается именно C. Если точный тип объекта — C, можно сразу вернуть true:

// Псевдокод. C наследует B.
if (obj == null)
    return false;
if (ExactType(obj) == typeof(C))
    return true;
// Для остальных типов нужна общая проверка.
return GeneralTypeCheck(obj, typeof(B));

Даже на быстром пути, кроме cmp, могут понадобиться загрузки и переходы. Общая проверка нужна, когда быстрый путь не сработал. 

От интерфейсного вызова к устранению аллокации

Возьмём перечисление через IEnumerable<int>:

static int Sum(IEnumerable<int> values)
{
    int sum = 0;
    foreach (int value in values)
        sum += value;

    return sum;
}

За foreach здесь стоят GetEnumerator, последовательные вызовы MoveNext и Current, а в конце — Dispose. Если конкретный тип коллекции неизвестен компилятору, перечислитель в некоторых сценариях создаётся в куче или требует упаковки (boxing).

PGO может подсказать тип коллекции и перечислителя. Дальше JIT использует девиртуализацию, инлайнинг и анализ того, выходит ли объект за пределы метода (escape analysis). В отдельных сценариях это позволяет разместить перечислитель в стеке или вообще разложить его состояние по регистрам. Примеры таких преобразований есть в документе команды.NET о de‑abstraction и conditional escape analysis.

Возможность убрать аллокацию зависит от типа коллекции, доступной информации и версии рантайма. В документации приводятся как примеры успешного устранения аллокаций, так и случаи, где они сохраняются.

Другие практические примеры можно найти в разборах улучшений производительности.NET, которые публикует Стивен Туб.

Когда Go,.NET и HotSpot используют профиль

Главное различие между рассматриваемыми реализациями — когда собирают профиль и когда используют его для оптимизации.

Go обычно компилирует приложение заранее, в машинный код (AOT). CPU‑профиль собирают во время работы уже выпущенной версии сервиса. Затем передают его компилятору при следующей сборке, и оптимизации попадают в новый бинарный файл. Текущий процесс от этого сам по себе не меняется.

NET CoreCLR умеет использовать JIT‑компиляцию во время выполнения. Сначала метод может исполняться в более простой версии, затем рантайм собирает статистику и готовит более оптимизированную. В Java HotSpot тоже есть многоуровневая компиляция, а деоптимизация устроена иначе.

Упрощённое сопоставление AOT- и JIT-компиляции

Упрощённое сопоставление AOT‑ и JIT‑компиляции

На схеме показаны типичные конфигурации Go, CoreCLR и HotSpot. У.NET есть и Native AOT, а у Java — другие варианты исполнения и предварительной компиляции. Подробнее о Native AOT — в докладе «Native AOT. Возможности и ограничения».

Сборка с профилем в Go

Для PGO в Go используется CPU‑профиль в формате pprof. Снимаем профиль работающего сервиса под типичной нагрузкой. При следующей сборке go build подхватит default.pgo из каталога пакета main. Путь к другому файлу можно указать флагом -pgo.

Профиль строится по выборкам, поэтому можно обойтись без инструментирования каждой ветки. В выборках есть статистическая погрешность, а качество профиля зависит от того, под какой нагрузкой его сняли. Подробнее этот процесс описан в официальной документации Go.

Dynamic PGO в.NET: Tier 0 и Tier 1

В.NET профиль для Dynamic PGO собирается прямо в работающем процессе. Рантайм может отследить, какие участки кода выполняются чаще и какие типы там встречаются. Эти данные JIT использует при компиляции оптимизированной версии метода.

Сопоставление статического и динамического профилирования

Сопоставление статического и динамического профилирования 

При многоуровневой компиляции (tiered compilation) JIT обычно сначала быстро компилирует метод в Tier 0, чтобы тот мог начать выполняться без долгой оптимизации. Если метод вызывается часто, рантайм может собрать профиль и скомпилировать оптимизированную версию Tier 1.

Порядок не всегда одинаков. На него влияют настройки рантайма, наличие ReadyToRun‑кода и то, собирается ли профиль для этого метода.

Как CoreCLR переходит от Tier 0 к Tier 1 (упрощённая схема)

Как CoreCLR переходит от Tier 0 к Tier 1 (упрощённая схема)

Сравним ARM64-код двух версий метода: Tier 0 Instrumented и Tier 1 Instrumented. Обе версии ещё собирают статистику, но во второй JIT уже применил больше оптимизаций.

Tier 0 Instrumented:

G_M000_IG02:                 ;; offset=0x0018
    ldr     x0, [fp, #0x20]
    str     x0, [fp, #0x18]
    ldr     x0, [fp, #0x18]
    movz    x1, #0x6EC0
    movk    x1, #0xBB2 LSL #16
    movk    x1, #1 LSL #32
    bl      CORINFO_HELP_CLASSPROFILE32
    ldr     x0, [fp, #0x18]
    str     x0, [fp, #0x10]
    ldr     x0, [fp, #0x10]
    movz    x11, #464
    movk    x11, #0xA4B LSL #16
    movk    x11, #1 LSL #32
    ldr     xip0, [x11]
    blr     xip0

Tier 1 Instrumented:

G_M000_IG02:                 ;; offset=0x0010
    mov     x0, x19
    movz    x1, #0x9CB0
    movk    x1, #0x8E5 LSL #16
    movk    x1, #1 LSL #32
    bl      CORINFO_HELP_CLASSPROFILE32
    mov     x0, x19
    movz    x11, #208
    movk    x11, #0x782 LSL #16
    movk    x11, #1 LSL #32
    ldr     xip0, [x11]
    blr     xip0

В первом фрагменте заметно больше обращений к стеку: по обращениям [fp, #...] видно, где ldr читает из стека, а str пишет в него.

В обеих версиях остался вызов CORINFO_HELP_CLASSPROFILE32. Эта функция собирает сведения о типе объекта в точке вызова. Обе версии инструментированы: они собирают профиль для дальнейшей оптимизации.

Чем отличается Java HotSpot

Допустим, JIT в.NET уже подготовил оптимизированную версию Tier 1 с учётом собранного профиля. При обычной многоуровневой компиляции она не будет автоматически пересобираться при каждом изменении распределения типов. Если проверка типа не проходит, код выполняется по общему пути.

HotSpot может действовать иначе: если тип объекта оказался другим, чем предполагал JIT, рантайм способен деоптимизировать код, восстановить состояние выполнения и позднее скомпилировать метод повторно с учётом нового профиля.

Упрощённое сравнение многоуровневой компиляции в .NET и HotSpot

Упрощённое сравнение многоуровневой компиляции в.NET и HotSpot

Вернёмся к IWorker, теперь на Java:

interface IWorker {
    int work(int x);
}

final class Hot implements IWorker {
    public int work(int x) {
        return ((x + 1) * 3) - 7;
    }
}

static int run(IWorker worker, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += worker.work(i);
    }
    return sum;
}

Предположим, во время прогрева run получал только объекты типа Hot, и компилятор C2 решил встроить Hot.work. Вот как может выглядеть run после такого встраивания:

int run(IWorker worker, int n) {
    int sum = 0;
    if (n <= 0)
        return sum;

    if (worker == null || worker.getClass() != Hot.class) {
        uncommon_trap_and_deopt();
    }

    for (int i = 0; i < n; i++) {
        sum += ((i + 1) * 3) - 7; // inlined Hot.work(i)
    }
    return sum;
}

Что будет, если вместо объекта Hot передать Cold? Проверка не пройдёт. HotSpot может деоптимизировать код, восстановить состояние вызова и продолжить выполнение в интерпретаторе. Если метод скомпилируют заново, компилятор сможет учесть обновившийся профиль — например, подготовить специализированные ветки для двух типов:

// Псевдокод возможной новой специализации.
if (worker.getClass() == Hot.class) {
    // Быстрый путь для Hot.
} else if (worker.getClass() == Cold.class) {
    // Быстрый путь для Cold.
} else {
    // Общий путь или деоптимизация.
}

Число типов, которые HotSpot может сохранить в профиле одной точки вызова, ограничивает параметр TypeProfileWidth. В.NET количество проверок для guarded devirtualization также настраивается, например параметром DOTNET_JitGuardedDevirtualizationMaxTypeChecks.

CoreCLR чаще сохраняет общий путь рядом с быстрым, а HotSpot способен отменить спекулятивную оптимизацию и заново скомпилировать метод с обновлённым профилем. Это не значит, что один рантайм всегда быстрее другого: цена и выгода зависят от поведения приложения.

Откуда берётся профиль: инструментирование и семплирование

Инструментирование в.NET

Для динамической PGO JIT может вставлять в выполняемый код дополнительные операции: счётчики переходов и вызовы помощников, которые записывают типы объектов. Разберём это на знакомом примере:

public static int Run(IWorker worker, int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        sum += worker.Work(i);
    }

    return sum;
}

После инструментирования в промежуточном представлении JIT перед worker.Work(i) появляется вызов помощника, который записывает тип worker. Ниже — сокращённое дерево IR для этого участка метода:

STMT
└── STORE_LCL_VAR int V02 loc0
    └── ADD int
        ├── LCL_VAR int V02 loc0
        └── CALLV stub int IWorker:Work(int):int:this
            ├── COMMA ref [this]
            │   ├── STORE_LCL_VAR ref V05 tmp1
            │   │   └── LCL_VAR ref V00 arg0
            │   └── COMMA ref
            │       ├── CALL help void CORINFO_HELP_CLASSPROFILE32
            │       │   ├── LCL_VAR ref V05 tmp1 [arg0]
            │       │   └── CNS_INT long 0x10b5bd920 [arg1]
            │       └── LCL_VAR ref V05 tmp1
            └── LCL_VAR int V03 loc1 [arg1]

Здесь этот помощник обозначен как CORINFO_HELP_CLASSPROFILE32. Перед интерфейсным вызовом этот помощник получает ссылку на объект и данные, необходимые для записи профиля. Так рантайм узнаёт, какого типа объект в этой точке вызова.

Дополнительные узлы IR превращаются в машинные инструкции. Пока метод собирает профиль, он выполняет эти инструкции при каждом проходе через инструментированный участок. Последующая оптимизация может окупить эти затраты.

Почему неточные счётчики бывают полезнее точных

Пусть JIT хочет знать, сколько раз выполнялся участок кода. Самый простой вариант — count++. Он дешёвый, но, если несколько потоков пишут в одну переменную без синхронизации, часть инкрементов потеряется.

Interlocked.Increment обновляет счётчик атомарно, поэтому инкременты не теряются. lock тоже обеспечивает синхронизацию, однако добавляет свои расходы. Потоки могут конкурировать за одну строку кеша, даже если атомарная операция обходится без блокировки в ядре ОС.

Потоки могут конкурировать за одну строку кеша, даже если атомарная операция обходится без блокировки в ядре ОС.

А нужна ли компилятору точность до единицы? Для выбора горячих и холодных путей чаще достаточно хорошей оценки. Поэтому в.NET описан механизм scalable approximate counting: когда значение счётчика растёт, его обновляют реже, но а одно обновление прибавляют больше.

Текущее значение

Сколько прибавляем

Вероятность обновления,%

Меньше 8192

1

100

8192–16 383

2

50

16 384–32 767

4

25

32 768–65 535

8

12,5

При таком выборе вероятности математическое ожидание прибавки за один вызов остаётся равным единице. Зато потоки реже записывают новое значение счётчика.

Упрощённая реализация идеи на C#:

static void Count(ref uint sharedCounter)
{
    uint currentCount = Volatile.Read(ref sharedCounter);
    uint delta = 1;

    if (currentCount >= 8192)
    {
        int logCount = 31 - (int)uint.LeadingZeroCount(currentCount);
        delta = 1u << (logCount - 12);

        uint random = (uint)Random.Shared.NextInt64(
            0, uint.MaxValue + 1L);

        if ((random & (delta - 1)) != 0)
            return;
    }

    Interlocked.Add(ref sharedCounter, delta);
}

В листинге показана только вероятностная часть алгоритма CoreCLR.

В эксперименте получились такие результаты:

Interlock => Expected: 1,200,000,000
             Actual:   1,200,000,000
             Elapsed:  20185.548 ms

Racy      => Expected: 1,200,000,000
             Actual:   138,526,798
             Elapsed:  987.4997 ms

Scalable  => Expected: 1,200,000,000
             Actual:   1,193,541,836
             Elapsed:  1082.8471 ms

В этом запуске вероятностный вариант оказался почти таким же быстрым, как несинхронизированный, но заметно ближе к ожидаемому значению. Не стоит переносить эти миллисекунды на любую программу: результаты зависят от оборудования, числа потоков и характера нагрузки. Подробности алгоритма — в дизайн‑документе Scalable Approximate Counting.

Как сократить количество счётчиков

Ещё одна возможность сэкономить — не измерять то, что можно вычислить. Если в блок управления вошли тысячу раз и девятьсот раз ушли по ветке true, для простой развилки число переходов по false можно восстановить: 1000 − 900 = 100.

Та же идея работает и на уровне графа потока управления. Частоты рёбер связаны балансом входящих и исходящих переходов. JIT может оставить счётчики только на части рёбер, а остальные значения восстановить по этим соотношениям. Для выбора измеряемых рёбер JIT строит остовное дерево графа. Часть счётчиков можно убрать: число переходов по этим рёбрам JIT восстановит по остальным..

Go: выборки стека вместо счётчика на каждой ветке

В Go для PGO обычно используют CPU‑профили pprof. Во время профилирования рантайм периодически собирает стеки выполнения. Вот фрагмент обработчика SIGPROF в рантайме Go на Unix‑платформах:

if sig == _SIGPROF {
    if !delayedSignal && validSIGPROF(mp, c) {
        sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, mp)
    }
    return
}

Счётчики показывают, сколько раз программа прошла по ветке. Выборки стеков помогают оценить, где она проводит процессорное время.

On‑stack replacement: новый код посреди цикла

Что, если метод вызывают всего один раз, но работает он очень долго? Обычная смена версии между вызовами тут не поможет. On‑stack replacement (OSR) позволяет перейти на оптимизированный код прямо во время этого вызова.

Возьмём тот же Run:

public static int Run(IWorker worker, int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += worker.Work(i);

    return sum;
}

Run может вызываться один раз, а затем пройти огромное количество итераций. Не хотелось бы ждать завершения цикла, чтобы получить преимущества JIT‑оптимизации.

Сначала собираем профиль

При определённых условиях рантайм сразу готовит инструментированную версию метода. В цикле появляются счётчики, профиль типов и точка, в которой можно проверить возможность перехода к новому коду:

// Псевдокод Tier 0 Instrumented.
int Run(IWorker worker, int n)
{
    int sum = 0;
    int i = 0;
    int patchCountdown = 1000; // Условное значение для примера.

    while (true)
    {
        if (--patchCountdown <= 0)
            CORINFO_HELP_PATCHPOINT(ref patchCountdown, /* ... */);

        if (i >= n)
            break;

        ProfileCount(loopBody);
        ProfileType(worker);

        sum += worker.Work(i);
        i++;
    }

    ProfileCount(loopExit);
    return sum;
}

Здесь ProfileType обозначает сбор сведений о типе объекта, ProfileCount — подсчёт выполнения участков кода. CORINFO_HELP_PATCHPOINT передаёт управление рантайму, чтобы тот мог проверить, пора ли переключиться на оптимизированный код. ProfileCount и ProfileType — условные обозначения в псевдокоде.

Затем продолжаем с того же места

Когда появляется оптимизированная OSR‑версия, запускать Run заново нельзя: мы потеряем уже накопленную сумму и повторно пройдём обработанные элементы. Нужно перенести состояние выполняющегося метода, в том числе значения i и sum.

Вот как это выглядит в псевдокоде:

// Псевдокод. Параметры i и sum обозначают переданное
// состояние текущего вызова, а не реальную сигнатуру OSR.
int Run_Tier1_OSR(IWorker worker, int n, int i, int sum)
{
    if (i >= n)
        return sum;

    if (worker != null && ExactType(worker) == typeof(Hot))
    {
        do
        {
            sum += ((i + 1) * 3) - 7;
            i++;
        }
        while (i < n);

        return sum;
    }

    // Общий путь дан в сокращённом виде.
    while (i < n)
    {
        sum += worker.Work(i);
        i++;
    }

    return sum;
}

Профиль указал на Hot, проверка типа ограничила быстрый путь объектами Hot, девиртуализация и инлайнинг позволили убрать интерфейсный вызов из горячего цикла, а OSR дал возможность использовать новый код, не дожидаясь завершения текущего вызова.

Для новых вызовов рантайм может использовать обычную оптимизированную версию метода Tier 1.

Цена динамической PGO

Прогрев. Новому процессу нужно время, чтобы собрать статистику и скомпилировать горячие методы. В первые секунды или минуты работы поведение приложения может отличаться от установившегося режима.

Повторная работа в нескольких экземплярах. Если сервис запущен в десятках контейнеров, каждый экземпляр может собирать собственный профиль и оптимизировать те же методы независимо от соседних.

Стоимость ранних версий кода. JIT тратит меньше времени на компиляцию Tier 0, поэтому на этом уровне код оптимизирован слабее. В инструментированной версии к этому добавляются расходы на сбор профиля.

Что показывают бенчмарки.NET

На графике ниже сравниваются варианты выполнения простого HTTP‑обработчика:

app.MapGet("/plaintext", () => "Hello, World!");

В этом конкретном измерении инструментированный Tier 0 заметно уступает оптимизированным версиям. А разница между двумя вариантами Tier 1 — с PGO и без — намного меньше. Но это результат одного сценария, а не общая оценка пользы PGO: в других тестах влияние профиля может быть существенно больше или почти отсутствовать.

На графике один сценарий — обработчик /plaintext. Под другой нагрузкой эффект PGO может быть заметнее или почти исчезнуть.

Выводы о работе с PGO

Мне в PGO интересен момент, когда наблюдение за программой меняет решение компилятора. В примере с IWorker предположили, что в точке вызова чаще всего встречается Hot. Если профиль это подтвердит, JIT может проверить тип, встроить Hot.Work и убрать интерфейсный вызов из горячего цикла.

В Go CPU‑профиль обычно пригодится при следующей сборке. CoreCLR может использовать собранные данные в том же процессе, а с OSR — переключиться на оптимизированный код прямо посреди цикла. HotSpot тоже работает с профилем во время выполнения. Если предположение JIT о типе объекта перестаёт выполняться, HotSpot может деоптимизировать код и позже скомпилировать метод заново.

Когда я смотрю на бенчмарк JIT, первым делом проверяю, успело ли приложение прогреться к началу замеров. Сразу после запуска и после прогрева рантайм может выполнять разные версии одного и того же метода. А если хочется понять, сколько дал именно профиль, в нашем примере с ASP.NET я бы смотрел на две линии Tier 1 — с PGO и без него.

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.