Подборку: Sorry, this page can’t be found.

Подборки — Яндекс Переводчик. Справка

Сохраняйте переводы в подборках: это поможет в изучении иностранных языков. Вы можете делиться своими подборками с пользователями или сами подписаться на их публичные подборки.

Чтобы просмотреть все доступные подборки, вверху страницы нажмите значок .

1. Сохранить перевод в подборку
2. Создать подборку
3. Подписаться на подборку
4. Учить слова
5. Решение проблем

Примечание. Чтобы работать с подборками и синхронизировать их между устройствами, войдите с Яндекс ID.

В окне с переводом нажмите значок . Сервис автоматически добавит перевод в общую подборку Избранное.

Если вы хотите сохранить перевод в другую подборку, во всплывающем окне нажмите Изменить подборку. Выберите нужную подборку или создайте новую.

Создать подборку можно не только при добавлении нового слова. Чтобы создать подборку:

1. В меню доступных подборок нажмите кнопку .

2. Назовите подборку.

3. Сделайте подборку публичной, если хотите поделиться ею с другими пользователями.

4. Нажмите Создать подборку.

Чтобы синхронизировать подборки на всех устройствах, войдите с Яндекс ID и нажмите кнопку .

Вы можете подписаться на тематические подборки, созданные командой Яндекс Переводчика или другими пользователями:

1. В меню доступных подборок перейдите в раздел Популярные подборки.

2. Выберите нужную подборку.

3. Нажмите кнопку Подписаться.

Вы можете использовать сервис для запоминания слов на иностранном языке:

1. В меню доступных подборок откройте свою подборку, подборку Избранное или любую подборку, на которую вы подписались.

2. Нажмите кнопку Учить слова.

3. Листайте карточки со словами и отслеживайте прогресс.

Не могу добавить слово или перевод в Избранное или в подборку

Возможные причины:

• Вы не авторизованы в сервисе. В правом верхнем углу нажмите  → Войти и выберите аккаунт.

• Исходный текст или перевод превышает максимально допустимый объем — 300 символов.

• Превышено максимальное количество слов в подборке. В каждой подборке может храниться не более 2500 переводов. Удалите старые записи и сохраните новые.

Не вижу своих подборок и подписок

Вы не авторизованы в сервисе. В правом верхнем углу нажмите  → Войти и выберите аккаунт.

Не синхронизируются подборки

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

Написать в службу поддержки

Qui-Quo — система создания подборок туров №1 в России и СНГ

Сагдеева Лариса, г. Курган, «Туристическая компания Азимут»

Как же перевернулся наш взгляд на подбор туров после знакомства с Qui-Quo!!! Когда он нам всё объяснил, показал все её возможности, мы были просто в шоке! Как мы раньше без Qui-Quo жили!!!

Очень много сейчас именно он-лайн туристов … а как много времени затрачивается на работу с такими туристами! Некоторые из них по 24 часа в сутки могут просить посчитать эту страну, ту страну…

Продолжение истории

Алиева Жанна, г. Москва, «Горячие туры пр. Вернадского»

Вот оно «Чудо»!!! Наконец-то кто-то позаботился о нас! Так приятно, что кто-то думает о нашем времени, об удобствах и о наших клиентах. Не знаю как я раньше жила без вашей программы, но как же приятно, когда заходишь подбирать туры по разным операторам и не нужно тебе копированием все куда-то переносить, сохранять, потом еще и не потерять все это!!! Ваша программа заменила все неудобные способы по поиску туров для клиентов.

Продолжение истории

Евгений Данилович, директор УК Слетать.ру

Сеть турагентств Слетать.ру с момента основания использует сервис Qui-Quo для составления качественных продающих подборок туров. Наши турагенты особенно отмечают его удобство, скорость работы и возможность добавления в рассылки индивидуального фирменного дизайна.

Некоторое время назад Слетать.ру и Qui‑Quo объединили усилия для расширения функциональности данного сервиса. Теперь российские турагенты…

Продолжение истории

Кустова Зоя, г. Краснодар, «Venera-Tour»

