Что делает компилятор just-in-time (JIT)?

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

в какой-то момент эволюции языков компиляторы скомпилируют язык высокого уровня в псевдокод, который затем будет интерпретирован (интерпретатором) для запуска вашей программы. Это устранило объектный код и исполняемые файлы и разрешило их языки, переносимые на несколько операционных систем и аппаратных платформ. Pascal (который скомпилирован в P-код) был одним из первых; Java и C# являются более поздними примерами. В конце концов термин P-код был заменен байт-кодом, так как большинство псевдо-операций имеют длину байта.

компилятор Just-In-Time (JIT) является особенностью интерпретатора времени выполнения, который вместо интерпретации байт-кода каждый раз, когда вызывается метод, скомпилирует байт-код в машинный код инструкции запущенной машины, а затем вместо этого вызовите этот объектный код. В идеале эффективность выполнения объектного кода позволит преодолеть неэффективность перекомпиляции программы при каждом ее запуске.

JIT-как раз вовремя само слово говорит, когда это необходимо (по требованию)

типичный сценарий:

исходный код полностью преобразуется в машинный код

JIT сценарий:

исходный код будет преобразован в ассемблерный язык, например structure [for ex IL (intermediate language) for C#, байт-код для java].

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

JIT vs Non - JIT сравнение:

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

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

JIT примеры:

1. в Java JIT находится в JVM (виртуальная машина Java)
2. в C# он находится в CLR (Общеязыковая среда выполнения)
3. в Android он находится в DVM (виртуальная машина Dalvik) или ART (среда выполнения Android) в более новых версиях.

как другие упомянули

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

просто чтобы добавить точку к вышеизложенному обсуждению, JVM поддерживает подсчет времени выполнения функции. Если это число превышает предопределенное ограничение, JIT компилирует код на машинный язык, который может быть непосредственно выполнен процессором (в отличие от обычного случая, когда javac компилирует код в байт-код и затем java-интерпретатор интерпретирует этот байт-код строка за строкой, преобразует его в машинный код и выполняет).

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

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

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

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

когда нам нужно вызвать метод несколько раз, мы должны интерпретировать один и тот же код много раз и это может занять больше времени, чем необходимо. Таким образом, у нас есть JIT (just-in-time) компиляторы. Когда байт был загружен в JVM (его время выполнения), весь код будет скомпилирован, а не интерпретирован, тем самым экономя время.

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

JIT-компилятор компилирует только байт-код в эквивалентный машинный код при первом выполнении. При каждом последующем выполнении JVM просто использует уже скомпилированный собственный код для оптимизации производительности.

без JIT-компилятора интерпретатор JVM переводит байт-код строка за строкой, чтобы сделать его похожим на собственное приложение выполненный.

источник

как раз вовремя компилятор (JIT):
Он компилирует байт-коды java в машинные инструкции этого конкретного процессора.

например, если у нас есть оператор цикла в нашем java-коде:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

приведенный выше код цикла выполняется 10 раз, если значение i равно 0.

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

другим подобным примером является поиск шаблона с использованием "регулярного выражения" в списке строк/предложений.

JIT-компилятор не компилирует код в машинный код. Он компилирует код, который имеет аналогичная картина во время выполнения.

посмотреть этот документация Oracle по пониманию JIT подробнее.

У вас есть код, который компилируется в некоторый IL (промежуточный язык). При запуске программы компьютер не понимает этот код. Он понимает только собственный код. Таким образом, компилятор JIT компилирует ваш IL в собственный код на лету. Он делает это на уровне метода.

Я знаю, что это старый поток, но оптимизация времени выполнения-еще одна важная часть компиляции JIT, которая, похоже, не обсуждается здесь. В принципе, компилятор JIT может контролировать программу по мере ее запуска, чтобы определить способы улучшения выполнения. Затем он может внести эти изменения "на лету" во время выполнения. Оптимизация Google JIT (javaworld имеет довольно хорошая статья об этом.)

Jit означает just in time compiler jit-это программа, которая превращает байтовый код java в инструкцию, которая может быть отправлена непосредственно процессору.

использование компилятора java just in time (действительно второго компилятора) на конкретной системной платформе соответствует байт-коду в конкретный системный код,как только код был повторно скомпилирован JIT complier ,он обычно будет работать быстрее на компьютере.

компилятор just-in-time поставляется с виртуальным машина и использована выборочно. Он компилирует байт-код в специфичный для платформы исполняемый код, который немедленно выполняется.

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

в следующих примерах кода показано, как JIT оптимизирует Java-код.

Код Перед Оптимизацией

    class A {
      B b;
      public void newMethod() {
        y = b.get();
        ...do stuff...
        z = b.get();
        sum = y + z;
      }
    }

class B {
   int value;
   final int get() {
      return value;
   }
}

Код После Оптимизации

class A {
B b;
public void newMethod() {
   y = b.value;
   ...do stuff...
   sum = y + y;
}
}
class B {
   int value;
   final int get() {
      return value;
   }
}

первоначально код содержал два вызова b.метод get (). После оптимизации два вызова метода оптимизируются в одну операцию копирования переменной; то есть оптимизированному коду не нужно выполнять вызов метода, чтобы получить значение поля класса B.

just-in-time (JIT) компиляция, (также динамический перевод или компиляция во время выполнения), является способ выполнения машинный код это включает компиляцию во время выполнения программы – во время выполнения – , а не до исполнения.

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

давайте рассмотрим JIT, используемый в JVM,

например, компиляторы HotSpot JVM JIT генерируют динамические оптимизации. Другими словами,они принимают решения по оптимизации во время работы приложения Java и генерируют высокопроизводительные собственные машинные инструкции targeted для основного системная архитектура.

когда метод выбран для компиляции, JVM передает свой байт-код компилятору Just-In-Time (JIT). JIT должен понимать семантику и синтаксис байт-кода, прежде чем он сможет правильно скомпилировать метод. Чтобы помочь JIT-компилятору проанализировать метод, его байт-код сначала переформулируется во внутреннее представление, называемое деревьями трассировки, которое больше напоминает машинный код, чем байт-код. Анализ и оптимизация затем выполняются на деревья метода. В конце деревья переводятся в собственный код.

дерево трассировки-это структура данных, используемая при компиляции программного кода во время выполнения. Деревья трассировки используются в типе "just in time compiler", который отслеживает выполнение кода во время горячих точек и компилирует его. См.этой.

см. :

• http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
• https://en.wikipedia.org/wiki/Just-in-time_compilation

20% байтового кода используется 80% времени. Компилятор JIT получает эту статистику и оптимизирует этот 20% байтового кода, чтобы работать быстрее, добавляя встроенные методы, удаление неиспользуемых блокировок и т. д., а также создавая байт-код, специфичный для этой машины. Я цитирую из этой статьи, я нашел, что это было удобно. http://java.dzone.com/articles/just-time-compiler-jit-hotspot

JIT относится к движку выполнения в нескольких реализациях JVM, который быстрее,но требует больше памяти, является компилятором just-in-time. В этой схеме байт-коды метода компилируются в машинный код при первом вызове метода. Машинный код метода кэшируется, поэтому его можно использовать при следующем вызове того же метода.

JVM фактически выполняет шаги компиляции во время выполнения по соображениям производительности. Это означает, что Java не имеет чистого разделения компиляции и выполнения. Сначала он выполняет так называемую статическую компиляцию из исходного кода Java в байт-код. Затем этот байт-код передается JVM для выполнения. Но выполнение байт-кода происходит медленно, поэтому JVM измеряет, как часто байт-код запускается и когда он обнаруживает "горячую точку" кода, который запускается очень часто, он выполняет динамическую компиляцию из байт-кода в machinecode из "горячих точек" код (профайлер точка). Так эффективно сегодня Java-программы запускаются с помощью выполнения machinecode.

компилятор just in time (JIT) - это часть программного обеспечения, которая принимает не исполняемый вход и возвращает соответствующий машинный код для выполнения. Например:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

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

разница компилятор, интерпретатор и JIT

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

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