Télécharger la présentation powerpoint

Pierre-Yves ALIZON – Ingénieurs 2000
Sommaire
Un bref historique
L’architecture JAVA
La plate-forme java
Le compilateur
Le format class
La JVM
Le JIT Compiler
Benchmark
Un bref historique
Un 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 Java
Architecture JAVA :
Vue globale
Code Source
class Toto {
string str;
public Toto(String name) {
str = name;
Compilation
Byte-Code
-----------------------------------------------------------------------
PC
PDA
Java Runtime
MAC
Architecture JAVA :
La 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 :
La 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 :
Le 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 :
Le format class
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
interfaces
Le noms des classes dont elle dépend
Droits d’accès
Constantes
Ses attributs
Ses méthodes
Le code des méthodes
Architecture JAVA :
La 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 :
La 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 :
La 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 :
La JVM
Bytecode
Interpréteur
Host OS
Hardware
Architecture JAVA :
Le 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 :
Le 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 :
Le JIT compiler
Bytecode
Interpréteur
JIT Compiler
Code machine
Host OS
Hardware
Le Benchmark
Benchmark :
La plate-forme de test
Cyrix MII – 300 (225 MHz)
64 Mo RAM
Windows NT4 WorkStation Service Pack 5
C++ :
Compilateur : Microsoft Visual C++ 6.0
Java
Compilateur : Sun JDK 1.2.2
Interpréteurs :
•Sun JRE 1.3
•IBM JRE 1.1.8
Compilateurs Just in Time :
•Sun JRE 1.3
•IBM JRE 1.1.8
Benchmark :
Les tests
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 :
Test 1
Addition de 2 matrices à valeurs entières
1
4
7
2
5
8
3
6
9
+
Complexité :
Nbadditions (n) = n2
1
4
7
2
5
8
3
6
9
=
2
8
14
4
10
16
6
12
18
Benchmark :
Test 2
Addition de 2 matrices à valeurs réelles
1/1
1/4
1/7
1/2 1/3
1/5 1/6
1/8 1/9
+
Complexité :
Nbadditions (n) = n2
1/1
1/4
1/7
1/2 1/3
1/5 1/6
1/8 1/9
=
2
1/2
2/7
1 2/3
2/5 1/3
1/4 2/9
Benchmark :
Test 3
Multiplication de 2 matrices à valeurs entières
1
4
7
2
5
8
3
6
9
X
1
4
7
Complexité :
Nbadditions (n) = n3
Nbmultiplications (n) = n3
2
5
8
3
6
9
=
30 36 42
66 81 96
102 126 150
Benchmark :
Test 4
Multiplication de matrices à valeurs réelles
1/1
1/4
1/7
1/2 1/3
1/5 1/6
1/8 1/9
X
1/1
1/4
1/7
Complexité :
Nbadditions (n) = n3
Nbmultiplications (n) = n3
1/2 1/3
1/5 1/6
1/8 1/9
=
1,06.. …
… …
… …
…
…
…
Benchmark :
Java
La compilation :
Sun JDK 1.2.2 (Java 2)
« javac –O Bench.java »
Les différentes plate-formes d’exécution :
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 :
C++
La compilation :
Microsoft Visual C++ 6.0
Utilisation de l’option –O2 pour l’optimisation
Benchmark :
Mesures
La mesure du temps d’exécution :
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.
Benchmark :
Mesures
Déroulement du benchmark :
L’exécutable prend en paramètre :
Le type des données (int ou double)
La taille de la matrice carrée
Le 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 500
Pour la multiplication, N=100, 200 et 300
Pour chaque donnée, on réalise la moyenne de
5 mesures.
Benchmark :
Mesures
Déroulement du benchmark :
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’additions
27 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 ciaprès, T(C++)=1;
Benchmark :
Mesures
Mesure du temps d’exécution :
Description du Test
N
JRE sun 1,3
noJIT
JRE IBM noJIT
JRE sun 1,3 - JRE IBM JIT
JIT
C++
Addition de 2 matrices - valeurs
entières
N=100
N=200
N=500
0,66
0,87
2,43
0,55
0,59
1,96
0,62
0,68
0,99
0,48
0,50
0,59
0,14
0,15
0,29
Addition de 2 matrices - valeurs
flottantes
N=100
N=200
N=500
0,68
1,00
3,29
0,44
0,74
2,65
0,61
0,75
1,36
0,50
0,54
1,06
0,14
0,21
0,50
Multiplication de 2 matrices valeurs entières
N=100
N=200
N=300
3,29
22,46
73,11
3,36
22,69
75,68
0,84
2,30
6,82
2,47
1,78
5,23
0,34
2,32
6,42
Multiplication de 2 matrices valeurs flottantes
N=100
N=200
N=300
4,16
26,21
86,88
3,27
23,38
78,81
0,92
3,57
11,13
2,69
3,60
11,02
0,38
2,23
8,30
Benchmark :
Résultats du test 1
Addition de 2 matrices à valeurs entières
9,00
8,00
7,00
6,00
Sun JRE 1,3 - noJIT
5,00
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
4,00
Visual C++
3,00
2,00
1,00
0,00
N=100
N=200
N=500
Benchmark :
Résultats du test 2
Addition de 2 matrices à valeurs réelles
7,00
6,00
5,00
Sun JRE 1,3 - noJIT
4,00
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
3,00
Visual C++
2,00
1,00
0,00
N=100
N=200
N=500
Benchmark :
Résultats du test 3
Multiplication de 2 matrices à valeurs entières
14,00
12,00
10,00
Sun JRE 1,3 - noJIT
8,00
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
6,00
Visual C++
4,00
2,00
0,00
N=100
N=200
N=300
Benchmark :
Résultats du test 4
Multiplication de 2 matrices à valeurs réelles
14,00
12,00
10,00
Sun JRE 1,3 - noJIT
8,00
IBM JRE 1.1.8 - noJIT
Sun JRE 1,3 - JIT
IBM JRE 1.1.8 - JIT
6,00
Visual C++
4,00
2,00
0,00
N=100
N=200
N=300
Benchmark :
Le 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.