[JAVA] Essayez d'utiliser GraalVM

Préface

Étant donné que cet article se concentre sur les performances de GraalVM et les performances lors de l'utilisation de Graal en tant que compilateur JIT, cet article n'aborde pas l'une des fonctionnalités de GraalVM, telles que l'image native et plusieurs langues.

environnement

macOS Mojava 10.14.4
Scala 2.13.1
sbt 1.3.8
GraalVM 20.1

Qu'est-ce que Graal VM

C'est une VM équipée de Graal, le dernier compilateur JIT écrit en Java. Selon le Document officiel de GraalVM, Graal présente les caractéristiques suivantes.

Graal lui-même est implémenté en java, ce qui peut considérablement accélérer les programmes Java avec des optimisations puissantes telles que l'analyse d'échappement partielle impossible avec les compilateurs JIT standard.

La vitesse à laquelle il sera réellement sera décrite plus tard.

Au fait, s'il est difficile de changer la VM, il semble que vous ne puissiez changer que le compilateur JIT en Graal en ajoutant les options suivantes. Cependant, veuillez noter que selon Reference, il ne peut être utilisé qu'avec JDK10 ou version ultérieure.

-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

Architecture de machine virtuelle Graal

Il a l'architecture suivante. Par rapport à la JVM standard, la partie C2 a été remplacée par le compilateur Graal. Les parties Graal et JVMCI sont implémentées en Java.

JVMCI Un compilateur implémenté par Java qui peut être utilisé dans JVM en tant que compilateur dynamique.

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

En fait utiliser

Installation

Suivez les instructions des Documents officiels. Pour macOS, ici

Comparez la vitesse avec la VM standard d'OpenJDK et de GraalVM

Une comparaison de vitesse plus détaillée peut être trouvée dans cet article.

Exécutez un programme qui recrache les 10 principaux types de mots contenus dans 275 Mo GraalTest.txt.


$ 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

Utilisez GraalVM installé ci-dessus en tant que 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)

Ci-dessous, le programme d'exécution

`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])
  }
}

résultat

Avec la VM standard d'OpenJDK! ??

À titre de comparaison, exécutons le programme en utilisant le compilateur JIT standard d'OpenJDK. Si vous spécifiez -XX: -Use JVMCI Compiler, vous pouvez utiliser le compilateur JIT standard d'OpenJDK.

`.jvmopts`


-XX:-UseJVMCICompiler
-Xmx8G

`Courir`


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

Ensuite, le résultat suivant est obtenu.

`Résultats JVM`


[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

Avec GraalVM! ??

Essayez d'exécuter le programme ci-dessus sur GraalVM.

`.jvmopts`


-Xmx8G

`Courir`


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

Ensuite, le résultat suivant est obtenu.

`Résultats GraalVM`


[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

En utilisant GraalVM, vous pouvez voir qu'il est 10 s plus rapide. C'est beaucoup plus rapide !!!!!

↓ Codes utilisés pour la mesure des performances https://github.com/kinshotomoya/loginfrastructure/tree/master/jitCompiler

Résumé

Si vous pouvez utiliser Graal au lieu du compilateur JIT actuel, vous devez l'utiliser.

La prochaine fois, je résumerai une autre fonctionnalité de GraalVM, native-image.

référence

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