pierre-yves alizon – ingénieurs 2000. sommaire un bref historique larchitecture java la...
TRANSCRIPT
Pierre-Yves ALIZON – Ingénieurs 2000Pierre-Yves ALIZON – Ingénieurs 2000
SommaireSommaire
Un bref historique
L’architecture JAVALa plate-forme javaLe compilateurLe format classLa JVMLe JIT Compiler
Benchmark
Un bref historiqueUn bref historique
Un bref historiqueUn bref historique
Java a été crée grâce aux initiatives de Sun en 1996 (date de la 1ère release officielle du JDK1) : 212 classes.
5 objectifs pour un nouveau langage : code efficace petite taille sécurité robustesse très grande portabilité
En 1999, Javasoft (Sun) sort Java 2 (jdk 1.2) : 1520 classes.
L’architecture de JavaL’architecture de Java
Architecture JAVA : Architecture JAVA : Vue globaleVue globale
PC
Code Sourceclass Toto { string str; public Toto(String name) { str = name;
Compilation
Java RuntimeByte-Code
------------------------------------------------------------------------
PDA MAC
Architecture JAVA : Architecture JAVA : La plate-forme javaLa plate-forme java
C’est l’ensemble des classes de base dont a besoin un programme java pour s’exécuter.
Ces classes sont organisées en paquetages (packages) compressés en jar ou zip.
Certains paquetages concernent : les entrées/sorties la sécurité la création d’interfaces graphiques …
Architecture JAVA : Architecture JAVA : La plate-forme javaLa plate-forme java
Une plate-forme java est donc dépendante du jeu d’API propre à l’OS.
Une partie de la plate-forme java est par conséquent écrite en langage natif.
La plate-forme java n’est pas portable, mais rend java portable lorsqu’elle est portée sur un système d’exploitation.
Architecture JAVA : Architecture JAVA : Le compilateurLe compilateur
Java est à la fois un langage compilé et interprété.
Le compilateur traduit les sources java en instructions binaires : le byte-code.
Création d’un fichier .class par fichier source.
Architecture JAVA : Architecture JAVA : Le format Le format classclass
Chaque fichier class contient la définition d’une seule classe ou interface exprimée en byte-code.
C’est-à-dire : Son nom, celui de sa super classe et de ses interfacesLe noms des classes dont elle dépendDroits d’accèsConstantesSes attributsSes méthodesLe code des méthodes
Architecture JAVA : Architecture JAVA : La JVMLa JVM
La Machine Virtuelle Java est la pièce maîtresse de l’architecture Java.
La JVM interprète le byte-code généré par le compilateur.
Une JVM doit répondre aux spécifications décrites par Sun (disponibles sur son site).
Java est portable uniquement sur les plate-formes où une JVM a été portée.
Sun propose son Runtime Environment pour Solaris, Windows, Linux, …
Architecture JAVA : Architecture JAVA : La JVMLa JVM
La JVM, ou Runtime Interpreter, réalise toutes les activités d’un vrai processeur.
Exécution dans un environnement virtuel et sécurisé.
A noter la présence d’un Garbage Collector qui dé-alloue la mémoire non utilisée.
Architecture JAVA : Architecture JAVA : La JVMLa JVM
Lors du lancement de la JVM, allocation d’une pile et d’un tas (possibilité en général de fixer sa taille initiale et maximale).
Toutes les JVM comprennent le même jeu d’instructions (c’est normal!).
Les types de donnée sont prédéfinis et ont normalement la même taille quelque soit la JVM.
Architecture JAVA : Architecture JAVA : La JVMLa JVM
Interpréteur
Host OS
Hardware
Bytecode
Architecture JAVA : Architecture JAVA : Le JIT compilerLe JIT compiler
JIT compiler = Just In Time compiler
Procédé de traduction dynamique du byte-code en langage machine.
L’astuce :l’interpréteur a déjà été compilé en langage machine.A chaque byte-code correspond donc une séquence de code binaire.Sauvegarde d’une copie de chaque instruction binaire.Correspondance: byte-code instructions binaires
Architecture JAVA : Architecture JAVA : Le JIT compilerLe JIT compiler
Journalisation de l’exécution et re-use de procédures assembleur.Possibilité d’exécuter des méthodes entières beaucoup plus rapidement.De plus, le JIT compiler optimise par à-coups comme un compilateur.
En théorie, un JIT compiler permet d’accélérer une interprétation avec un facteur 10.
Architecture JAVA : Architecture JAVA : Le JIT compilerLe JIT compiler
Interpréteur
JIT Compiler
Host OS
Hardware
Bytecode
Code machine
Le BenchmarkLe Benchmark
Cyrix MII – 300 (225 MHz)64 Mo RAMWindows NT4 WorkStation Service Pack 5
C++ :Compilateur : Microsoft Visual C++ 6.0
JavaCompilateur : Sun JDK 1.2.2Interpréteurs :
•Sun JRE 1.3•IBM JRE 1.1.8
Compilateurs Just in Time :•Sun JRE 1.3•IBM JRE 1.1.8
Benchmark : Benchmark : La plate-forme de testLa plate-forme de test
1) Addition de 2 matrices d’entiers
2) Addition de 2 matrices de réels
3) Multiplication de 2 matrices d’entiers
4) Multiplication de 2 matrices de réels
Benchmark : Benchmark : Les testsLes tests
Benchmark : Benchmark : Test 1Test 1
1 2 34 5 67 8 9
1 2 34 5 67 8 9
+ = 2 4 6 8 10 1214 16 18
Complexité :Nbadditions (n) = n2
Addition de 2 matrices à valeurs entières
Benchmark : Benchmark : Test 2Test 2
1/1 1/2 1/31/4 1/5 1/61/7 1/8 1/9
+ =
Complexité :Nbadditions (n) = n2
1/1 1/2 1/31/4 1/5 1/61/7 1/8 1/9
2 1 2/31/2 2/5 1/32/7 1/4 2/9
Addition de 2 matrices à valeurs réelles
1 2 34 5 67 8 9
1 2 34 5 67 8 9
X = 30 36 42 66 81 96102 126 150
Complexité :Nbadditions (n) = n3
Nbmultiplications (n) = n3
Benchmark : Benchmark : Test 3Test 3
Multiplication de 2 matrices à valeurs entières
X =
Complexité :Nbadditions (n) = n3
Nbmultiplications (n) = n3
Benchmark : Benchmark : Test 4Test 4
1/1 1/2 1/31/4 1/5 1/61/7 1/8 1/9
1/1 1/2 1/31/4 1/5 1/61/7 1/8 1/9
1,06.. … … … … … … … …
Multiplication de matrices à valeurs réelles
IBM JRE 1.1.8 :-JIT disabled « jre –cp . –nojit Bench »-JIT enabled « jre –cp . Bench »
sun JRE 1.3 :-JIT disabled « java –Xint Bench »-JIT enabled « java Bench »
Benchmark : Benchmark : JavaJava
Les différentes plate-formes d’exécution :
Sun JDK 1.2.2 (Java 2)« javac –O Bench.java »
La compilation :
Benchmark : Benchmark : C++C++
Microsoft Visual C++ 6.0
Utilisation de l’option –O2 pour l’optimisation
La compilation :
Benchmark : Benchmark : MesuresMesures
Utilisation de la commande « time », commande portée sur Win32 par cygwin.
Mesure du temps total d’exécution en centièmes de secondes.
Pour java, comptabilisation du temps de chargement de la VM.
La mesure du temps d’exécution :
Benchmark : Benchmark : MesuresMesures
L’exécutable prend en paramètre :Le type des données (int ou double)La taille de la matrice carréeLe type de l’opération à exécuter (addition ou multiplication)
Pour chacun des 4 tests et pour chaque JVM (et C++), on fait varier la taille de la matrice.
Pour l’addition, N=100, 200 et 500Pour la multiplication, N=100, 200 et 300
Pour chaque donnée, on réalise la moyenne de 5 mesures.
Déroulement du benchmark :
Benchmark : Benchmark : MesuresMesures
D’après le calcul des complexités, une addition de 2 matrices 500*500 génèrera 250 000 additions.
Une multiplication de 2 matrices 300*300 :27 millions d’additions27 millions de multiplications
Après la récolte de ces moyennes du temps d’exécution, on les ajuste par rapport à celles du C++. C’est-à-dire que dans tous les graphiques ci-après, T(C++)=1;
Déroulement du benchmark :
Benchmark : Benchmark : MesuresMesures
Mesure du temps d’exécution :
Description du Test NJRE sun 1,3
noJITJRE IBM -
noJITJRE sun 1,3 -
JITJRE IBM -
JITC++
N=100 0,66 0,55 0,62 0,48 0,14N=200 0,87 0,59 0,68 0,50 0,15N=500 2,43 1,96 0,99 0,59 0,29
N=100 0,68 0,44 0,61 0,50 0,14N=200 1,00 0,74 0,75 0,54 0,21N=500 3,29 2,65 1,36 1,06 0,50
N=100 3,29 3,36 0,84 2,47 0,34N=200 22,46 22,69 2,30 1,78 2,32N=300 73,11 75,68 6,82 5,23 6,42
N=100 4,16 3,27 0,92 2,69 0,38N=200 26,21 23,38 3,57 3,60 2,23N=300 86,88 78,81 11,13 11,02 8,30
Addition de 2 matrices - valeurs entières
Addition de 2 matrices - valeurs flottantes
Multiplication de 2 matrices - valeurs entières
Multiplication de 2 matrices - valeurs flottantes
Benchmark : Benchmark : Résultats du test 1Résultats du test 1
Addition de 2 matrices à valeurs entières
0,00
1,00
2,00
3,00
4,00
5,00
6,00
7,00
8,00
9,00
N=100 N=200 N=500
Sun JRE 1,3 - noJIT
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
Visual C++
Benchmark : Benchmark : Résultats du test 2Résultats du test 2
Addition de 2 matrices à valeurs réelles
0,00
1,00
2,00
3,00
4,00
5,00
6,00
7,00
N=100 N=200 N=500
Sun JRE 1,3 - noJIT
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
Visual C++
Benchmark : Benchmark : Résultats du test 3Résultats du test 3
Multiplication de 2 matrices à valeurs entières
0,00
2,00
4,00
6,00
8,00
10,00
12,00
14,00
N=100 N=200 N=300
Sun JRE 1,3 - noJIT
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
Visual C++
Benchmark : Benchmark : Résultats du test 4Résultats du test 4
Multiplication de 2 matrices à valeurs réelles
0,00
2,00
4,00
6,00
8,00
10,00
12,00
14,00
N=100 N=200 N=300
Sun JRE 1,3 - noJIT
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
Visual C++
Benchmark : Benchmark : Le debriefingLe debriefing
Conclusions
Avec l’émergence des JIT compilers, la différence de performance entre les applications Java et C++ s’amenuise.
Et même s’il reste des différences, le programmeur bénéficie de la convivialité de java.