interpréteur

GraalVM 21 avec Java on Truffle

Soumis par fredericmazue le

GraalVM est une machine virtuelle universelle développée par Oracle, permettant d'exécuter des applications écrites dans des langages basés sur JavaScript, Python, Ruby, R, tels que Java, Scala, Kotlin, Clojure et LLVM, tels que C et C ++.

GraalVM supprime l'isolement entre les langages de programmation et permet l'interopérabilité dans un environnement d'exécution partagé.

Cette universalité que présente GraalVM est rendue possible grâce au framework Truffle. Pour dire les choses simplement, Truffle permet de créer des interpréteurs d’arbres syntaxiques. Pour mémoire, un arbre syntaxique est un arbre dont les nœuds représentent des opérateurs du langage, des expressions ou encore des variables. En traitant un tel arbre, il est possible de déterminer les instructions devant être exécutées.

GraalVM 21, qui vient d'être publiée, comporte un nouveau composant : Java on Truffle, nom de code : Espresso. Avant Java on Truffle, l'exécution d'applications Java dans GraalVM était possible en utilisant la VM Java HotSpot avec le compilateur Just-In-Time (JIT) de GraalVM, ou en compilant vers un exécutable natif à l'aide de GraalVM Native Image.

Java on Truffle est une JVM minifiée qui fournit tous les composants de base d'une JVM et assure la prise en charge de l'exécution d'autres langages basés sur JVM comme Kotlin.

Implémenté en Java et capable d'exécuter du, Java, Java On Truffle est un 'Java sur Java' ou un 'Java auto-hébergé', ce qui offre de nouvelles possibilités.

Par exemple, une bibliothèque Java 8 uniquement peut être appelée à partir d'une application Java 11 via l'API Polyglot. Il devient possible aux applications Java d'interagir directement avec des langages non JVM tels que JavaScript et Python, et de passer des données dans les deux sens dans le même espace mémoire. Il est possible de tirer parti des outils standard fournis par le framework Truffle. Par exemple, l'outil de profilage d'échantillonneur de processeur, etc.

Java on Truffle est pour le moment un composant expérimental, qui ne doit donc pas être utilisé en production.

Plus d'informations sur Java on Truffle ici.

Firefox 70 sera doté d'un nouvel interpréteur JavaScript

Soumis par fredericmazue le
Image
Image

Les applications web chargent et exécutent toujours plus de code JavaScript, fait remarquer Mozilla dans un billet. Même si Firefox dispose déjà d'un compilateur JIT performant pour améliorer la vitesse d'exécution de JavaScript dans Firefox, Mozilla a estimé pertinent de doter son navigateur d'un nouvel interpréteur JavaScript. Ce nouvel interpréteur viendra avec Firefox 70.

Mozilla détaille les raisons techniques de sa décision dans un très intéressant billet.

En résumé, jusqu'à Firefox 70, le pipeline d'exécution de code JavaScript était celui-ci :

Ce pipeline pose des problèmes que Mozilla décrit ainsi :

  1. La compilation JIT de Baseline est rapide, mais les applications Web modernes telles que Google Docs ou Gmail exécutent tellement de code JavaScript que nous pourrions passer beaucoup de temps dans le compilateur Baseline, en compilant des milliers de fonctions.
  2. Parce que l'interpréteur C ++ est très lent et ne collecte pas d'informations de type, retarder la compilation de Baseline ou le déplacer hors du thread aurait constitué un risque de perte de performance.
  3. Comme vous pouvez le voir dans le diagramme ci-dessus, le code Ion JIT optimisé ne peut que provenir du JIT Baseline. Pour que cela fonctionne, le code JIT de base nécessitait des métadonnées supplémentaires (le décalage du code machine correspondant à chaque instruction de code intermédiaire).
  4. Le JIT de base comportait un code compliqué pour les plans de secours, le support du débogueur et la gestion des exceptions. C'était particulièrement vrai là où ces caractéristiques se rencontrent!

puis décrit la solution :

Nous avions besoin d'informations de type provenant de JIT Baseline pour activer les niveaux les plus optimisés, et nous voulions utiliser la compilation JIT pour la vitesse d'exécution. Cependant, le Web moderne a des bases de code si volumineuses que même le compilateur relativement rapide JIT Compiler passe beaucoup de temps à compiler. Pour remédier à cela, Firefox 70 ajoute au pipeline un nouveau niveau appelé interpréteur de base:

