После шести месяцев разработки подготовлен (http://lists.llvm.org/pipermail/llvm-announce/2017-March/000... релиз проекта LLVM 4.0 (http://llvm.org/) (Low Level Virtual Machine) - GCC-совместимого инструментария (компиляторы, оптимизаторы и генераторы кода), компилирующего программы в промежуточный биткод RISC-подобных виртуальных инструкций (низкоуровневая виртуальная машина с многоуровневой системой оптимизации). Сгенерированный псевдокод может быть преобразован при помощи JIT-компилятора в машинные инструкции непосредственно в момент выполнения программы.
LLVM 4.0 стал первым выпуском в рамках новой нумерации версий (https://www.opennet.dev/opennews/art.shtml?num=45690), в которой решено уйти от разделения значительных и функциональных выпусков. Отныне в каждом функциональном обновлении будет меняться первая цифра (в сентябре состоится релиз LLVM 5.0.0, весной следующего года 6.0.0 и т.д.). Для обеспечения совместимости с существующими системами разбора номеров версий LLVM корректирующие обновления, как и раньше будут приводить к увеличению третьей цифры (4.0.1, 4.0.2, 4.0.3).
Из новых возможностей LLVM 4.0 отмечается использование статистики выполнения в оптимизаторе ThinLTO, более агрессивное устранение бесполезного кода, экспериментальная поддержка сопрограмм, экспериментальная поддержка целевой платформы AVR, улучшение совместимости с GNU ld и значиетельное увеличение производительности компоновщика LLD.Улучшения (http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes... в Clang 4.0:
- Добавлен атрибут diagnose-if (http://releases.llvm.org/4.0.0/tools/clang/docs/AttributeRef... позволяющем выводить предупреждения или ошибки, если вызов функции соответствует одному или нескольким условиям, определённым пользователем. Например:
void abs(int a)
__attribute__((diagnose_if(a >= 0, "Redundant abs call", "warning")));- Расширены средства девиртуализации (https://ru.wikipedia.org/wiki/%D0%A2%D0%... (замена непрямых вызовов на условное выполнение развёрнутых inline-блоков) при помощи новой опции "-fstrict-vtable-pointers (http://releases.llvm.org/4.0.0/tools/clang/docs/UsersManual....
- В оптимизатор ThinLTO (http://blog.llvm.org/2016/06/thinlto-scalable-and-incrementa... ("-flto=thin"), работающий на этапе связывания, добавлена поддержка учёта данных профилирования (PGO (https://ru.wikipedia.org/wiki/Profile-guided_optimization), Profile-guided optimization), накопленных в процессе выполнения программы, для более точного принятия решений об импортировании функций и продвижения косвенных вызовов между различными модулями. При включении отладочного режима (-g) существенно сокращено время сборки и уменьшен размер исполняемого файла;
- Представлен новый флаг компиляции "-Og", позволяющий выполнить оптимизацию с сохранением удобства отладки (в текущей версии опция аналогична применению режима "-O1";
- Добавлена опция "-MJ" для вывода БД компиляции в формате JSON для интеграции с существующими системами сборки;- Устранена порция ошибок в реализации OpenCL и добавлено новое OpenCL-расширение cl_khr_mipmap_image. Добавлен флаг "-cl-ext" для переопределения списка расширений, компилируемых для выбранной целевой платформы. Добавлены pragma OPENCL EXTENSION the_new_extension_name : begin/end для добавления собственных расширений OpenCL без правки кола Clang. В документацию Clang включено руководство (http://releases.llvm.org/4.0.0/tools/clang/docs/UsersManual.... по OpenCL;
- В статическом анализаторе улучшена поддержка кода, использующего gtest. Добавлена опция "--show-description" для вывода описаний дефектов в списке scan-build. Добавлены новые проверки: предупреждение при виртуальных вызовах из конструкторов и деструкторов, проверка синхронизированных копий свойств mutable-типов в Objective C, таких как NSMutableArray, проверка нежелательных сравнений NSNumber, CFNumberRef и других числовых объектов Cocoa со скалярными значениями;
- В linter clang-tidy добавлена (http://releases.llvm.org/4.0.0/tools/clang/tools/extra/docs/... большая порция новых проверок. В include-fixer обеспечена интеграция с Emacs;
Основные новшества (http://llvm.org/releases/4.0.0/docs/ReleaseNotes.html) LLVM 4.0:
- Добавлена экспериментальная поддержка сопрограмм (http://releases.llvm.org/4.0.0/docs/Coroutines.html), активируемая при указании опции "-enable-coroutines" или через API addCoroutinePassesToExtensionPoints;- Повышены требования к минимальным версиям компиляторов. Для сборки LLVM теперь необходимы как минимум GCC 4.8 и Visual Studio 2015;
- Обеспечена обработка invariant.group для различных базовых блоков, что сделало возможным выполнение девиртуализации виртуальных вызовов внутри циклов;
- В фазе агрессивного удаления мёртвого кода (https://ru.wikipedia.org/wiki/%D0%9C%D1%... (adce) реализовано удаление веток, не влияющих на поведение программы. Циклы оставляются по умолчанию, но они могут быть удалены при явном указании опции "-adce-remove-loops", если тело цикла не включает значимых операций.
- В утилиту llvm-cov добавлена возможность экспорта coverage-статистики в формате JSON. Кроме того, также улучшен вывод в формате HTML;URL: http://lists.llvm.org/pipermail/llvm-announce/2017-March/000...
Новость: http://www.opennet.dev/opennews/art.shtml?num=46181
LLVM — это хорошо. А еще лучше будет, когда со шлангом можно генту собрать, полностью.
Зачем?
> Зачем?Надо!
кому?
Мне
Собирай, я разрешаю. Патчи добавишь в апстрим. Потом займись поддержкой сборки icc - поинтереснее будет.
icc и правда интереснее, когда сделаешь?
> А еще лучше будет, когда со шлангом можно генту собрать, полностью.А что конкретно не собирается? Костыли для GCC?
ядро шлангом не собирается. Оно рассчитано на несовместимое нестандартизированное поведение gcc.
И каким теперь образом узнать, где поломали API?
Раньше API ломали при смене второй цифры, теперь первой :)
ну сделали нумерацию как у apple сейчас, с учетом того что пилят инженеры эпла молодцом, сделали себе удобно.
"...Повышены требования к минимальным версиям компиляторов. Для сборки LLVM теперь необходимы как минимум GCC 4.8 ..."Ого! а я-то думал он сам себя умеет собирать...
умеет.. clang 3.1 собирает.
Умеет. Даже кросскомпиляцию самого себя умеет. Но в большинстве случаев для бутстрапа используется gcc.
на macOS и *BSD не нужен gcc, для линукса жизненно необходимо как и часть системы.
> жизненно необходимо как
> и часть системы.Вы что-то путаете, гражданчик. GCC только для ядра нужен, из-за его (GCC) специфичных костылей.
да ты что? для начала глянь, сколько софта у тебя с libstdc++ слинковано, а потом уже чушь про "только для ядра" неси
> да ты что? для начала глянь, сколько софта у тебя с libstdc++
> слинковано, а потом уже чушь про "только для ядра" несиПри чём тут libstdc++? Это стандартная крестовая либа, да, она поставляется и собирается вместе с GCC, но у LLVM тоже есть libc++, на которую вполне успешно переползла фряха и которую вроде как юзает макось.
Но это всё лирика, суть же в том, что GCC умеет в GNU-специфичные расширения и инструкции, которые не являются частью стандарта языка, плюс для определённых конструкций GCC генерирует определённый ассемблерный код. И вот на эти особенности компиляции и гнутые расширения и завязана часть экосистемы линукса, в том числе ядро, иксы, часть иксодров, glibc и т.п..
вот когда во всех дистрибутивах все и вся будет собирано шлангом, тогда и можно будет говорить про "только ядро". а пока-что рановато
Ну, пол года назад на генте не удалось скомпилировать clang'ом только ядро, глибцы и какие-то сетевые библиотеки, а также poppler(целью было скомпилировать полностью укомплектованную плазму со всеми kde-applications). Сейчас возможно даже лучше стало.
В libcxx++ не нужен libstdc++
> В libcxx++ не нужен libstdc++xx++ - это уже четырежды плюс! Новый язык?
зачем этот шланг нужен вообще? Ресурсы процессора девать наверное сейчас некуда, мало жирных и тормозных описаний абстракций c++, так нужно ещё такты процессора забивать ненужной прослойкой эмулятора виртуального кода.
>зачем этот шланг нужен вообще? Ресурсы процессора девать наверное сейчас некуда, мало жирных и тормозных описаний абстракций c++, так нужно ещё такты процессора забивать ненужной прослойкой эмулятора виртуального кода.Какая-такая "прослойка", какие такты, какой эмулятор? То, что вы описываете - это какой-то корявых интерпретатор. Даже в версии JIT нет никаких "эмуляторов", байт-код компилируется в момент запуска и после этого является самым обыкновенным нативным кодом. Не нравится JIT, можно откомпилировать сразу нативный бинарник, такой же самый, как сделает GCC.
>> жирных и тормозных описаний абстракций c++ахахах - а в каких языках нежирные тогда - python? java?
>>> жирных и тормозных описаний абстракций c++
> ахахах - а в каких языках нежирные тогда - python? java?Pure C, Lua?
> Pure CТы знаешь современный компилятор Pure C, который не использует промежуточного кода для компиляции и при этом не только под x86 умеет генерить код?
Лучше не так, лучше спросить знает ли он компилятор Pure C(что это такое - не понятно), написанный не на C++ :)
Кто может объяснить, какой плюс от преобразования в машинные инструкции непосредственно в момент запуска? И так каждый раз, в каждый момент запуска. Зачем?
> Кто может объяснить, какой плюс от преобразования в машинные инструкции непосредственно
> в момент запуска? И так каждый раз, в каждый момент запуска.
> Зачем?Прежде всего - есть опция компилировать сразу в машинный код. Преимуществом jit является по большому счету портируемость и всяческие оптимизации. Если есть сферический компилятор С(++), то он откомпилирует программу под конкретную архитектуру и даже под конкретную ее версию. Например, под i386. Этот код не запустится под ARM и не сможет использовать какие-то наборы инструкций, например, MMX, которые появились позже i386, но которые возможно имеются на компьютере пользователя. JIT, теоретически, может обеспечить подобное (не надо мне рассказывать, что написание кросс-платформенного кода сложнее hello world'a - это нетривиальная задача, я в курсе). Помимо этого JIT-компиляторы имеют множество метрик и профилировщиков, которые могут каким-то образом оптимизировать результат в зависимости от определенных условий.
В случае LLVM это еще и множество бэкэндов, т.е. список аппаратных архитектур, в которые можно транслировать байт-код. То есть, есть 2 независимых процесса -- генерация байт-кода из языка программирования и генерация нативного кода из байт-кода. И поскольку байт-код универсальный, это дает возможность создать комбинацию компилятора языка и архитектуры, для которой классического компилятора не существует.
В случае LLVM байт-код не универсальный. Это не аналог JVM и CLR (хотя жаль).
>>В случае LLVM байт-код не универсальный. Это не аналог JVM и CLR (хотя жаль).Например?
Байткод LLVM как язык - кроссплатформенный. Байткод конкретных приложений, генерируемый Clang'ом - нет. Проблема тут в том, что код на C неизбежно привязывается к целевой платформе после того, как проходит стадию препроцессинга. И уже этот некроссплатформенный после-C компилируется в байткод.
Т.е. очень хорошо нацелен на решение задачи"как бы пошире распространять бинарники, не отдавая исходники"
Проприетарщина живет на паре-тройке аппаратных платформ, ей хватает. Плюс мобильники, но там вполне без шланга решены вопросы распространения.
>Т.е. очень хорошо нацелен на решение задачи
>"как бы пошире распространять бинарники, не отдавая исходники"Открою сейчас тайну - большинство пользователей Linux получают софт с открытыми исходниками в виде бинарников, кроме случаев типа Gentoo, которые как раз меньшинство. И когда собирают пакет, то его компилируют очень осторожно, образно говоря, чтобы он запустился и на 6 летнем Core2 Duo, и на свежем i7. Ни обладатели i7, ни обладатели свеженького AMD Ryzen ничего из их новых наборов команд использовать не смогут, т.к. выхлоп традиционного компилятора - это неизменный монолит, а вот JIT тут мог бы быть полезен. Это вряд ли мега-фича для большинства линукс-пакетов. Преимущества LLVM лежат больше в плоскости многообразия архитектур и языков программирования, ну и просто более свежий и чистый дизайн, который не имеет в себе 30 летнего наследия, как у GCC.
Write Once, Run Everywhere!
Все хорошо, заисключением одного момента - времени старта приложения
>Все хорошо, заисключением одного момента - времени старта приложенияДа, тут нужно найти баланс, взвесить за и против. Для сложного приложения, которое работает долго и получит преимущество, используя все аппаратные возможности ЦП, игра определенно стоит свеч - время старта несущественно на фоне времени работы.
Кстати, есть сценарии, когда JIT может сэкономить память - это жирные бинарники, содержащие в себе кучу кода. Допустим, запускается такой бинарник с определенными параметрами, это соответствует определенному графу выполнения программы. JIT компилирует код by demand - то есть не компилирует все сразу, а делает это по мере того, как требуется запускать все еще некомпилированный код. И если в данном сценарии требуется лишь маленький кусочек функциональности, то ровно на это кусочек увеличится memory footprint процесса. Полностью нативный бинарник будет загружен сразу же и полностью, даже если и 95% его не будет использована.
Не забывайте, что биткод(или байткод) в память загрузится полностью и будет отъедать её.
Плюс скомпилированные куски кода, что в сумме приведёт к большему потреблению памяти.
Ну и плюс ко всему этому -- память будет потреблять ещё виртуальная машина, которая будет осуществлять JIT компиляцию.
>> Не забывайте, что биткод(или байткод) в память загрузится полностью и будет отъедать её.Я могу ошибаться по поводу LLVM, но нет никакой необходимости грузить в память весь байткод. Это - всего лишь бинарные данные в файле, JIT их читает и аллоцирует память для результатов своей работы по мере продвижения. Это так даже в Windows, где раннер .net является частью загрузчика exe-файлов, которые можно запустить "дабл-кликом", без какого-либо внешнего раннера (как в java, например). Любой современный формат исполняемых файлов дает возможность создавать секции, которые вообще не будут спроцированы и загружены в адресное пространство процесса. Не говоря уже о бинарниках вроде джавовских.
Возможно вы правы.
Я тоже не знаю полностью они грузятся или частями по мере необходимости.
Конечно тут многое от виртуальной машины зависит.
Я думал, нативный бинарник сначала ммапится в память по определённым смещениям, и лишь потом загружается в память физически постранично по мере надобности. Неиспользуемые страницы, если что, могут быть "сброшены" обратно на диск.Может, вопрос больше в занимании памяти на диске этим разросшимся бинарником?
Оформить уже́ "докомпиляцию" (транслятор в инструкции местного CPU, назовите лучше) в post-install пакета. Профит (для ≈10% софта, где есть чего ловить). Неужели ещё не докумекали до такого варианта?
Сейчас для этого лепят 100500 precompiled вариантов (где совсем-совсем надо).
> Оформить уже́ "докомпиляцию" (транслятор в инструкции местного CPU, назовите лучше)
> в post-install пакета. Профит (для ≈10% софта, где есть чего ловить).
> Неужели ещё не докумекали до такого варианта?
> Сейчас для этого лепят 100500 precompiled вариантов (где совсем-совсем надо).АОТ. В Андроиде внедрили, в основной Жабе пытаются внедрить.
LLVM позволяет (пока реально в пакетах никто не пользуется, как и JIT).
> Все хорошо, заисключением одного момента - времени старта приложенияМожно сделать по типу АОТ - только один раз при инсталляции на конкретную архитектуру.
В этом смысле LLVM весьма гибкий.
> Все хорошо, заисключением одного момента - времени старта приложенияА разве LLVM сразу после окончания выполнения программы теряет уже скомпилированный нативный код? Насколько я помню описание LLVM, вроде ж сохранять должен.
Дисклеймер: LLVM не пользуюсь, только читал.
JIT хуже оптимизирует, т.к. работает в реальном времени и должен производить оптимизацию быстро.
Но с LLVM можно полученный биткод запустить не только через JIT, а полноценно скомпилировать под свою архитектуру.
При этом скорость компиляции должна быть намного быстрее, чем непосредственно из исходников, т.к. архитектурно-независимая оптимизация уже была проведена на этапе преобразования в биткод. И остаётся только архитектурно-зависимая оптимизация.Если бы появился дистрибутив, где пакеты распространялись бы в биткоде LLVM, то по скорости компиляции он был бы быстрее аналогичных действий в Gentoo, а по результату не хуже.
> JIT хуже оптимизирует, т.к. работает в реальном времени и должен производить оптимизацию
> быстро.Зависит от уровня абстракции байткода от нативного. В принципе, самые «жирные» оптимизации как раз делаются еще до или при преобразовании в байт-код.
Да и не нужно валивать все в кучу и сравнивать с JIТами JaбкоСкрипта, Луа, Питона и т.д., где JITу действительно нужно в реальном времени скомпилировать «от и до».
всё так, только про генту не надо - она вообще не о том
> выхлоп традиционного компилятора - это неизменный монолитВерно, но с небольшим уточнением. Многие С++ либы, в частности, криптогроафические пользуются такой фичей: https://gcc.gnu.org/wiki/FunctionMultiVersioning
> Открою сейчас тайну - большинство пользователей Linux получают софт с открытыми исходниками
> в виде бинарников, кроме случаев типа Gentoo, которые как раз меньшинство.
> И когда собирают пакет, то его компилируют очень осторожно, образно говоря,
> чтобы он запустился и на 6 летнем Core2 Duo, и на
> свежем i7. Ни обладатели i7, ни обладатели свеженького AMD Ryzen ничего
> из их новых наборов команд использовать не смогут, т.к. выхлоп традиционного
> компилятора - это неизменный монолит, а вот JIT тут мог бы
> быть полезен.Ну, в большинстве случаев AOT не является проблемой для пользователя. Чесслово, у меня i7 с 8ю потоками выполнения: я не сильно страдаю от того, что некоторые программы выполняются неоптимально. Критичные долгоработающие демоны можно и перекомпилировать, если что. Тут делов как бы не много: apt-get source, поправить флаги и pbuilder натравить. Но это, опять же, в исключительных случаях.
JIT, хоть и является весьма старой технологией, стал модным трендом относительно недавно.
В принципе, промежуточное представление компилируемой программы в байткоде есть и в GCC. Даже, если память не изменяет, их целых два: Generic и Gimple. После второго за дело берутся бэкенды, производящие компиляцию уже в конечную архитектуру.В общем, идеи-то старые. Если бы они были действительно востребованы, в GCC их бы реализовали уже давно. Однако на деле, влияние JIT-а не сильно сказывается на работе.
Популярность LLVM во многом обусловлена пермиссивной лицензией. Именно поэтому корпорации активно вбухивают деньги в проекты для него.
> Преимущества LLVM лежат больше в плоскости многообразия архитектур и языков программирования
Поподробнее можно?
Для этого AOT нужен, а не JIT. То есть оконяательная стадия компиляции на целевой машине - да, компиляция при каждом запуске - нет.
оптимизaция по sizeof(L!, L@, L#), хотя бы ?!
Никакого нет. Даже наоборот. Оптимизация на уровне абстрактной RISC-машины не исключает необходимости оптимизации для конкретной архитектуры, поскольку реальные архитектуры отличаются друг от друга более, чем существенно.
Парадигма LLVM позволяет быстро начать производить код для новых архитектур -- для этого достаточно написать эмулятор абстрактного RISC-процессора LLVM. Плюс здесь только один -- гибкость, а все остальное в минусах по самое горло. И среди этих минусов два очень важных -- время компиляции и качество оптимизации. С учетом того, что в процессе развития СВТ как памяти, так и производительности все более и более не хватает, с практической точки зрения парадигму LLVM нельзя считать хорошей.
>более агрессивное устранение бесполезного кодаСобираешь программу, а бинарник получаетя нулевого размера, и понимаешь что-то в этой жизни пошло не так :)
Не тем занимаешься в жизни, похоже.
>>более агрессивное устранение бесполезного кода
> Собираешь программу, а бинарник получаетя нулевого размера, и понимаешь что-то в этой
> жизни пошло не так :)Так это же будет идеальная программа - ни одной ошибки!
Ваш код был рассмотрен, проверен и вынесен вердикт - идите на курсы программирования в <здесь название школы, куда проприетарастский компилятор вас посылает оглядываясь на то какая школа заплатила за рекламу в вашем регионе>.
- Где у меня ошибка?
- В ДНК...
SystemD бы так собирать! :)
репы 3,9 4,0 5,0 для деба\\бунты
инвесторы любят большие числа, да.
> инвесторы любят большие числа, да.- График роста версий, уходящий в небеса.
LLVM 4.0 включен в базовую систему FreeBSD 11-STABLE.