что такое время компиляции

Время компиляции (фаза жизненного цикла программы)

Компиляция программы может осуществляться компилятором как по команде от пользователя, так и по команде от среды разработки при изменении исходного кода программы, в отличие от других этапов жизненного цикла (англ. program lifecycle phase) программы, таких как время выполнения, время установления связей («линковки») (англ. link time) и время загрузки (англ. load time).

Связанные понятия

Сопрограммы (англ. coroutines) — методика связи программных модулей друг с другом по принципу кооперативной многозадачности: модуль приостанавливается в определённой точке, сохраняя полное состояние (включая стек вызовов и счётчик команд), и передаёт управление другому. Тот, в свою очередь, выполняет задачу и передаёт управление обратно, сохраняя свои стек и счётчик.

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

В теории компиляторов удалением мёртвого кода (англ. dead code elimination, DCE) называется оптимизация, удаляющая мёртвый код. Мёртвым кодом (так же бесполезным кодом) называют код, исполнение которого не влияет на вывод программы, все результаты вычисления такого кода являются мёртвыми переменными, то есть переменными, значения которых в дальнейшем в программе не используются.

Источник

Время компиляции

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

[править] Обзор

Операции, выполняемые во время компиляции, как правило, включают в себя синтаксический анализ, различные виды семантического анализа (например, проверки типов и инстанцирования шаблона) и генерации кода.

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

Свойства программ, которые могут быть выяснены во время компиляции, это например:

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

«Время компиляции» может также относиться к фактическому количеству времени, необходимому для компиляции.

Источник

Аннотации времени компиляции на примере @Implement

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

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

Я опишу общий алгоритм проверки, а также все шаги и нюансы на которые я тратил время и нервные клетки.

Постановка задачи

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

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

Допустим, есть класс UnitManager, который, по сути, является коллекцией юнитов. В нем есть методы для добавления, удаления, получения юнита и т.д. При добавлении нового юнита менеджер присваивает ему id. Генерация id делегирована классу RotateCounter, который, возвращает число в заданном диапазоне. И тут есть крошечная проблема, RotateCounter не может знать о том, свободен ли выбранный id. Согласно принципу инвертирования зависимостей, можно создать интерфейс, в моем случае это RotateCounter.IClient, у которого есть единственный метод isValueFree(), который получает id и возвращает true, если id свободен. А UnitManager реализует этот интерфейс, создаст экземпляр RotateCounter и передаст ему себя в качестве клиента.

Я так и сделал. Но, открыв исходник UnitManagerа через несколько дней после написания, я вошел в легкий ступор увидев метод isValueFree(), который не очень то подходил по логике для UnitManagerа. Было бы намного проще, если бы была возможность указать какой интерфейс реализует этот метод. Например, в языке C#, из которого я пришел в Java, с этой проблемой помогает справиться явная реализация интерфейса. В этом случае, во-первых, вызвать метод можно только при явном касте к интерфейсу. Во-вторых, что более важно в данном случае, в сигнатуре метода явно указывается имя интерфейса (и без модификатора доступа), например:

Немного теории

Обработкой элементов на этапе компиляции занимаются специальные классы-процессоры. Это классы которые наследуются от javax.annotation.processing.AbstractProcessor (можно просто реализовать интерфейс javax.annotation.processing.Processor ). Больше про процессоры можно прочитать здесь и здесь. Самый важные метод в нем process. В котором мы можем получить список всех аннотированных элементов и провести необходимые проверки.

Сначала, по наивности душевной, я думал, что работа с типами на этапе компиляции осуществляется в терминах рефлексии, но… нет. Там все основано на элементах.

Element (javax.lang.model.element.Element) — основной интерфейс для работы большинством структурных элементов языка. У элемента есть наследники, которые точнее определяют свойства конкретного элемента (за подробностями можно заглянуть сюда):

Types (javax.lang.model.util.Types) — к этому классу советую присмотреться повнимательнее. Там можно найти много интересного. По сути, это набор утилит для работы с типами. Например, он позволяет получить обратно TypeElement из TypeMirror.

TypeKind (javax.lang.model.type.TypeKind) — перечисление, позволяет уточнить информацию о типе, проверить является ли тип массивом (ARRAY), пользовательским типом (DECLARED), переменной типа (TYPEVAR) и т.д. Получить можно через TypeMirror.getKind()

ElementKind (javax.lang.model.element.ElementKind) — перечисление, поваляет уточнить информацию об элементе, проверить является ли элемент пакетом (PACKAGE), классом (CLASS), методом(METHOD), интерфейсом(INTERFACE) и т.д.

В основном, этих типов мне было достаточно для написания алгоритма проверки.

Алгоритм проверки

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

Хочу заметить, что нельзя просто так взять и получить value аннотации. При попытке вызвать annotation.value() будет брошено исключение MirroredTypeException, а вот из него можно получить TypeMirror. Этот читерский способ, а также правильное получение value я нашел тут:

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

Первым делом нужно проверить, является ли value аннотации интерфейсом. Тут все просто:

Вызов нужно поместить в конец цикла в методе process, вот так:

А сам метод haveMethod() выглядит следующим образом:

Видите проблему? Нет? А она там есть. Дело в том, что я так и не смог найти способ получить фактические параметры типов для обобщенных интерфейсов. Например, у меня есть класс, который реализует интерфейс Predicate:

Подключение к Eclipse

Все вместе и в Eclipse-проекте можно увидеть на GitHub. На момент написания статьи там всего два класса, если аннотацию можно так назвать: Implement.java и ImplementProcessor.java. Думаю, об их назначении вы уже догадались.

PS. Благодарю пользователей ohotNik_alex и Comdiv за помощь в исправлении ошибок.

Источник

