HWW Portfolio

Software and Hardware Developer

Инкрементальная сборка внутри компилятора: как sootc решает, что пересобирать

Большинство систем сборки задают один вопрос: изменился ли файл? Для sootc этот вопрос неправильный. В статье объясняется, почему инкрементальная компиляция должна жить внутри компилятора, как .bin-файл оказывается носителем собственного манифеста свежести и на какие компромиссы мы пошли по дороге.

Содержание

  1. Проблема
  2. Почему инкремент должен быть внутри компилятора
  3. .bin как манифест
  4. Два представления зависимостей
  5. Что считается «грязным»
  6. Режимы сборки, уровни API и пути
  7. Примеры
  8. Детерминизм
  9. Сборочные скрипты на самом soot
  10. Почему не раздельная компиляция и линковка?
  11. Что осталось
  12. Выводы

1. Проблема

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

Внешние системы сборки (Make, CMake, Ninja) умеют не пересобирать неизменившееся. Но они опираются только на две вещи: время модификации файлов (mtime) и явно объявленные зависимости. Что sootc делает внутри, им неизвестно.

Для C и C++ этого достаточно. gcc компилирует один .c в один .o, а зависимости выражаются через #include и генерируемые .d-файлы. Для sootc такая модель не работает, и это не мелкая деталь, а прямое следствие устройства компилятора.

2. Почему инкремент должен быть внутри компилятора

Когда sootc компилирует foo.sc, он делает гораздо больше, чем читает один файл:

  1. Загружает prelude (lib.st + lib.sc) в интерпретатор.
  2. Загружает в память bar.sc (и его зависимости).
  3. Строит дерево узлов для foo.sc в контексте уже загруженных зависимостей.
  4. Только после этого генерирует .bin.

Теперь представим, что CMake запускает sootc отдельно на каждый файл. Каждый процесс заново загружает bootstrap и заново разбирает все зависимости. Для проекта из десяти модулей это десять загрузок bootstrap и десять разборов одного и того же bar.sc. Выигрыш от «не пересобирать неизменившееся» съедается стоимостью повторного старта.

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

Именно поэтому в sootc появились:

3. .bin как манифест

В .bin уже есть запись requires: список имён модулей, от которых зависит файл. Она нужна загрузчику, который читает имена как обычные строки прямо из string pool, без SIDBase. Благодаря этому .bin остаётся самодостаточным.

Мы добавили вторую запись, build-info. Это фича компилятора, а не загрузчика: runtime её не читает. Она нужна только sootc, чтобы ответить на один вопрос: соответствует ли этот .bin по-прежнему своему исходнику и своим зависимостям?

Раскладка:

BuildInfo               (0x20)
DepEntry[num_deps]      (0x10 * num_deps)
struct BuildInfo {
    u64 source_hash;       // FNV-1a 64 от .sc
    u64 compiler_version;  // хеш версии компилятора
    u64 platform_hash;     // FNV-1a 64 от "linux"/"windows"/"darwin"
    u32 num_deps;
    u32 reserved;
};

struct DepEntry {
    sid64 name_sid;        // SID имени модуля (без .sc)
    u64   bin_hash;        // FNV-1a 64 от .bin зависимости
};

Ключевое решение: DepEntry хранит только sid64 имени и хеш .bin зависимости. Строки имён уже лежат в requires. Дублировать их в build-info незачем: это лишние байты и, что хуже, ещё одно место, где две копии могут разойтись.

4. Два представления зависимостей

Зависимости описаны дважды, и это сделано намеренно:

Проверка свежести, is_fresh, идёт от requires к build-info, и никогда наоборот:

  1. Берём requires.m_pNames[i], которая гарантированно является строкой.
  2. Вычисляем SID(name), детерминированный CRC64.
  3. Ищем в build-info.deps запись с этим sid64.
  4. Берём её bin_hash, строим путь к .bin по строке имени, хешируем файл и сравниваем.

Обратное направление (StringIdManager(d.name_sid) → строка) ненадёжно: SIDBase может не знать строку, get_string вернёт пустую строку, и проверка молча провалится. Именно чтобы этого не случалось, requires сделан строковым.

5. Что считается «грязным»

Модуль считается грязным, если выполнено хотя бы одно из условий:

Пока compiler_version это просто строка версии ("sootc-v1"). Включить в неё хеш содержимого lib.sc / lib.st — следующий шаг. Поле в формате уже есть, так что менять раскладку .bin не придётся.

6. Режимы сборки, уровни API и пути

Режимы

Режим задаётся через CLI, окружение (SOOT_BUILD_MODE), JSON-конфиг ("build-mode") или REPL: (opt "build-mode" "incremental").

Два уровня API

CLI устроен так же: sootc --incremental foo.sc пропускает входной файл, если он свежий.

Пути. project_root разрешается относительно директории soot.json (если путь относительный) или относительно CWD. out-dir и header-dir подчиняются тому же правилу: они разрешаются от json_dir, а не от project_root. Это важно, потому что артефакты сборки живут в отдельных папках и не обязаны лежать внутри дерева исходников. Значения из окружения и CLI разрешаются от project_root, так как о json_dir они ничего не знают.

7. Примеры

Явная команда на свежем модуле:

sc> (save-module "tests/foo")
; saved soot_gen/bin/tests/foo.bin
; OK: module 'tests/foo' saved

sc> (save-module "tests/foo")   ← второй раз
; saved soot_gen/bin/tests/foo.bin
; OK: module 'tests/foo' saved

save-module пишет каждый раз: это явная команда.

Проектная сборка, всё свежее:

sc> (save-module-deps "tests/foo")
; OK: module 'tests/foo' and dependencies saved   ← ничего не пишет, всё свежее

Грязный корень, свежая зависимость:

sc> (save-module-deps "tests/foo")
; saved soot_gen/bin/tests/foo.bin                 ← только foo
; OK: module 'tests/foo' and dependencies saved

Удалён bar.bin:

sc> (save-module-deps "tests/foo")
; saved soot_gen/bin/tests/bar.bin                 ← bar отсутствовал
; saved soot_gen/bin/tests/foo.bin                 ← foo грязный (зависимость изменилась)
; OK: module 'tests/foo' and dependencies saved

Обратите внимание, как вторая пересборка вытекает из первой: после регенерации bar.bin его хеш уже не совпадает с тем, что записан в build-info модуля foo, поэтому foo тоже пересобирается.

Из командной строки:

sootc --incremental soot_src/tests/foo.sc
# всё свежее: "Skipping soot_src/tests/foo.sc: up to date"

sootc --force soot_src/tests/foo.sc
# всегда компилирует

8. Детерминизм

Инкрементальная сборка не должна менять результат. Тест простой: чистая сборка (--force) и инкрементальная после серии правок должны давать побайтно одинаковые .bin-файлы.

Это работает, потому что идентификаторы строк вычисляются как CRC64 от самой строки, а значит, порядок компиляции не важен. Автогенерируемые имена лямбд (<base>::lambda#N) локальны для модуля и на результат не влияют.

Если тест когда-нибудь сломается, причина будет одной из трёх: порядок, скрытые входы (prelude, версия компилятора) или сам BuildInfo. Пока тест проходит.

9. Сборочные скрипты на самом soot

В sootc есть опция --do <script>: она выполняет скрипт в сессии компилятора до входных файлов. Это позволяет описать сборку на самом soot, а не на shell:

; build.sc
(require "tests/foo.sc")
(require "tests/bar.sc")
(save-module-deps "tests/foo")
(save-module-deps "tests/bar")

Запуск:

sootc --incremental --do build.sc

Компилятор один раз загружает prelude и зависимости, выполняет save-module-deps для каждого модуля и в режиме Incremental пересобирает только грязное. Логика инкремента та же, что и у одиночного save-module-deps, но проектная сборка теперь выражена как данные, а не как флаги CLI.

Именно это делает возможной проектную сборку без внешней системы сборки. CMake по-прежнему может запускать sootc --do build.sc одним правилом, но логика того, что собирать и в каком порядке, живёт в build.sc.

10. Почему не раздельная компиляция и линковка?

Теоретически «правильнее» было бы компилировать каждый файл независимо, а потом линковать. Тогда инкремент тривиален: файл изменился, пересобираем его, а линковщик соберёт остальное.

Мы пошли другим путём по трём причинам:

  1. Это намного сложнее. Нужны полноценный линковщик, разрешение символов, ABI и порядок инициализации. В sootc ничего из этого нет: модули загружаются в runtime по имени.
  2. Ошибки линковки отлаживать тяжелее всего. Они слабее всего связаны с чем-либо в исходнике. «Символ не найден» совсем не похоже на «в строке 42 забыли скобку». Они случаются реже, но когда случаются, разбираться с ними мучительно.
  3. В sootc «линковка» — это загрузка модуля в VM. Модули загружаются и компилируются отдельно, и это фича, а не баг: именно она обеспечивает интерактивное программирование, REPL и динамическую среду. Ощущение «модуль загрузился — значит, работает» входит в замысел.

Компилировать файл за файлом, таким образом, можно, и это уже работает: sootc foo.sc компилирует один файл. Просто это неэффективно для проекта, потому что каждый запуск заново грузит prelude и зависимости. Поэтому инкремент живёт внутри одного процесса компилятора, где всё это уже загружено.

Отдельный «брутфорс-режим» реализовывать не нужно: он уже есть. Ценность в том, чтобы один процесс умно собирал много файлов, и именно это делают save-module-deps, --do build.sc и --incremental.

11. Что осталось

12. Выводы

Решение не идеальное. Идеальное — независимая компиляция плюс линковка, но это намного сложнее, а ошибки линковки труднее разбирать. К тому же sootc по природе динамическая среда, где модули загружаются и компилируются отдельно, и это проектное решение, а не недостаток.

То, что мы сделали, — компромисс:

Решение простое: нет отдельного манифеста, нет fingerprint-файлов и (пока) нет depfile. Оно работоспособное: инкремент лучше всего окупается в проектах, где загрузка prelude занимает больше времени, чем компиляция одного модуля. И оно соответствует духу soot: данные (.bin, build.sc) вместо внешних инструментов, явные команды вместо магии.

Не идеально, но работает. И это, пожалуй, лучший компромисс для компилятора, который живёт в REPL и собирает проект изнутри себя.