L'interpréteur de base se situe entre l'interpréteur C ++ et le JIT de base et contient des éléments des deux. Il exécute toutes les instructions bytecode avec une boucle interpréteur fixe (comme l'interpréteur C ++). En outre, il utilise les caches en ligne pour améliorer les performances et collecter des informations de type (comme le JIT de base).

Ce nouvel interpréteur a été construit une réutilisant de manière agréable la plupart du code Baseline JIT Compiler indique encore Mozilla, qui annonce une amélioration des performances de 2 à 8%, avec une amélioration du même ordre pour le temps de chargement, le tout avec une petite réduction de l'empreinte mémoire.

JSCPP : un interpréteur C++ écrit en JavaScript

Soumis par fredericmazue le

Il s'agit d'un interpréteur développé pour un cours MOOC, donc au départ uniquement à des fins pédagogiques. Partant du constat que jusque là, pour mettre un environnement d'exécution C++ en ligne il était nécessaire d'utiliser des serveurs compilant le code C++ à exécuter, l'auteur propose JSCPP, un interpréteur C++ qui peut travailler avec un serveur node.js, ou même de manière totalement autonome dans un navigateur.

JSCPP est un interpréteur C++ écrit en JavaScript. Certes en l'état, il est bien loin de prendre en charge l'intégralité du standard C++, mais il a le mérite d'exister et une utilisation dans un cadre pédagogique, disons pour prendre contact avec C++ sans devoir compiler du code à chaque fois paraît intéressante.

Obtenir un navigateur qui interprète du C++ est tout simple. On doit simplement charger le code JavaScript de l'interpréteur et mettre C++ à interpréter dans une chaine de caractère. Par exemple comme ceci :

<script src="JSCPP.es5.min.js"></script>
<script type="text/javascript">
           var code =            "#include <iostream>"+
                                            "using namespace std;"+
                                            "int main() {"+
                                            "    int a;"+
                                            "    cin >> a;"+
                                            "    cout << a << endl;"+
                                           "    return 0;"+
                                            "}"
           ;
           var input = "4321";
           var output = "";
           var config = {
                      stdio: {
                                 write: function(s) {
                                            output += s;
                                 }
                      }
           };
           var exitCode = JSCPP.run(code, input, config);
           alert(output + "\nprogram exited with code " + exitCode);
</script>

Cette approche permet de modifier le code C++ dans le navigateur et de tester immédiatement le résultat.  

Une démonstration en ligne de JSCPP est disponible ici.

JSCPP est open source. Son code est disponible sur GitHub.

Un nouvel interpréteur .NET pour Mono

Soumis par fredericmazue le

Le projet Mono complète son compilateur JIT et son compilateur statique avec un interpréteur qui amène de nouvelles façons d'exécuter du code.

L'interpréteur .NET n'est pas une idée nouvelle au sien du projet Mono. En 2001, un tel outil existait déjà, mais il était alors considéré comme devant être temporaire, en attendant que le compilateur JIT soit au point. Cet interpréteur a été assez vite abandonné, notamment en raison du fait qu'il était coûteux en termes de ressources de développement de le maintenir avec l'arrivée des génériques.

Aujourd'hui le projet Mono ressort cet interpréteur. L'outil a bien sûr été mis à niveau et il supporte les génériques. La motivation principale de la résurrection de cet outil est de fournir aux développeurs un outils qui leur dispense de recompiler tout un projet, suite à des modifications du code. Un interpréteur permet de voir tout de suite que les modifications apportées au code se comporte selon ce qu'on attend d'elles, ce qui fait gagner beaucoup de temps de développement.

Cet interpréteur va continuer à évoluer et proposera bientôt un mode d'exécution mixte qui permettra d'exécuter du code source (interprété donc) en compagnie de code compilé statiquement ou produit par le compilateur JIT.

Ignition : Google réduit l'empreinte mémoire de son moteur JavaScript V8

Soumis par fredericmazue le
Image

Google vient de publier un très intéressant billet détaillant des progrès réalisés quant à l'empreinte mémoire de son moteur JavaScript V8.

Ce billet explique que V8 et les autres moteurs JavaScript modernes obtiennent leur rapidité à l'exécution d'un compilateur Just-in-Time (JIT) qui compile un script JavaScript en code machine natif juste avant l'exécution. Le code est au départ compilé par un compilateur de base qui génère rapidement un code machine non optimisé. Ce code est ensuite analysé lors de l'exécution et éventuellement recompilé dynamiquement et se voit alors appliquer des optimisations pointues pour gagner en performance.

Avec V8, ce pipeline est complexe car il nécessite de faire des commutations entre le compilateur de base et les deux optimiseurs que sont Crankshaft et Turbofan. Un des problèmes dans tout ça est que ce traitement consomme beaucoup de mémoire, ce qui est peu rentable pour des portions de code exécutés une seule fois.

C'est là que vient l'amélioration Ignition, qui à la place du compilateur de base, compile le code JavaScript en un bytecode concis. Le résultat a une empreinte mémoire de 50% à 25% inférieure à celle du code compilé par le compilateur de base.

Ce bytecode est alors interprété par un interpréteur hautes performances qui montre sur des sites du monde réels des résultats équivalents en terme de rapidité à ce qui était obtenu par l'ancien procédé, assure Google.

L'interpréteur d'Ignition est une machine registre dont chaque bytecode spécifie les entrées/sorties comme des opérandes de registre explicites, ce qui est plus performant qu'une machine à pile avec laquelle le traitement de chaque bytecode consomme des empilages/dépilages.

Ignition viendra avec Chrome 53. Il sera activé sur les appareils Android qui ont une faible capacité mémoire (512 Mo ou moins). Google assure que le gain global de mémoire sera d'environ 5% par onglet ouvert.

[video:https://www.youtube.com/watch?v=r5OWCtuKiAk]