Wie unterscheidet sich ein JIT-Compiler von einem gewöhnlichen Compiler?

Bei JIT-Compilern für Sprachen wie Java, Ruby und Python herrschte großer Hype. Inwiefern unterscheiden sich JIT-Compiler von C / C ++ - Compilern, und warum heißen die für Java, Ruby oder Python geschriebenen Compiler JIT-Compiler, während C / C ++ - Compiler nur Compiler genannt werden?

JIT-Compiler kompilieren den Code im laufenden Betrieb, unmittelbar vor ihrer Ausführung oder sogar, wenn sie bereits ausgeführt werden. Auf diese Weise kann die VM, auf der der Code ausgeführt wird, nach Mustern in der Codeausführung suchen, um Optimierungen zu ermöglichen, die nur mit Laufzeitinformationen möglich wären. Wenn die VM feststellt, dass die kompilierte Version aus irgendeinem Grund nicht gut genug ist (z. B. zu viele Cache-Ausfälle oder Code, der häufig eine bestimmte Ausnahme auslöst), wird sie möglicherweise auf andere Weise neu kompiliert, was zu einer wesentlich intelligenteren Version führt Zusammenstellung.

Auf der anderen Seite sind C- und C ++ - Compiler traditionell keine JIT-Compiler. Sie werden nur einmal auf dem Computer des Entwicklers in einem einzigen Schritt kompiliert und anschließend wird eine ausführbare Datei erstellt.

JIT ist die Abkürzung für Just-in-Time-Compiler, und der Name ist misson: Zur Laufzeit werden sinnvolle Codeoptimierungen ermittelt und angewendet. Es ersetzt nicht die üblichen Compiler, sondern ist Teil von Dolmetschern. Beachten Sie, dass Sprachen wie Java, die Zwischencode verwenden, über beides verfügen : einen normalen Compiler für die Übersetzung von Quellcode in Zwischencode und eine im Interpreter enthaltene JIT für Leistungssteigerungen.

Code-Optimierungen können zwar von "klassischen" Compilern durchgeführt werden, beachten Sie jedoch den Hauptunterschied: JIT-Compiler haben zur Laufzeit Zugriff auf Daten . Das ist ein riesiger Vorteil; es richtig auszunutzen kann natürlich schwierig sein.

Betrachten Sie beispielsweise folgenden Code:

m(a : String, b : String, k : Int) {
  val c : Int;
  switch (k) {
    case 0 : { c = 7; break; }
    ...
    case 17 : { c = complicatedMethod(k, a+b); break; }
  }

  return a.length + b.length - c + 2*k;
}

Ein normaler Compiler kann nicht zu viel dagegen tun. Ein JIT-Compiler kann jedoch feststellen, dass mdas immer nur mit k==0einem bestimmten Grund aufgerufen wird (so etwas kann passieren, wenn sich der Code im Laufe der Zeit ändert). Es kann dann eine kleinere Version des Codes erstellen (und in systemeigenen Code kompilieren, obwohl ich dies konzeptionell für einen kleinen Punkt halte):

m(a : String, b : String) {
  return a.length + b.length - 7;
}

Zu diesem Zeitpunkt wird es wahrscheinlich sogar den Methodenaufruf einbinden, da er jetzt trivial ist.

Anscheinend hat die Sonne die meisten Optimierungen javacin Java 6 verworfen . Mir wurde gesagt, dass diese Optimierungen es JIT schwer machten, viel zu tun, und naiv kompilierter Code am Ende schneller lief. Stelle dir das vor.