[JAVA] Versuchen Sie es mit GraalVM

Vorwort

Da sich dieser Artikel auf die Leistung von GraalVM und die Leistung bei Verwendung von Graal als JIT-Compiler konzentriert, werden in diesem Artikel keine der Funktionen von GraalVM wie native Bilder und mehrere Sprachen behandelt.

Umgebung

macOS Mojava 10.14.4
Scala 2.13.1
sbt 1.3.8
GraalVM 20.1

Was ist Graal VM?

Es ist eine VM, die mit Graal ausgestattet ist, dem neuesten in Java geschriebenen JIT-Compiler. Laut dem offiziellen GraalVM-Dokument verfügt Graal über die folgenden Funktionen.

Graal selbst ist in Java implementiert, was Java-Programme mit leistungsstarken Optimierungen wie der partiellen Escape-Analyse, die mit Standard-JIT-Compilern nicht möglich ist, erheblich beschleunigen kann.

Wie schnell es tatsächlich sein wird, wird später beschrieben.

Übrigens, wenn es schwierig ist, die VM zu ändern, können Sie anscheinend nur den JIT-Compiler in Graal ändern, indem Sie die folgenden Optionen hinzufügen. Beachten Sie jedoch, dass es gemäß Referenz nur mit JDK10 oder höher verwendet werden kann.

-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

Graal VM-Architektur

Es hat die folgende Architektur. Im Vergleich zur Standard-JVM wurde der C2-Teil durch den Graal-Compiler ersetzt. Die Teile Graal und JVMCI sind in Java implementiert.

JVMCI Ein von Java implementierter Compiler, der in JVM als dynamischer Compiler verwendet werden kann.

https://openjdk.java.net/jeps/243

Eigentlich verwenden

Installation

Befolgen Sie die Anweisungen in den offiziellen Dokumenten. Für macOS hier

Vergleichen Sie die Geschwindigkeit mit der Standard-VM von OpenJDK und GraalVM

Einen detaillierteren Geschwindigkeitsvergleich finden Sie in diesem Artikel.

Führen Sie ein Programm aus, das die 10 häufigsten Worttypen ausspuckt, die in der 275-MB-Datei "GraalTest.txt" enthalten sind.


$ ll
total 65368
-rw-r--r--  1 kinsho  staff   202B  5 31 14:04 FibTest.scala
-rw-r--r--  1 kinsho  staff   1.9K  5 31 17:13 GraalTest.scala
-rw-r--r--  1 kinsho  staff   275M  5 31 16:54 GraalTest.txt
drwxr-xr-x  4 kinsho  staff   128B  5 31 14:28 project
drwxr-xr-x  5 kinsho  staff   160B  5 31 14:35 target

Verwenden Sie das oben installierte GraalVM als VM.

$ java -version
openjdk version "1.8.0_252"
OpenJDK Runtime Environment (build 1.8.0_252-b09)
OpenJDK 64-Bit Server VM GraalVM CE 20.1.0 (build 25.252-b09-jvmci-20.1-b02, mixed mode)

Unten das Ausführungsprogramm

`GraalTest.scala`


import java.io.File

import scala.annotation.tailrec
import scala.io.BufferedSource

object GraalTest extends App {

  val fileName: String = "GraalTest.txt"
  val encode: String = "UTF-8"

  val source: BufferedSource = scala.io.Source.fromFile(fileName, encode)
  val lines: Iterator[String] = source.getLines()
  val sortedTextList = lines.toList.mkString(" ").split(" ").sorted.toList
  val value = createMap(sortedTextList)
  val top10Words = value.toList.sortBy(_._2).reverse.take(10)

  def createMap(wordList: List[String]): Map[String, Long] = {
    @tailrec
    def loop(list: List[String], acc: Map[String, Long]): Map[String, Long] = {
      wordList match {
        case head :: tail if acc.isEmpty => {
          loop(tail, acc + (head -> 1L))
        }
        case head :: tail => {
          acc.get(head) match {
            case Some(value) => {
              loop(tail, acc.updated(head, value + 1L))
            }
            case None => {
              loop(tail, acc + (head -> 1L))
            }
          }
        }
        case head :: Nil => {
          acc.get(head) match {
            case Some(value) => {
              acc.updated(head, value + 1L)
            }
            case None => {
              acc + (head -> 1L)
            }
          }
        }
      }
    }
    loop(wordList, Map.empty[String, Long])
  }
}

Ergebnis

Mit der Standard-VM von OpenJDK! ??

Zum Vergleich führen wir das Programm mit dem Standard-JIT-Compiler von OpenJDK aus. Wenn Sie -XX: -Use JVMCI Compiler angeben, können Sie den Standard-JIT-Compiler von OpenJDK verwenden.

`.jvmopts`


-XX:-UseJVMCICompiler
-Xmx8G

`Lauf`


$ /usr/bin/time sbt run GraalTest.scala

Dann wird das folgende Ergebnis erhalten.

`JVM-Ergebnisse`


[info] running GraalTest
List((the,3297996), (and,2198664), (of,2198664), (you,1648998), (a,1648998), (in,1648998), (about,1099332), (always,1099332), (with,1099332), (how,1099332))
[success] Total time: 64 s (01:04), completed 2020/06/04 0:38:37
       85.31 real       479.11 user         8.89 sys

Mit GraalVM! ??

Versuchen Sie, das obige Programm auf GraalVM auszuführen.

`.jvmopts`


-Xmx8G

`Lauf`


$ /usr/bin/time sbt run GraalTest.scala

Dann wird das folgende Ergebnis erhalten.

`GraalVM-Ergebnisse`


[info] running GraalTest
List((the,3297996), (and,2198664), (of,2198664), (you,1648998), (a,1648998), (in,1648998), (about,1099332), (always,1099332), (with,1099332), (how,1099332))
[success] Total time: 54 s, completed 2020/06/04 0:40:02
       75.29 real       333.95 user         9.23 sys

Wenn Sie GraalVM verwenden, können Sie sehen, dass es 10 Sekunden schneller ist. Das geht viel schneller !!!!!

↓ Codes zur Leistungsmessung https://github.com/kinshotomoya/loginfrastructure/tree/master/jitCompiler

Zusammenfassung

Wenn Sie Graal anstelle des aktuellen JIT-Compilers verwenden können, sollten Sie es verwenden.

Das nächste Mal werde ich eine weitere Funktion von GraalVM zusammenfassen, das native Image.

Referenz

https://medium.com/graalvm/graalvm-ten-things-12d9111f307d
https://www.graalvm.org/docs/examples/java-performance-examples/