Le JDK 9 va supporter la compilation anticipée (AOT)
En commençant par les systèmes Linux 64-bit exécutant Java 64-bit

Le , par Michael Guilloux, Chroniqueur Actualités
Java 9 sera livré avec le support de la compilation anticipée (ou compilation AOT). La compilation anticipée est une compilation qui traduit un langage évolué en langage machine avant l'exécution d'un programme. Elle s’oppose à la compilation à la volée (JIT) qui se fait lors de l'exécution du programme. La compilation AOT va donc permettre de compiler les classes Java en code natif avant de lancer la machine virtuelle.

Si les compilateurs à la volée (JIT) sont rapides, la compilation AOT vise à résoudre certains problèmes comme le fait que le temps de « warm up » du JIT peut être beaucoup plus long pour les grandes applications. « Il est également possible que des méthodes Java rarement utilisées ne soient jamais compilées du tout, ce qui peut potentiellement affecter les performances en raison d'invocations interprétées de façon répétée », a expliqué Vladimir Kozlov dans une proposition d’amélioration pour le JDK (JEP).

Cette proposition d’amélioration visant à apporter la compilation AOT a été acceptée dans le projet OpenJDK et sera implémentée dans la prochaine version du JDK, attendue en juillet 2017. Les objectifs sont d’améliorer le temps de démarrage à la fois des petites et grandes applications Java, avec au plus un impact limité sur les performances, tout en changeant le flux de travail de l'utilisateur final aussi peu que possible.

Dans le JEP 295, il est précisé que « pour la version initiale [de la compilation AOT], le seul module pris en charge est java.base. Ceci est fait pour limiter le périmètre de problèmes, puisque le code Java dans java.base est bien connu à l'avance et peut être soigneusement testé en interne. La compilation AOT de tout autre module JDK, ou du code utilisateur, est expérimentale. » La compilation AOT sera faite par un nouvel outil baptisé jaotc, un compilateur java statique qui produit du code natif pour les méthodes java compilées.

« Pour utiliser le module java.base AOT, l'utilisateur devra compiler le module et copier la bibliothèque AOT résultante dans le répertoire d'installation de JDK, ou le spécifier sur la ligne de commande java. L'utilisation du code AOT-compilé est par ailleurs totalement transparente pour les utilisateurs finaux », est-il également indiqué dans le JEP.

Étant donné qu’il s’agit d’un début d’implémentation, il faut aussi noter que la compilation AOT dans le JDK 9 aura certaines limitations à prendre en compte :

  • la version initiale de la compilation AOT dans le JDK 9 n'est prise en charge que sur des systèmes Linux 64 bits exécutant Java 64 bits ;
  • le système doit avoir installé libelf pour permettre la génération de bibliothèques AOT partagées (.so) à la suite de la compilation AOT ;
  • la compilation AOT doit être exécutée sur le même système ou sur un système avec la même configuration que celui sur lequel le code AOT sera utilisé par l'application Java ;
  • pour la version initiale dans le JDK 9, le seul module pris en charge pour la compilation AOT sera java.base ;
  • seuls G1 et Parallel GC sont pris en charge pour le moment ;
  • il peut ne pas être possible de compiler le code Java qui utilise des classes générées dynamiquement et du bytecode (expressions lambda, invoke dynamic) ;
  • la même configuration de runtime Java doit être utilisée lors de la compilation AOT et de l'exécution. Par exemple, l'outil jaotc doit être exécuté avec Parallel GC si une application va également utiliser Parallel GC avec le code AOT.

Ces différentes limitations seront progressivement traitées dans les versions suivantes du JDK.

Source : OpenJDK

Et vous ?

Que pensez-vous de la prise en charge de la compilation AOT dans le JDK ?

Voir aussi :

JDK 9 : la nouvelle date de sortie est fixée au 27 juillet 2017, après acceptation de la demande de report de Mark Reinhold
JavaOne 2016 : Oracle veut moderniser Java EE 8 pour le cloud et repousse sa sortie à fin 2017, Java EE 9 devrait être disponible un an plus tard
NetBeans en voie de devenir un projet de la fondation Apache, le projet vient d'être accepté dans Apache Incubator


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse Signaler un problème