Время выполнения vs время компиляции

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

24 ответов

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

время компиляции

времени

Что может пойти не так, это выполнить ошибки:

также могут быть ошибки, обнаруженные самой программой:

Я думаю об этом с точки зрения ошибок, и когда их можно поймать.

строковое значение не может быть присвоено переменной типа int, поэтому компилятор знает во время компиляции что этот код имеет проблемы

здесь результат зависит от того, какая строка была возвращена ReadLine(). Некоторые значения могут быть проанализированы в int, другие-нет. Это можно определить только при выполнить время

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

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

вам нужно более четкое определение?

(редактировать: следующее относится к C# и аналогичным строго типизированным языкам программирования. Я не уверен, что это поможет вам).

например, компилятор обнаружит следующую ошибку (at время компиляции) перед запуском программы и приведет к ошибке компиляции:

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

на составлен программа (примеры-c и fortran):

вещи, которые происходят на первом шаге, как говорят, происходят во время» компиляции», вещи, которые происходят на втором шаге, как говорят, происходят во время»выполнения».

на понял программа (пример MicroSoft basic (на dos) и python (я думаю)):

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

существует также промежуточный случай, в котором программа компилируется в байт-код и запускается немедленно (как в awk или perl).

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

компилятор может выполнить эту калькуляцию во время компиляции, потому что он знает, что такое 2, и что такое MY_CONSTANT. Таким образом, он избавляет себя от выполнения вычисления каждого отдельного выполнения.

Хм, хорошо, среда выполнения используется для описания чего-то, что происходит при запуске программы.

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

подробнее обо всех ошибки программирования здесь

Время Компиляции:

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

Время Выполнения:

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

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

актуальность

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

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

в просто разнице слов b / w время компиляции и время выполнения.

вот цитата из Даниэля Ляна, автора «введения в JAVA-Программирование», по вопросу компиляции:

«программа, написанная на языке высокого уровня, называется исходной программой или исходным кодом. Поскольку компьютер не может выполнить исходную программу, исходная программа должна быть переведен на код на исполнение. Перевод может быть выполнен с помощью другого инструмента программирования, называемого интерпретатором или компилятор.(Даниэль Лян, «введение в Программирование JAVA», p8).

«компилятор переводит всю исходный код на машина-код file, и файл машинного кода затем выполняется»

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

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

помните: просто потому, что программа компилируется без ошибок не означает, что она будет работать без ошибок.

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

пример ошибки времени компиляции:

синтаксическая ошибка-как ваш код может быть скомпилирован в инструкции машинного уровня, если они неоднозначны?? Ваш код должен соответствовать 100% синтаксическим правилам языка, иначе он не может быть скомпилирован в working код.

пример ошибки во время выполнения:

заканчивается память-вызов рекурсивной функции, например, может привести к переполнению стека, учитывая переменную определенной степени! Как это может предвидеть компилятор!? не может.

и в этом разница между ошибкой времени компиляции и ошибкой времени выполнения

в качестве дополнения к другим ответам, вот как я бы объяснил это непрофессионалу:

ваш исходный код похож на чертеж корабля. Он определяет, как должен быть сделан корабль.

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

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

время выполнения означает, что что-то происходит при запуске программы.

время компиляции означает, что что-то происходит при компиляции программы.

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

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

с другой стороны; если что-то сделано во время компиляции, оно запускается только на вашем компьютере, а если что-то выполняется, оно запускается на вашем компьютере пользователей.

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

большой источник для дальнейшего чтения здесь:

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

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

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

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

на этой ноте, однако, это действительно зависит от контекст, в котором вы используете время выполнения и время компиляции.

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

основная разница между временем выполнения и временем компиляции:

int a = 1 int b = a/0;

вот очень простой ответ:

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

скомпилированная программа может быть открыта и запущена пользователем. Когда приложение запущено, оно называется runtime.

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

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

CLR_diag время компиляции, а затем runtime2

;

3.2 разница между этими 3 вещами: compile vs build vs runtime

https://www.quora.com/What-is-the-difference-between-build-run-and-compile Фернандо Падоан, разработчик, который просто немного любопытен для языкового дизайна Ответил 23 Февраля Я возвращаюсь назад по отношению к другим ответам:

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

время работы: Когда приложение запущено, оно называется временем выполнения.

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

посмотрите на этот пример:

тест открытого класса <

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

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

Это не хороший вопрос для S. O. (Это не конкретный вопрос программирования), но это не плохой вопрос в целом.

Если вы думаете, что это тривиально: как насчет времени чтения и времени компиляции, и когда это полезное различие? Насчет языков, где компилятор доступен во время выполнения? Гай Стил (не манекен, он) написал 7 страниц в CLTL2 об EVAL-WHEN, которые программисты CL могут использовать для управления этим. 2 предложения едва хватает для определение, который сам по себе далеко не объяснение.

В общем, это сложная проблема, которую языковые дизайнеры, казалось, пытались избежать. Они часто просто говорят: «вот компилятор, он делает вещи во время компиляции; все после этого во время выполнения, получайте удовольствие». C разработан, чтобы быть простым в реализации, а не самой гибкой средой для вычислений. Когда у вас нет компилятора, доступного во время выполнения, или возможности легко управлять, когда выражение оценивается, вы, как правило, в конечном итоге с хаки на языке, чтобы подделать общее использование макросов, или пользователи придумывают шаблоны проектирования для имитации более мощных конструкций. Простой в реализации язык определенно может быть стоящей целью, но это не означает, что это конец всего дизайна языка программирования. (Я не использую EVAL-когда много, но я не могу представить жизнь без него.)

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

к сожалению, я не знаю никаких хороших ссылок на это. Переговоры CLTL2 об этом немного, но не узнав об этом.

Источник