Discussion :

[visiwi]

Bonjour,

J'ai remarqué qu'il est plus rapide d'utiliser un int plutot qu'un long pour faire un même calcul. Jusqu'ici, rien ne me choquait puisque un int est sur 32bits et qu'un long sur 64. Mais j'ai remarqué qu'il n'y pratiquement aucune différence entre un long et un byte (pour un même calcul) alors que le int est sensiblement plus rapide.
Je me demandais pourquoi l'utilisation du type int est plus rapide ?

[dinobogan]

La JVM de Sun utilise des int en interne. Le byte n'existe pas. La JVM va devoir traiter le int pour en faire un byte.
Sinon, on pourrait avoir ton code de test ?

[visiwi]

La JVM de Sun utilise des int en interne. Le byte n'existe pas. La JVM va devoir traiter le int pour en faire un byte.

Ah, Ok.

Sinon, on pourrait avoir ton code de test ?

Oui, bien sûr.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
public class Test {
 
	public static void main(String[] args) {
		a();
		b();
		c();
		d();
	}
 
	private static void a() {
		long b = 0;
		long start = System.nanoTime();
		for (int a = 0; a < 100; a++) {
			b += 1;			
		}
		long duree = System.nanoTime() - start;
		System.out.println("long = " + duree);
	}
 
	private static void b() {
		byte b = 0;
		long start = System.nanoTime();
		for (int a = 0; a < 100; a++) {
			b += 1;			
		}
		long duree = System.nanoTime() - start;
		System.out.println("byte = " + duree);
	}
 
	private static void c() {
		int b = 0;
		long start = System.nanoTime();
		for (int a = 0; a < 100; a++) {
			b += 1;			
		}
		long duree = System.nanoTime() - start;
		System.out.println("int = " + duree);
	}
 
	private static void d() {
		Integer b = new Integer(0);
		long start = System.nanoTime();
		for (int a = 0; a < 100; a++) {
			b += 1;			
		}
		long duree = System.nanoTime() - start;
		System.out.println("Integer = " + duree);
	}
 
}

J'obtiens sous ubuntu :

long = 1979
byte = 1931
int = 1694
Integer = 420664

C'est marrant parce que je viens de tester sous Windows XP (sur une autre machine) et je n'obtiens pas du tout cela. Dans ce cas, le byte est plus rapide !?!?!?!

long = 6704
byte = 5308
int = 5867
Integer = 946768

[dinobogan]

Ce n'est pas une bonne méthode de test : le temps d'exécution est beaucoup trop petit. Ton programme n'a pas toute la machine pour lui. Entre temps, il y a une multitudes d'interruptions qui interviennent.
Tu dois faire beaucoup plus d'itération dans ta boucle, genre 1 milliard. Et tu dois faire le test plusieurs fois de suite et calculer la moyenne de l'exécution.
Pour info, mon propre test sur ma machine anté-diluvienne donne le byte grand perdant avec un temps d'exécution 3 fois plus grand. Le int et le long sont équivalents.

[visiwi]

Je ne discute pas que ce test n'est pas au petit oignon, mais je ferais juste remarquer que cela ne change rien. La proportion est a peu prêt la même. Le int est le grand gagnant et le long et byte les perdant. Sauf que le byte se rapproche un peu plus des perfs du int avec 1 milliard d'itérations.

A noter que j'utilise la dernière JVM de Sun disponible.

Les performances des différent types primitifs semblent être différent suivant les machines et les OS. Je n'ai pas l'impression que cela soit très prévisible !

Merci bien pour ta réponse en tout cas, c'est sympa