Avatar de gros_bidule gros_bidule - Membre du Club https://www.developpez.com
le 28/10/2016 à 18:13
Je ne sais pas, au début de la news ça avait l'air sympa ; avant de lire les 36 conditions.
Ils feraient mieux d'inclure moins de features dans les futurs JDK, ça permettrait de raccourcir le cycle de sorties du JDK. Là, il faut attendre beaucoup trop longtemps avant d'avoir des features qu'on a depuis des lustres sur d'autres plateformes de dev. Et ne parlons pas de la lenteur à laquelle les entreprises migrent d'un JDK à un autre (le JDK7 c'est encore tout nouveau pour certaines). Des cycles plus courts leur forceraient peut être la main.
Avatar de derderder derderder - Membre averti https://www.developpez.com
le 28/10/2016 à 19:41
Plutôt que de tout refaire from scratch, il ferait mieux de réutiliser le code de ART ( Android Runtime, le précompilateur java d'Android) qui marche et est largement testé et utilisé, plutôt que de se lancer dans leur propre implémentation infaisable à faire dans les délais de sortie du JDK...
Avatar de Songbird Songbird - Responsable Rust https://www.developpez.com
le 28/10/2016 à 22:11
la compilation AOT doit être exécutée sur le même système ou sur un système avec la même configuration que celui sur lequel le code AOT sera utilisé par l'application Java
Je ne vois plus tellement l'intérêt d'utiliser Java, dans ce cas.
Avatar de yann2 yann2 - Membre expérimenté https://www.developpez.com
le 29/10/2016 à 13:12
Citation Envoyé par derderder Voir le message
Plutôt que de tout refaire from scratch, il ferait mieux de réutiliser le code de ART ( Android Runtime, le précompilateur java d'Android) qui marche et est largement testé et utilisé, plutôt que de se lancer dans leur propre implémentation infaisable à faire dans les délais de sortie du JDK...
Si je ne me trompe pas, ART c'est uniquement pour l'OS Android.

Citation Envoyé par Songbird_ Voir le message
Je ne vois plus tellement l'intérêt d'utiliser Java, dans ce cas.
Un des intérêts de Java est effectivement Write once run everywhere. Effectivement, avec cette fonctionnalité ce ne sera plus le cas (mais bon personne nous oblige à faire de la compilation anticipée...). A terme, ils visent certainement le Write once compile everywhere ?! Le write once run everywhere n'est pas du tout le seul intérêt de Java.

Je ne me sens pas vraiment excité par la news, le but est d'éliminer le coût d'évaluation des instructions interprétées mais c'est déjà ce que fait le JIT (ok c'est au runtime mais, ça coûte si cher que ça ? Un serveur, une fois démarré, on n'est pas censé le redémarrer toutes les 20 minutes). En fait, j'ai du mal à voir un use case intéressant pour cette techno (je n'ai pas lu la source) ou alors peut être pour une application pour laquelle on veut des performances aux petits oignons ?!
Avatar de Songbird Songbird - Responsable Rust https://www.developpez.com
le 29/10/2016 à 15:26


Un des intérêts de Java est effectivement Write once run everywhere. Effectivement, avec cette fonctionnalité ce ne sera plus le cas (mais bon personne nous oblige à faire de la compilation anticipée...). A terme, ils visent certainement le Write once compile everywhere ?! Le write once run everywhere n'est pas du tout le seul intérêt de Java.
Je suis bien d'accord sur le fait qu'il n'y a pas que la portabilité aisée comme intérêt à utiliser Java, toutefois cette portabilité est quand même bien ancrée dans le coeur du langage.
Après oui effectivement, on ne nous oblige pas d'utiliser la compilation anticipée, mais, comme tu l'as dit toi-même, je ne vois pas d'intérêt à utiliser cette fonctionnalité.

En revanche, dans le domaine du jeu vidéo, ça pourrait peut-être permettre à Java de commencer à faire ses premiers pas concrets dans ce milieu.
Avatar de adiGuba adiGuba - Expert éminent sénior https://www.developpez.com
le 29/10/2016 à 21:13
Citation Envoyé par yann2 Voir le message
Je ne me sens pas vraiment excité par la news, le but est d'éliminer le coût d'évaluation des instructions interprétées mais c'est déjà ce que fait le JIT (ok c'est au runtime mais, ça coûte si cher que ça ? Un serveur, une fois démarré, on n'est pas censé le redémarrer toutes les 20 minutes). En fait, j'ai du mal à voir un use case intéressant pour cette techno (je n'ai pas lu la source) ou alors peut être pour une application pour laquelle on veut des performances aux petits oignons ?!
Je pense que l'intérêt se situe plutôt coté client pour accélérer le démarrage des applications, en conservant le code natif au lieu de le recompiler à chaque fois...
Ou alors pour déployer des applications sur des devices spécifiques (TV, etc.)

Citation Envoyé par Songbird_ Voir le message
En revanche, dans le domaine du jeu vidéo, ça pourrait peut-être permettre à Java de commencer à faire ses premiers pas concrets dans ce milieu.
Je pense que le plus gros problème vient plus de l'absence de type "value", qui rend le partage de données difficile entre Java et les appels systèmes natifs...

a++
Avatar de bouye bouye - Rédacteur/Modérateur https://www.developpez.com
le 30/10/2016 à 0:38
Coté client et encore plus sur mobile ou le JIT n'est pas forcément autorisé (hum iOS). Donc à la longue ça sera forcément utile pour le port mobile de l'OpenJDK.
Et puis en chipotant, cela ne change rien au "Write Once, run anywhere". C'est juste, et uniquement pour ceux utilisant cette fonctionnalité, qu'il faudra faire des compilations spécifiques pour les plateformes ciblées, le code Java lui ne changeant pas.

Par contre, je m'étonne que cette fonctionnalité soit annoncée si tardivement. Plusieurs propositions pour JavaFX pour le JDK9 (telles que le support de WebGL ou encore le remplacement du moteur de rendu Pisces par Marlin un moteur beaucoup plus performant) sont actuellement, après discussions sur la mailing liste de l'OpenJFX, repoussées au calendes grecques (post release JDK 9 ou même JDK 10) sous le prétexte que le JDK9 est déjà "feature complete" et donc qu'il est trop tard pour rajouter des fonctionnalités totalement nouvelles, trop drastiquement différentes ou demandant de trop longues phases de test ou de stabilisation.
Avatar de yann2 yann2 - Membre expérimenté https://www.developpez.com
le 30/10/2016 à 12:58
Citation Envoyé par adiGuba Voir le message
Je pense que l'intérêt se situe plutôt coté client pour accélérer le démarrage des applications, en conservant le code natif au lieu de le recompiler à chaque fois...
Ou alors pour déployer des applications sur des devices spécifiques (TV, etc.)

a++
Ok pour le côté device spécifique mais pour un client lourd j'ai vraiment du mal à voir l'intérêt. Il me semble que le JIT est capable d'optimiser la génération de code machine en analysant la manière dont est utilisée l'application (inline d'une opération souvent appelée par exemple). En générant le code machine au moment de la compilation on perd ces optimisations, non ?

Bon du coup je suis allé voir la source :

Motivations

JIT compilers are fast, but Java programs can become so large that it takes a long time for the JIT to warm up completely. Infrequently-used Java methods might never be compiled at all, potentially incurring a performance penalty due to repeated interpreted invocations.
Ok, ça aurait été sympa d'avoir des exemples ou chiffres. Parce que, chez moi, Java est déjà super rapide, les seules fois où j'ai des problèmes de performance c'est parce que j'ai fait de la merde

Ils ont l'air perplexes sur reddit aussi : https://www.reddit.com/r/java/comments/57eyh2/jep_295_aheadoftime_compilation/. J'ai beaucoup aimé ce commentaire :

This is a monster truck feature. Occasionally useful but will be mostly used by jackasses who don't really need it.
Avatar de adiGuba adiGuba - Expert éminent sénior https://www.developpez.com
le 30/10/2016 à 18:07
Citation Envoyé par yann2 Voir le message
Ok pour le côté device spécifique mais pour un client lourd j'ai vraiment du mal à voir l'intérêt. Il me semble que le JIT est capable d'optimiser la génération de code machine en analysant la manière dont est utilisée l'application (inline d'une opération souvent appelée par exemple). En générant le code machine au moment de la compilation on perd ces optimisations, non ?
Oui en effet on perdrait certaines optimisations liés au contexte d’exécution.
Mais apparemment le code AOT peut être recompilé par le compilateur JIT.

Donc grosso-modo cela pourrait aussi permettre d'exécuter du code natif au lieu du code interprété, tout en bénéficiant d'une compilation JIT si besoin.

Citation Envoyé par yann2 Voir le message
Ok, ça aurait été sympa d'avoir des exemples ou chiffres. Parce que, chez moi, Java est déjà super rapide, les seules fois où j'ai des problèmes de performance c'est parce que j'ai fait de la merde
Je pense que l'intérêt c'est d'améliorer le temps de démarrage.
Java est très performant pour de "grosses" tâches, mais moins pour un programme qui retourne une valeur immédiatement...

Le fait d'avoir un java.base précompilé devrait aider de ce coté là.

a++
Avatar de l'art souille l'art souille - Membre régulier https://www.developpez.com
le 02/11/2016 à 23:06
Une excellente étude (IBM) en plusieurs parties sur la compilation real-time Java (notamment Part 2 : JIT et AOT) : http://www.ibm.com/developerworks/vi...time+Java+Part
Contacter le responsable de la rubrique Accueil