Вы реально упрощаете нам работу) Процесс отправки подборок клиенту стал НАМНОГО проще! Просто нажал галочку и все!! Не нужно выписывать на листик отель, даты, количество ночей и т.д. Одним кликом мы переносим то, что отправили туристам, в свою CRM.

Мы попросили сделать индивидуальный шаблон письма и теперь все подборки туристу…

Продолжение истории

Екатерина Рудас, г. Днепропетровск, «Экспресс-Тур»

Когда в нашем офисе программа Qui-Quo-Quo только появилась, часть наших сотрудников отнеслась к ней немного скептически. Считали они так примерно минут пять. Может даже семь.

Теперь же во время подбора туров практически всю работу за меня и моих коллег делает Qui-Quo — нам остается только задавать параметры поиска на сайтах и отмечать заинтересовавшие варианты…

Продолжение истории

Скорик Ульяна, г. Москва, «Лили Турс»

Первой мыслью, когда прочла аннотацию к сервису Qui-Quo, было: «Если это действительно так работает, то это просто супер-помощник менеджеру в подборе туров и составлении КП клиенту!» Попробовали – так и есть!

Туристы оценили, поскольку время от диалога до отправки КП существенно сократилось. Кроме того, людям очень нравится…

Продолжение истории

Инга Евсюкова, г. Одесса, «Хороший отдых»

Пришлось пройти стадию отрицания (нет, я буду отправлять письма, как раньше), гнева (НЕТ, Я БУДУ ОТПРАВЛЯТЬ ПИСЬМА, КАК РАНЬШЕ), компромисса (ладно, эту неделю я буду отправлять письма с Qui-Quo) и вот спустя два месяца мне уже тяжело себе представить, что раньше не было Qui-Quo.

Дорогие менеджеры, не сопротивляйтесь. Отправлять туры туристам с Qui-Quo это удобно, просто, понятно и быстро.

Продолжение истории

Куликова Людмила, г. Домодедово, «Интурист Магазин Путешествий»

Больше никакой рутины – только работа в удовольствие! подружка, у которой 3 турагентства рассказала, что ее менеджеры попросили установить им КВИ-КВО и она согласилась, т.к. деньги смешные, а польза очевидна.) оказалось, что программа существует уже 3 (ТРИ!!!) года, это почти столько же, сколько я в турагентском бизнесе и все это время я ей не пользовалась! Срочно захотелось побежать в офис и установить наконец-то эту чудо-программу)

Продолжение истории

Мартян Алла, г. Москва, «УЛЕТАЕМ.РУ»

Программа настолько удивительно удобная, экономит наше время на подборку отелей, сортировку по цене, отправку писем своим туристам в симпатичном формате. Теперь для меня это просто незаменимая услуга в работе, спасибо разработчикам и придумщикам. Желаю вам дальнейшего процветания.

Дильбра Иляхунова, г. Бишкек, «GSSAD»

Qui-Quo — это точно можно сказать наша «Правая Рука» — «Палочка Выручалочка» — «Волшебная палочка»!

Скорость и сервис — говорит о достоинствах Qui-Quo и в будущем это наша «Волшебная Ручка», со сказочными возможностями станет неотъемлемой частью нашего коллектива будет или уже есть!!!

уровней компиляции замыкающего компилятора | Google для разработчиков

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

ПРОБЕЛ_ТОЛЬКО

Уровень компиляции WHITESPACE_ONLY

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

Транспиляция языковых функций по-прежнему будет происходить, если запрошенный вывод языковой режим отличается от языкового режима ввода. См. --language_in и --language_out в Флаги и опции.

Этот уровень компиляции обеспечивает наименьшее сжатие из трех уровни.

ПРОСТЫЕ_ОПТИМИЗАЦИИ

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

Сборник с SIMPLE_OPTIMIZATIONS всегда сохраняет функциональность синтаксически корректного JavaScript при условии, что код не обращается к локальным переменным, используя строковые имена (путем используя, например, операторы eval() или вызывая toString для функций).

SIMPLE_OPTIMIZATIONS — уровень компиляции по умолчанию.

РАСШИРЕННЫЕ_ОПТИМИЗАЦИИ

