Недавно Дэн Лу опубликовал статью «Теперь ничто не мешает программам быть быстрыми» (оригинал). В ней он рассуждает о том, насколько благодаря большим языковым моделям (LLM) подешевели самые разные задачи: от разработки специализированных решений — например, JIT‑компиляторов и индексов для поиска — до оптимизации под конкретную рабочую нагрузку.
Мы пока не настолько продвинулись, чтобы захотеть писать всё на ассемблере, но нечто похожее на то, что Нолан Лоусон сказал о тестировании — теперь вы сами можете выбирать, сколько ошибок вам нужно, — а я сформулировал менее изящно, становится всё более справедливым и в отношении производительности.
Мне представляется, что за этим утверждением стоят благие намерения, но само оно неверно. Примерно так же, как неверно, при всей благожелательности посыла, утверждение Лоусона. И так же, как, по‑моему, ошибаются сторонники формальных методов, предсказывающие, что всё большая доля1 (здесь и далее сноски — в конце текста — прим. переводчика) программного обеспечения будет проходить формальную верификацию.2
По сути, во всех этих случаях приводится примерно один и тот же довод3:
Раньше получение желаемого свойства X стоило A долларов при бюджете B, то есть A превышало B.
До появления LLM от свойства X отказывались именно потому, что расходы не укладывались в бюджет.
После появления LLM стоимость получения X снизилась до A/N, а это меньше B, поскольку N намного больше единицы.
Если все эти предпосылки верны, теперь на получение X станут тратить A/N.
На первый взгляд рассуждение выглядит вполне здравым, особенно если вы сами убедились, что LLM помогают улучшать свойство X.4 Но на практике оно работает лишь при условии, что все предпосылки действительно выполняются.
Я согласен: бывают ситуации, когда они выполняются. Станут ли опытные специалисты с глубокими знаниями предметной области — вроде тех, на кого ссылается Лу, — внедрять гораздо больше оптимизаций? Или работать в командах, которые выпускают намного больше оптимизаций, чем раньше? Да, думаю, именно так и будет.
Однако из того, что я наблюдаю, случаев, когда эти предпосылки не выполняются, гораздо больше.
Ниже я разберу несколько ситуаций, в которых они, по моему опыту, не срабатывают.
Готовность мириться с отсутствием свойства X растёт
Или, другими словами, потребность в X снижается.
Одно из изменений, связанных с появлением LLM, состоит в том, что работу, которую раньше выполняли синхронно, теперь порой приходится выполнять асинхронно: итерации агентного цикла занимают заметное время.
Например, в последнее время я занимаюсь ускорением git в нашем рабочем монорепозитории. Если бы в 2022 году мне показали нынешние показатели производительности — даже в удачный день — и сказали, что людей они вполне устраивают, я бы, скорее всего, посмотрел на собеседника с большим недоверием или недоумением.
Ещё один пример — автодополнение кода на основе LLM. Когда оно только появилось, задержка была намного больше, чем у обычного автодополнения в IDE.5 В то время на видеозаписях того, как разработчики пишут код в реальном времени, можно было заметить небольшие паузы: они ждали подсказок от модели. А ведь исторически автодополнение ценили в том числе именно за мгновенную обратную связь!
То же относится к скорости компиляции и компоновки, времени выполнения тестов и прочим подобным вещам. В целом люди совершенно по‑разному относятся к ожиданию при синхронной и асинхронной работе.
Если вы уделяете производительности много внимания, вам может быть трудно принять, что других вполне устраивает более медленная работа программ. Особенно когда вы и без того считаете это ПО «слишком медленным». Ещё обиднее, когда те же люди готовы терпеть замедление именно ради новых функций, а вы при этом уверены, что программа и так «слишком раздута».
Бюджет с самого начала был нулевым
Если выйти за пределы хорошо платящих технологических компаний, в которых к разработчикам относятся с уважением и предоставляют им достаточно самостоятельности, обнаружится, что во многих организациях разработку ПО воспринимают как центр затрат, а не как источник прибыли.
Там может вообще не быть непрерывной интеграции (CI): проверка качества целиком держится на ручном тестировании. А согласование бюджета способно тянуться целую вечность.
И при этом бизнес вполне может процветать! Например, у компании может быть монополия, предоставленная государством, или какой‑нибудь другой источник рыночной силы.
В организации, где все усилия направлены на сокращение расходов, убедить руководителя в окупаемости работ по оптимизации производительности, вероятно, будет непросто. И вполне возможно, что потраченные на это усилия лучше направить на что‑то другое.
После появления LLM бюджет сократили
Предположим, бюджет изначально всё‑таки был ненулевым. Например, каждый квартал вы выделяли на работу над производительностью примерно одну неделю.6
Но и здесь молчаливо предполагается, что после появления LLM бюджет B на получение свойства X остался прежним. На практике это предположение нередко оказывается неверным.
Если заглянуть в сабреддит r/experienceddevs, можно увидеть немало рассказов инженеров о том, как за последний год сроки проектов стали заметно жёстче: руководство ожидает, что благодаря LLM вся работа теперь должна выполняться гораздо быстрее.
Масштаб снижения затрат N переоценивают
Реализовать оптимизацию — одно дело. Внедрить её в активно используемую production‑систему — совсем другое. Ещё одна отдельная задача — создать механизм, который не позволит производительности незаметно ухудшиться в будущем. И ещё одна — сделать этот механизм надёжным, с минимальным числом ложных срабатываний и пропусков, достаточно быстрым и стабильным, чтобы он не требовал постоянного обслуживания.
В предыдущей статье о код‑ревью я приводил пример: коллега попытался сократить задержку одной операции, перенеся её в фоновый процесс, но тем самым повысил риск ошибки при захвате блокировки.
Вообще, человек, плохо знакомый с устройством системы, легко может взяться за «оптимизацию производительности» и заодно нарушить важные для корректной работы проектные решения.
Более заметный пример — Джарред Самнер, создатель Bun, у которого, как сообщалось, появился форк компилятора Zig с распараллеленными семантическим анализом и генерацией кода.
Мэтью Лагг, один из ключевых разработчиков Zig, объяснил, почему эти изменения нельзя принять в основной проект, даже если не учитывать политику Zig, запрещающую принимать код, созданный LLM:
Параллельный семантический анализ уже давно входит в планы развития компилятора Zig и существенно повлиял на архитектуру компилятора, написанного на самом Zig. Однако для корректной реализации этой возможности требуется изменить не только сам компилятор, но и язык Zig! Поэтому, чтобы внедрить её без лавины ошибок и несоответствий, нам необходимо изменить язык.
[…] Переработанная семантика разрешения типов как раз и была спроектирована так, чтобы избежать этих проблем. Но форк Zig от Bun не включает соответствующие изменения и никак иначе не решает архитектурных проблем. Следовательно, его реализация параллельного семантического анализа будет вести себя недетерминированно. Для большинства серьёзных разработчиков это практически сразу ставит крест на таком решении: никому не нужно, чтобы компиляция случайным образом завершалась непонятной ошибкой в 30% случаев.
На это можно посмотреть и с другой стороны: стоимость написания кода — лишь одна из составляющих общих затрат. И далеко не обязательно самая большая.
Вот два примера на более общем уровне:
-
Если большой объём данных уже хранится в формате, неудобном для эффективной обработки, при оценке стоимости оптимизации придётся учитывать их преобразование в подходящий формат. При этом необходимо сохранить надёжность, быстродействие и корректность существующих путей чтения и записи, а также перенести уже написанный код.
Хуже того, вы можете даже не знать обо всех местах, где данные читаются и записываются. Тогда сначала придётся потратиться на их поиск.
-
Если вычисления над данными оплачиваются по мере потребления ресурсов, эксперименты с разными стратегиями ускорения тоже могут обойтись дорого.
Допустим, нестабильная ошибка проявляется только в одном из тысячи запусков CI, а вне CI воспроизвести её не удаётся. Тогда стоимость вычислительного времени, необходимого, чтобы воспроизвести ошибку и собрать достаточно подробные сведения, легко превысит стоимость написания исправления.
Есть и связанная с этим проблема: трудно заранее оценить все будущие расходы на сопровождение. Сложные оптимизации затрудняют понимание кода; для поддержки системы могут понадобиться более опытные и дорогие специалисты, дополнительные проверки корректности и так далее.
Дело вообще было не в бюджете
На мой взгляд, полезнее рассуждать не о стоимости работ, а об их приоритете.
Для простоты возьмём команду, которая планирует работу спринтами. Допустим, до появления LLM каждый разработчик в среднем закрывал четыре задачи за спринт, а оптимизация производительности обычно занимала шестое место в его списке. При такой скорости она просто переходила бы из спринта в спринт, оставаясь на доске планирования скорее в качестве благого намерения.
Если ваш опыт похож на мой, наверняка вы видели задачи, которые кочевали между спринтами из‑за низкого приоритета, пока кто‑нибудь не говорил: «Слушайте, раз мы всё равно этим не занимаемся, значит, это не так уж важно. Может, просто закроем задачу как отменённую — хотя бы до тех пор, пока кто‑нибудь за пределами команды снова о ней не попросит?»
Теперь предположим, что благодаря LLM каждый разработчик успевает выполнить не четыре, а двенадцать задач за спринт. Останется ли список приоритетов прежним, просто команда начнёт брать больше задач из бэклога, чтобы всем хватило работы?
Подозреваю, для большинства ответ будет отрицательным. Если до появления LLM вам не удавалось убедить команду поднять приоритет работ над производительностью, непонятно, почему после появления LLM это вдруг получится. Конечно, можно заняться оптимизацией параллельно с основной работой — действовать по принципу «лучше потом попросить прощения, чем заранее разрешения». Но так можно было поступать и раньше.
Вернёмся к примерам Лу
Я хочу подробнее разобрать два примера из статьи Лу. В обоих случаях речь идёт о сложных задачах, причём исходный код доступен:
-
pgrust — переписывание PostgreSQL на Rust.
-
FRE — движок регулярных выражений, созданный агентом за месяц непрерывной работы.
Начнём с pgrust. Главное достижение проекта — впечатляющая производительность в ClickBench, якобы полученная благодаря оптимизациям с помощью LLM. Ещё один тезис состоит в том, что раньше разработчики баз данных якобы редко писали JIT‑компиляторы из‑за сложности этой работы, но LLM сделали её доступной.
Даже при беглом знакомстве с проектом трудно понять, какая часть его выдающейся производительности обусловлена действительно удачной архитектурой, которая хорошо покажет себя и на других нагрузках, а какая — оптимизациями, подогнанными под конкретный бенчмарк. Например, если посмотреть на модель стоимости выполнения запросов, окажется, что ClickBench там упоминается буквально повсюду.
А в наборе запросов для профильно‑управляемой оптимизации (PGO) встречается, например, такой:
-- A15 composite (smallint, string) group + countSELECT URLCategoryID, UTMSource, COUNT(*) AS n FROM hits WHERE UTMSource <> '' GROUP BY URLCategoryID, UTMSource ORDER BY n DESC LIMIT 12;
А вот строка 15 в наборе запросов ClickBench:
SELECT SearchEngineID, SearchPhrase, COUNT(*) AS c FROM hits WHERE SearchPhrase <> '' GROUP BY SearchEngineID, SearchPhrase ORDER BY c DESC LIMIT 10;
Если присмотреться, станет ясно, что по сути это один и тот же запрос. Изменены имена столбцов и немного — константа в LIMIT.
То же относится ко многим запросам из набора для PGO. Возможно, я неправильно интерпретирую увиденное, но для меня это выглядит как совершенно явная подгонка под бенчмарк.
Что касается утверждения, будто другие разработчики не пишут JIT‑компиляторы для баз данных, — существует как минимум несколько СУБД, в которых JIT уже реализован:
-
Umbra (HTAP) и её коммерческий форк CedarDB. Umbra сейчас занимает первое место в ClickBench, а CedarDB находится неподалёку от неё. В Umbra используется двухуровневая JIT‑компиляция: собственный компилятор для нижнего уровня и LLVM для верхнего. Генератор кода и компилятор вместе занимают около 40 тысяч строк исходного кода, включая заголовочные файлы, реализацию и тесты.
-
SingleStore (HTAP). В своей статье для SIGMOD 2022 её разработчики прямо ссылаются на работу о компиляции запросов в HyPer — предшественнике Umbra.
-
Amazon Redshift (OLAP). Компилирует запросы в C++.7
-
Apache Impala (OLAP). Генерирует промежуточное представление LLVM (LLVM IR).
Подозреваю, есть и другие примеры.
А вот что сказано в README проекта FRE:
FRE — движок регулярных выражений, созданный LLM при минимальном участии человека. Судя по всему, он переобучен под набор бенчмарков rebar от BurntSushi и в целом не отличается высокой производительностью, хотя в некоторых сценариях действительно работает довольно быстро. Подробнее см. эту публикацию. Иногда — но далеко не всегда — он быстр, если время компиляции не имеет значения и выбран режим AOT/Optimizing, в котором код компилируется заранее с оптимизациями. В других случаях высокая скорость часто объясняется довольно специфическими особенностями конкретной нагрузки.
Небольшой вопрос: попробуйте оценить, сколько строк исходного кода приходится на реализацию каждого из следующих проектов, если исключить сгенерированный код и тесты:
-
rust-lang/regex; -
danluu/fre.
Я попросил LLM оценить эти числа и получил 35 тысяч строк для rust-lang/regex и 670 тысяч для danluu/fre. Нет, лишний ноль здесь не затесался.
Для сравнения: компилятор Go вместе со стандартной библиотекой занимает около 680 тысяч строк исходного кода, если исключить сгенерированный код, тесты и каталоги с включёнными в проект сторонними зависимостями.
Лу объясняет, почему его устраивает такой подход:
Нет особого смысла использовать движок регулярных выражений, созданный на «фабрике ПО», если на контрольных бенчмарках он не превосходит хорошо протестированный движок. Однако у FRE была одна примечательная особенность: нативная AOT‑скомпилированная версия показывала очень хорошие результаты при длительном поиске. Мы обратили на это внимание и решили, что можно запустить компилятор нативного кода в отдельном потоке, пока ripgrep продолжает работать со своим обычным механизмом поиска, а после завершения компиляции переключиться на нативный код. В целом это должно повысить производительность. Разумеется, на коротких запросах производительность, скорее всего, снизится: один из потоков будет занят компиляцией. Но для меня гораздо важнее, сколько времени ripgrep тратит на поиск, который длится многие секунды или минуты, чем на поиск, занимающий всего несколько секунд. Поэтому такой компромисс меня устраивает.
Пожалуй, для некоторых поисковых запросов в этом есть смысл. Особенно если решение не добавляет сторонних зависимостей и все эти 670 тысяч строк кода не приходится часто перекомпилировать.
Но далеко не очевидно, что такой подход годится для программного продукта общего назначения, который разрабатывает команда, к которому предъявляются требования надёжности и за проблемы с которым отвечают конкретные сопровождающие разработчики.
Заключительные мысли
Во избежание недоразумений: я вовсе не хочу, чтобы программы работали медленнее или содержали больше ошибок.
В исторической перспективе инструменты для работы с производительностью постоянно совершенствуются. От браузерных DevTools до eBPF — на разных уровнях появляется всё больше средств, позволяющих разбираться в причинах замедления. Оборудование тоже становится быстрее.
В то же время, думаю, многие согласятся, что среднестатистическая программа становится всё медленнее и требовательнее к ресурсам, веб‑страницы — всё тяжелее и так далее.
Уверен, по крайней мере отчасти это действительно происходит.
Например, если вам доводилось пользоваться агентными инструментами для программирования, которые выпускают крупные разработчики моделей, вы наверняка замечали, насколько плохо они работают с точки зрения производительности, потребления ресурсов и количества ошибок — особенно с учётом того, насколько скромен набор возможностей самого инструмента, а не лежащей в его основе модели.
Я регулярно вижу, как настройка MCP и просто ожидание отклика терминального интерфейса (TUI) агента занимают больше времени, чем инкрементальная компиляция и повторная компоновка исполняемого файла в системе сборки проекта на C++ с несколькими миллионами строк кода.
При этом я готов допустить, что часть впечатлений об общем замедлении может быть иллюзией. Например, люди всех возрастов считают, что нравы пришли в упадок, хотя в действительности это не так. Вот как объясняется этот эффект:
[…] Два хорошо известных психологических явления могут вместе создавать иллюзию нравственного упадка. Первое — избирательное внимание: люди уделяют непропорционально много внимания негативной информации, а СМИ зарабатывают на том, что её поставляют. Второе — избирательная память: отрицательные эмоции от плохих событий со временем ослабевают быстрее, чем положительные эмоции от хороших. (Это называется затуханием аффекта, Fading Affect Bias; подробнее — в статье «Недооценённые идеи в психологии»)
Из‑за избирательного внимания кажется, что вокруг постоянно творится что‑то ужасное: убийства, поджоги, мошенничество — кошмар! А из‑за избирательной памяти вчерашние ужасы сегодня уже не выглядят столь ужасными. И вот когда в настоящем всё кажется кошмаром, а в прошлом — куда прекраснее, поздравляю, друг: у тебя возникла иллюзия нравственного упадка.
Так что, возможно, об этом стоит вспомнить, когда в следующий раз столкнётесь с медленно работающей программой. Потому что, нравится вам это или нет, по‑моему, сталкиваться с такими программами вы всё равно продолжите.
[1] Я намеренно говорю именно о доле. Если бы речь шла о количестве программ, спорить было бы, в сущности, не о чем.
[2] Чтобы не возникло недоразумений: я всячески поддерживаю улучшение тестирования, применение формальных методов и оптимизацию производительности! Я занимался всем этим на нескольких местах работы, в том числе на нынешнем. Просто я не согласен с такими прогнозами на будущее.
[3] Здесь я обозначаю затраты в долларах, но при желании вместо денег можно подставить «рабочее время инженера E».
[4] Возможно, вы уже подумали: «Но ведь здесь ещё предполагается, что люди принимают рациональные экономические решения и обладают полной информацией». Да, совершенно верно. Почти всю статью я буду исходить из этого допущения и показывать, почему даже при столь сильном предположении рассуждение может не работать. В реальности люди, разумеется, не всегда рациональны и не обладают полной информацией. Я оставлю это за рамками статьи — на эту тему и так много написано.
[5] Позже ситуация изменилась: Cursor и другие редакторы начали использовать небольшие специализированные модели, обеспечивающие более быстрое автодополнение.
[6] В зависимости от вашего опыта неделя за квартал может показаться как невероятной щедростью, так и смехотворно малым сроком. Я понимаю, что разброс здесь очень велик. 🙂
[7] Не уверен, можно ли считать это JIT‑компиляцией. По‑моему, да — просто через C++, но непонятно, согласился бы с этим автор pgrust.
ссылка на оригинал статьи https://habr.com/ru/articles/1109128/