Уровень компиляции ADVANCED_OPTIMIZATIONS выполняет те же преобразования, что и SIMPLE_OPTIMIZATIONS , но добавляет множество более агрессивных глобальных преобразований для достижения самое высокое сжатие из всех трех уровни. Уровень ADVANCED_OPTIMIZATIONS сжимает JavaScript значительно превосходит возможности других инструментов.

Чтобы включить эту крайность сжатие, ADVANCED_OPTIMIZATIONS делает сильным предположения о скомпилированном коде. Если ваш код не соответствует к этим предположениям,

ADVANCED_OPTIMIZATIONS будет создавать код, который не запускается.

Например, код, скомпилированный с ADVANCED_OPTIMIZATIONS может не работать с нескомпилированный код, если вы не предпримете специальных шагов для обеспечения совместимость. Если вы не отметите внешние функции и свойства, на которые есть ссылки в вашем коде, Closure Compiler будет ненадлежащим образом переименовывать ссылки в вашем коде, вызывая несоответствия между именами в вашем коде и во внешнем коде.

Чтобы узнать больше о том, как подготовить код на РАСШИРЕННЫЕ_ОПТИМИЗАЦИИ

, читать Advanced Compilation и Экстерны.

Преобразования ADVANCED_OPTIMIZATIONS включают:

• более агрессивное переименование:

  Компиляция с SIMPLE_OPTIMIZATIONS только переименовывает параметры и переменные внутри функции. ADVANCED_OPTIMIZATIONS также переименовывает глобальные переменные, имена функций и свойства.

• Удаление мертвого кода :

  Компиляция с

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

• глобальное встраивание:

  Компиляция с ADVANCED_OPTIMIZATIONS заменяет некоторые вызовы функций с телом функции. Этот трансформация известна как «встраивание». Компилятор встраивает функции только тогда, когда он определяет, что встраивание безопасно и экономит место. Сборник с ADVANCED_OPTIMIZATIONS также встраивает константы и некоторые переменные, когда компилятор определяет, что он может сделать так безопасно.

Как установить уровень компиляции

Пользовательский интерфейс службы Closure Compiler, API службы и приложение. есть разные методы настройки уровень компиляции .

В пользовательском интерфейсе службы Closure Compiler

Чтобы установить уровень компиляции в пользовательском интерфейсе службы Closure Compiler, нажмите на переключатели в Оптимизация раздела интерфейс.

В API службы компилятора закрытия

Чтобы установить уровень компиляции в API сервиса Closure Compiler, включить параметр запроса с именем уровень_компиляции со значением WHITESPACE_ONLY , SIMPLE_OPTIMIZATIONS , или ADVANCED_OPTIMIZATIONS , как в следующем питоне программа:

#!/usr/bin/python2. 4
импортировать httplib, urllib, sys
параметры = urllib.urlencode([
    ('code_url', sys.argv[1]),
    ('уровень_компиляции', 'ДОПОЛНИТЕЛЬНЫЕ_ОПТИМИЗАЦИИ'),
    ('формат_вывода', 'текст'),
    ('output_info', 'скомпилированный_код'),
  ])
заголовки = { "Тип контента": "application/x-www-form-urlencoded" }
conn = httplib.HTTPSConnection('closure-compiler.appspot.com')
conn.request('POST', '/compile', параметры, заголовки)
ответ = conn.getresponse()
данные = ответ.чтение()
распечатать данные
соединение.закрыть()
 

В приложении Closure Compiler

Чтобы установить уровень компиляции в приложении Closure Compiler, включите флаг командной строки --compilation_level с ценность из WHITESPACE_ONLY , ПРОСТОЙ , или ADVANCED , как в следующей команде:

java -jarcompiler. jar --уровень_компиляции РАСШИРЕННЫЕ_ОПТИМИЗАЦИИ --js hello.js
 

Инкрементная компиляция | Rust Blog

Я помню, как во время презентации 1.0 на юбилейной конференции Встреча Bay Area Meetup, Аарон Турон рассказал о Dropbox, который до сих пор был очень доволен использованием Rust в продакшене. Ядро Команда регулярно связывалась с ними , сказал он, спрашивая их, знаете ли, что вам нужно? И их ответ всегда: быстрее компилируется… Опытный пользователь Rust, неудивительно, что это вызвало многозначительный смешок у аудитория. Улучшение времени компиляции на самом деле было важным событием внимание после того, как Rust достиг версии 1.0, хотя до этого момента большая часть работы к этой цели пошел в закладке архитектурных основ в пределах компилятор, и мы только медленно начинаем видеть реальные результаты.

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

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

 rustc -Zincremental=<путь> ./main.rs
 

Это запустит компилятор в инкрементном режиме , используя любой <путь> вы указали в качестве каталога кэша инкрементной компиляции. Мы тоже работая над подкомандой Cargo, чтобы сделать это более плавным, позволяя вам просто напишите груз, инкрементная сборка . Как только все работает надежно, конечно, инкрементная компиляция будет доступна по умолчанию грузовой билд командный.

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

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

Большая часть времени программиста тратится на рабочий процесс редактирования-компиляции-отладки :

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

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

Инкрементальная компиляция — это способ использования того факта, что небольшие изменения между компиляциями во время обычного рабочего процесса программирования: Многие, если не большинство, изменения, сделанные между двумя сеансами компиляции, имеют только локальное влияние на машинном коде в выходном двоичном файле, в то время как остальная часть программы, то же самое, что и на исходном уровне, в конечном итоге будет точно таким же, бит за битом. Инкрементальная компиляция направлена ​​на то, чтобы сохранить как можно больше из них без изменений. частей насколько это возможно, при этом переделывая только тот объем работы, который фактически должен быть переделан.

Мы уже слышали, что постепенное вычисление чего-либо означает обновление только те части выходных данных вычислений, которые необходимо адаптировать в ответ на заданное изменение входных данных вычисления. Одна из основных стратегий, которую мы можем использовать для достижения этой цели, состоит в том, чтобы просмотреть одно большое вычисление. (подобно компиляции программы) в виде составного множества более мелких, взаимосвязанных вычисления, которые накладываются друг на друга. Каждое из этих меньших вычислений даст промежуточный результат который может быть кэширован и надеюсь повторно использовал в более поздней итерации, избавляя нас от необходимости повторно вычислять это конкретный промежуточный результат снова.

Давайте рассмотрим простой пример из алгебры, чтобы сделать вещи более конкретный. Давайте посмотрим, что значит вычислить выражение вида a+b×c постепенно. Это будет включать оценку выражения один раз с одним набором значений для a , b и c , а затем оценивая его секунду время с другим значением для и . Впервые и будут 1 , B будет 2 , а C будет 3 :

Предположим, что мы «сохранили» промежуточные результаты на каждом этапе, то есть, мы, мы помните где-нибудь, что b×c — это 6 , а a+b×c — это 7 . Теперь во втором раунд, мы хотим знать, что a+b×c , если мы изменим значение a на 4 . Однако, когда мы повторно вычисляем значение выражения, мы видим, что мы уже известно, что b×c = 6 , поэтому нам не нужно выполнять это вычисление. снова и может сразу перейти к (a = 4) + (b×c = 6) . Таким образом, мы вычислили значение нашего выражения всего за один шаг вместо двух, что избавляет нас сплошное утомительное умножение.

Давайте посмотрим, как эта схема транслируется в компилятор.

Способ, который мы выбрали для реализации инкрементальности в компиляторе Rust, следующий: просто: сеанс инкрементной компиляции следует точно так же шаги в том же порядке, что и сеанс пакетной компиляции. Однако при контроле поток достигает точки, где он собирается вычислить некоторые нетривиальные промежуточные значения. результат, он попытается загрузить этот результат из кэша инкрементной компиляции. вместо этого на диске. Если в кэше есть допустимая запись, компилятор может просто пропустить вычисление этого конкретного фрагмента данных. Давайте посмотрим на (упрощенно) обзор различных этапов компиляции и промежуточных результатов, которые они производить:

Сначала компилятор разберет исходный код в абстрактное синтаксическое дерево. (АСТ). Затем AST проходит фазу анализа, которая выдает тип информации и MIR для каждой функции. После этого, если анализ ошибок не обнаружено, этап codegen преобразует версию MIR программу в ее версию машинного кода, создавая один объектный файл за модуль исходного кода. На последнем шаге все объектные файлы линкуются вместе. в окончательный выходной двоичный файл, который может быть библиотекой или исполняемым файлом.

Сравнивая это с нашим примером алгебры выше, части AST соответствуют на a , b и c , то есть они являются входами для нашего инкрементного вычисления, и они определяют, что нужно обновить, когда мы пробираемся через процесс компиляции. Кусочки типовой информации и МИР и объектные файлы, с другой стороны, являются нашими промежуточными результатами , то есть они соответствуют записям кэша инкрементных вычислений, которые мы сохранили для b×c и a+b×c . Где запись кэша выглядит как b×c = 6 в пример алгебры, это будет выглядеть примерно так translate_to_obj_file(mir1, mir2, mir3) = <биты obj-файла> в случае компилятора.

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

Существует формальный метод, который можно использовать для моделирования промежуточного этапа вычислений. результаты и их индивидуальную «актуальность» простым способом: графы зависимостей . Выглядит это так: Каждый вход и каждый промежуточный результат представлен как узел в ориентированном графе. превосходит в график, с другой стороны, представляет, какой промежуточный результат или входные данные могут иметь влияет на на какой-то другой промежуточный результат.

Давайте вернемся к нашему примеру с алгеброй, чтобы посмотреть, как это выглядит в практика:

Как видите, у нас есть узлы для входов a , b и c , и узлы для промежуточные результаты b×c и a+b×c . Края должны прийти как нет сюрприз: есть одно ребро от b×c до b и одно до c , потому что они значения, которые нам нужно прочитать при вычислении б×с . Для a+b×c это точно так же. Заметим, кстати, что приведенный выше граф является деревом только потому, что моделируемое им вычисление имеет форму дерева. В общем, графики зависимости являются ориентированными ациклическими графами , как это было бы, если бы мы добавим к нашим вычислениям еще один промежуточный результат b×c+c :

Что делает эту структуру данных действительно полезной, так это то, что мы можем задавать ей вопросы формы «если X изменился, является ли Y актуальным?». Мы просто берем узел представляет Y и собрать все входы Y зависит от транзитивно после всех ребер, исходящих из Y . Если какой-либо из этих входов изменился, на значение, которое мы кэшировали для Y , больше нельзя полагаться.

При компиляции в инкрементном режиме мы всегда строим граф зависимостей производимые данные: каждый раз записывается какая-то часть данных (например, объектный файл), мы записываем, к каким другим частям данных мы обращаемся при этом.

Ударение на запись здесь. В любой момент времени компилятор сохраняет отслеживать, над каким фрагментом данных он работает в данный момент (он делает это в фон в локальной памяти потока). Это текущий активный узел график зависимости. И наоборот, данные, которые должны быть 90 147, прочитаны 90 148 для вычисления. также отслеживается значение активного узла: обычно оно уже находится в каком-то вид контейнера (например, хэш-таблица), который требует вызова метода поиска для получить доступ к определенной записи. Мы хорошо используем этот факт, сделав эти поиск методы прозрачно создают ребра в графе зависимостей: всякий раз, когда запись доступ, мы знаем, что это читается, и мы знаем, что это читается вместо (текущий активный узел). Это дает нам оба конца края зависимости и мы можем просто добавить его на график. В конце сеансов компиляции мы все наши данные хорошо связаны, в основном автоматически:

Затем этот граф зависимостей сохраняется в кэше инкрементной компиляции каталог вместе с записями кэша, которые он описывает.

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

Все, что пережило этот этап проверки кеша, можно безопасно использовать повторно во время текущего сеанса компиляции.

Есть несколько преимуществ автоматическое отслеживание зависимостей подход мы нанимают. Поскольку он встроен во внутренние API компилятора, он быть в курсе изменений в компиляторе, и трудно случайно забудь о. И если кто-то все еще забывает использовать его правильно (например, не объявляя правильный активный узел в каком-то месте) то результат чрезмерно консервативный, но все же «правильный» график зависимостей : это будет отрицательно повлиять на коэффициент повторного использования, но это не приведет к неправильному повторному использованию некоторых устаревший фрагмент данных.

Другой аспект заключается в том, что система не пытается предсказать или вычислить, что график зависимости будет выглядеть так, он просто отслеживает. Большая часть наши (еще не написанные) регрессионные тесты , с другой стороны, даст описание того, как должен выглядеть граф зависимостей для данной программы. Это гарантирует, что фактический график и эталонный график достигнуты. с помощью различных методов , снижая риск того, что и компилятор, и test case согласуются с тем же, но неверным значением.

Давайте посмотрим на некоторые последствия того, что мы уже узнали:

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

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

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

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

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

Другая область, которая оказывает большое влияние на фактическую эффективность альфа-версия — . Степень детализации отслеживания зависимостей . мы делаем наши графики зависимостей, и текущая реализация делает это скорее грубовато местами. Например, график зависимости знает только один узел для всех методов в impl . Как следствие, компилятор будет рассматривать как все . методы этого подразумевают как измененные, если только один из них изменен. Это конечно будет означать, что будет перекомпилировано больше кода, чем это строго необходимо.

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

Как видите, сборка крейта в первый раз в инкрементном режиме может быть медленнее, чем компилировать его в неинкрементном режиме. Это связано с тем, что зависимость отслеживание влечет за собой дополнительную плату при активации. Обратите внимание, что компиляция постепенно также может быть быстрее (как в случае ящика регулярных выражений). Это потому что инкрементная компиляция разбивает код на более мелкие единицы оптимизации чем обычная сессия компиляции, что приводит к меньшему времени оптимизации, но также в менее эффективном коде времени выполнения.

В последнем столбце показано количество времени, которое занимает перестроение ящика, когда на самом деле ничего не изменилось. Для крейтов, на которые компилятор тратит много оптимизация времени, например, syntex-syntax или regex , выигрыш может быть существенным: инкрементная перестройка занимает всего около 22% времени полная перестройка потребуется для syntex-syntax , только 16% для regex и менее 10% для тестового примера all.rs ящика futures-rs.

С другой стороны, для такого ящика, как библиотека futures-rs , которая приводит к мало машинного кода при компиляции, текущая версия инкрементного компиляция не имеет большого значения: она всего на 3% быстрее, чем компиляция из царапать.

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

Цифры показывают, что эффективность инкрементной компиляции действительно зависит от лот по типу изменения, примененного к коду. Для изменений с очень локальными эффекта мы можем приблизиться к оптимальному повторному использованию (как в случае Ошибка::причина() , или dfa::write_vari32() ). Если мы изменим что-то, что повлияет на многих местах, таких как Compiler::new() , мы можем не увидеть заметного сокращения время компиляции. Но опять же, имейте в виду, что эти измерения взяты из текущее состояние реализации. Они не отражают полный потенциал функции.

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

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

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

Усовершенствования в обоих этих направлениях сделают инкрементную компиляцию более эффективным по мере развития реализации.

С точки зрения правильности, мы с самого начала пытались ошибиться в сторону осторожности, скорее заставить компилятор пересчитать что-то, если мы не были уверены, что наш отслеживание зависимостей сделало правильно, но есть еще кое-что, что может быть сделанный.

• Мы хотим иметь еще много автоматических тестов, которые удостоверятся, что различные базовые компоненты системы не регрессировать . Это та область, где заинтересованные лица могут начать вносить свой вклад с относительной легкостью, так как нужно только понять Язык Rust и тестовая среда, но не более сложные внутренности реализация компилятора. Если вы заинтересованы в прыжках, вперед перейти к проблеме отслеживания на GitHub и оставить комментарий!

• Мы работаем над Инкрементный инструмент Cargo (реализован как Cargo подкоманда для беспроблемной установки и использования), которая будет выполнять проекты git, компилируя последовательные версии исходного кода и сбор данных о эффективности и правильности о инкрементная компиляция по сравнению с обычной компиляцией.