Est-ce toujours plus rapide d'exécuter des opérations dans la mémoire des machines ? Non, selon des chercheurs

Expert éminent sénior

Le 27/03/2015 à 13:39

Cette étude a été démontée sur le forum du Daily WTF quand un lecteur s'est rendu compte que la version "mémoire" de la concaténation de chaîne utilisait la concaténation Java, qui ré-alloue une nouvelle String à chaque fois, copiant le contenu de la précédente et ajoutant le nouveau caractère. En gros, d'après ledit lecteur tout le test s'effondre sur une erreur de String contre StringBuilder.

10

0

De Bain

Nouveau membre du Club

Le 27/03/2015 à 15:48

Une petite recherche sur Google Scholar et on voit que l'article n'a jamais été publié dans une revue ou une conférence scientifique (et donc jamais été relu par d'autres scientifiques). Il s'agit seulement d'une soumission à une plateforme d'hébergement et de référencement d'articles.

C'est n'est pas "une étude scientifique", c'est "un papier écrit par 3 scientifiques qui personne n'a relu", ca n'a pas plus de valeur scientifique qu'un billet de blog.

8

0

bigjeff

Membre du Club

Le 27/03/2015 à 14:47

Bonjour,

En lisant l'article j'ai été surpris des résultats, j'ai repris le code qui est dans lien. J'ai été surpris de voir que la concaténation (en Java) se faisait avec la classe String et + pour concaténer.

J'ai repris le code, j'ai crée 2 classes une pour le test en mémoire puis écriture et l'autre pour l'écriture directe afin que le deuxième cas ne récupère pas les gains d'optimisation de la JVM du premier cas.

À la place de la classe String j'ai testé StringBuilder puis StringBuffer et les résultats sont tout autre, j'ai réduit la zone mémoire à 100 000 au lieu de 1 000 000 afin que cela s'exécute plus vite sur mon PC. Voici les résultats :

La concaténation en mémoire :
Avec String et +: 2.7836 secondes
Avec StringBuffer et append : 0.00279 seconde
Avec StringBuilder et append : 0.0016 seconde

Les résultats d'écriture disque sont à peu près égaux à l'étude initiale.

Côté Python je n'ai pas assez de connaissance mais en Java il vaut mieux travailler en mémoire.

Peut-être que je me trompe.

6

0

Voyvode

Membre émérite

Le 27/03/2015 à 14:06

Je viens de regarder le code. Il y a aussi un autre problème avec cette étude (en Java du moins) : les opérations prétendument disk-only sont faites avec des BufferedWriter.

Dans ce cas, c’est justement grâce à la mémoire que les écritures fréquentes sur le disque ont l’air si rapides.

[EDIT] Après vérification, Python utilise par défaut le système de cache de l’OS avec la commande open. Même topo donc.

5

0

iolco51

Membre habitué

Le 27/03/2015 à 16:41

Dans la plupart des tests Windows est deux fois plus lent que Linux, lorsque ce n'est pas le cas les performances sont à peu près équivalentes. C'est intéressant.

Sinon je ne comprends pas l'objectif du test, s'il s'agit d'écrire en séquentiel sur le disque alors c'est certain, pourquoi d'abord faire une concaténation en mémoire (ce qui signifie reallocations multiples) en concaténant des chaines alors qu'on peut écrire directement sur le disque, ce qu'il faudra faire de toutes façons. C'est une évidence.

Le test intelligent est d'utiliser des memory mapped files, d'y écrire en séquentiel et de laisser l'OS travailler. Utiliser les types strings du langage de programmation pour les concaténer ensemble au préalable n'a absolument aucun sens lorsque c'est une séquence à écrire telle quelle.

Cela se résume à : Est-ce que faire les operations 1,000,000 de fois en memoire et écrire sur disque est plus rapide que ne traiter qu'une seule fois et directement écrire sur disque.... La réponse est évidente.

5

0

kolodz

Modérateur

Le 27/03/2015 à 17:40

Après, quand tu lis le papier il y a des trucs qui choc :

Envoyé par Publication

Kamran Karimi¹, Diwakar Krishnamurthy², Parissa Mirjafari³
Dept of Biological Sciences ¹,
Dept of Electrical and Computer Engineering ²,
Dept of Chemical and Biological Engineering ³

En résumé, 2 chimistes et un électronicien...

Lecture au survole de la publication :

Envoyé par Publication

Appendix 1. However, using a mutable data type such as StringBuilder or StringBuffer dramatically improved the results.

Genre information secondaire ! Pas comme si l'ensemble de papier est basé dessus...

@bigjeff : Non non tu ne te trompe pas !
Voici mon test avec le code correspondant !

String + String (Version original)
Pas les temps beaucoup trop long sur ma machine !!!

Code java :

Sélectionner tout

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// By Kamran Karimi (kkarimi@ucalgary.ca) 
// Complete version. Runs each experiment 10 times 
import java.io.IOException; 
import java.io.FileWriter; 
import java.io.BufferedWriter; 
  
public class Test { 
	public static void main(String[] args) { 
		// number of increments for the file content. 
		int numAdd = 1; // Additional changes are needed when NUM_ADD = 1e6 
		int NUM_ITERATIONS = 10; 
		long totalMemory = (long) 1000000; // total amount of memory in bytes 
		String addString = ""; 
		for (int i = 0; i < numAdd; i++) { 
			addString += "1"; 
		} 
		double[] stringTimes = new double[NUM_ITERATIONS]; 
		double[] fileTimes1 = new double[NUM_ITERATIONS]; 
		double[] fileTimes2 = new double[NUM_ITERATIONS]; 
		for (int count = 0; count < NUM_ITERATIONS; count++) { 
			stringTimes[count] = fileTimes1[count] = fileTimes2[count] = 0; 
			BufferedWriter writer; 
			// First part: in-memory 
			long numIter = totalMemory / addString.length(); 
			String  concatString = ""; 
			long startTime = System.currentTimeMillis(); 
			for (int i = 0; i < numIter; i++) { 
				concatString+=addString; 
			} 
			long endTime = System.currentTimeMillis(); 
			double stringTime = (endTime - startTime) / 1000.0; 
			stringTimes[count] = stringTime; 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				writer.write(concatString); 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
			} catch (IOException e) { 
			} 
			double fileTime = (endTime - startTime) / 1000.0; 
			fileTimes1[count] = fileTime; 
			// Second part: disk-only 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				for (int i = 0; i < numIter; i++) { 
					writer.write(addString); 
				} 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
				fileTime = (endTime - startTime) / 1000.0; 
				fileTimes2[count] = fileTime; 
			} catch (IOException e) { 
			} 
		} 
		double stringMean = 0; 
		for (int i = 0; i < stringTimes.length; i++) { 
			stringMean += stringTimes[i]; 
		} 
		stringMean /= stringTimes.length; 
		double fileMean1 = 0; 
		for (int i = 0; i < fileTimes1.length; i++) { 
			fileMean1 += fileTimes1[i]; 
		} 
		fileMean1 /= fileTimes1.length; 
		double fileMean2 = 0; 
		for (int i = 0; i < fileTimes2.length; i++) { 
			fileMean2 += fileTimes2[i]; 
		} 
		fileMean2 /= fileTimes2.length; 
		System.err.println("In-memory mean: string time" + stringMean); 
		System.err.println("In-memory mean: file time " + fileMean1); 
		System.err.println("In-memory mean: Total " + (fileMean1+stringMean)); 
		System.err.println("Disk-only mean: file time " + fileMean2); 
	} 
}

StringBuilder append
In-memory mean: string time0.020599999999999997
In-memory mean: file time 0.007000000000000001
In-memory mean: Total 0.0276
Disk-only mean: file time 0.0397

Code Java :

Sélectionner tout

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// By Kamran Karimi (kkarimi@ucalgary.ca) 
// Complete version. Runs each experiment 10 times 
import java.io.IOException; 
import java.io.FileWriter; 
import java.io.BufferedWriter; 
  
public class Test { 
	public static void main(String[] args) { 
		// number of increments for the file content. 
		int numAdd = 1; // Additional changes are needed when NUM_ADD = 1e6 
		int NUM_ITERATIONS = 10; 
		long totalMemory = (long) 1000000; // total amount of memory in bytes 
		String addString = ""; 
		for (int i = 0; i < numAdd; i++) { 
			addString += "1"; 
		} 
		double[] stringTimes = new double[NUM_ITERATIONS]; 
		double[] fileTimes1 = new double[NUM_ITERATIONS]; 
		double[] fileTimes2 = new double[NUM_ITERATIONS]; 
		for (int count = 0; count < NUM_ITERATIONS; count++) { 
			stringTimes[count] = fileTimes1[count] = fileTimes2[count] = 0; 
			BufferedWriter writer; 
			// First part: in-memory 
			long numIter = totalMemory / addString.length(); 
			StringBuilder  concatString = new StringBuilder (); 
			long startTime = System.currentTimeMillis(); 
			for (int i = 0; i < numIter; i++) { 
				concatString.append(addString); 
			} 
			long endTime = System.currentTimeMillis(); 
			double stringTime = (endTime - startTime) / 1000.0; 
			stringTimes[count] = stringTime; 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				writer.write(concatString.toString()); 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
			} catch (IOException e) { 
			} 
			double fileTime = (endTime - startTime) / 1000.0; 
			fileTimes1[count] = fileTime; 
			// Second part: disk-only 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				for (int i = 0; i < numIter; i++) { 
					writer.write(addString); 
				} 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
				fileTime = (endTime - startTime) / 1000.0; 
				fileTimes2[count] = fileTime; 
			} catch (IOException e) { 
			} 
		} 
		double stringMean = 0; 
		for (int i = 0; i < stringTimes.length; i++) { 
			stringMean += stringTimes[i]; 
		} 
		stringMean /= stringTimes.length; 
		double fileMean1 = 0; 
		for (int i = 0; i < fileTimes1.length; i++) { 
			fileMean1 += fileTimes1[i]; 
		} 
		fileMean1 /= fileTimes1.length; 
		double fileMean2 = 0; 
		for (int i = 0; i < fileTimes2.length; i++) { 
			fileMean2 += fileTimes2[i]; 
		} 
		fileMean2 /= fileTimes2.length; 
		System.err.println("In-memory mean: string time" + stringMean); 
		System.err.println("In-memory mean: file time " + fileMean1); 
		System.err.println("In-memory mean: Total " + (fileMean1+stringMean)); 
		System.err.println("Disk-only mean: file time " + fileMean2); 
	} 
}

StringBuffer append
In-memory mean: string time0.037399999999999996
In-memory mean: file time 0.007000000000000001
In-memory mean: Total 0.044399999999999995
Disk-only mean: file time 0.041499999999999995

Code Java :

Sélectionner tout

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// By Kamran Karimi (kkarimi@ucalgary.ca) 
// Complete version. Runs each experiment 10 times 
import java.io.IOException; 
import java.io.FileWriter; 
import java.io.BufferedWriter; 
  
public class Test { 
	public static void main(String[] args) { 
		// number of increments for the file content. 
		int numAdd = 1; // Additional changes are needed when NUM_ADD = 1e6 
		int NUM_ITERATIONS = 10; 
		long totalMemory = (long) 1000000; // total amount of memory in bytes 
		String addString = ""; 
		for (int i = 0; i < numAdd; i++) { 
			addString += "1"; 
		} 
		double[] stringTimes = new double[NUM_ITERATIONS]; 
		double[] fileTimes1 = new double[NUM_ITERATIONS]; 
		double[] fileTimes2 = new double[NUM_ITERATIONS]; 
		for (int count = 0; count < NUM_ITERATIONS; count++) { 
			stringTimes[count] = fileTimes1[count] = fileTimes2[count] = 0; 
			BufferedWriter writer; 
			// First part: in-memory 
			long numIter = totalMemory / addString.length(); 
			StringBuffer concatString = new StringBuffer (); 
			long startTime = System.currentTimeMillis(); 
			for (int i = 0; i < numIter; i++) { 
				concatString.append(addString); 
			} 
			long endTime = System.currentTimeMillis(); 
			double stringTime = (endTime - startTime) / 1000.0; 
			stringTimes[count] = stringTime; 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				writer.write(concatString.toString()); 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
			} catch (IOException e) { 
			} 
			double fileTime = (endTime - startTime) / 1000.0; 
			fileTimes1[count] = fileTime; 
			// Second part: disk-only 
			try { 
				writer = new BufferedWriter(new FileWriter("test.txt")); 
				startTime = System.currentTimeMillis(); 
				for (int i = 0; i < numIter; i++) { 
					writer.write(addString); 
				} 
				writer.flush(); 
				writer.close(); 
				endTime = System.currentTimeMillis(); 
				fileTime = (endTime - startTime) / 1000.0; 
				fileTimes2[count] = fileTime; 
			} catch (IOException e) { 
			} 
		} 
		double stringMean = 0; 
		for (int i = 0; i < stringTimes.length; i++) { 
			stringMean += stringTimes[i]; 
		} 
		stringMean /= stringTimes.length; 
		double fileMean1 = 0; 
		for (int i = 0; i < fileTimes1.length; i++) { 
			fileMean1 += fileTimes1[i]; 
		} 
		fileMean1 /= fileTimes1.length; 
		double fileMean2 = 0; 
		for (int i = 0; i < fileTimes2.length; i++) { 
			fileMean2 += fileTimes2[i]; 
		} 
		fileMean2 /= fileTimes2.length; 
		System.err.println("In-memory mean: string time" + stringMean); 
		System.err.println("In-memory mean: file time " + fileMean1); 
		System.err.println("In-memory mean: Total " + (fileMean1+stringMean)); 
		System.err.println("Disk-only mean: file time " + fileMean2); 
	} 
}

Winner is :
StringBuilder append avec 0.0276

Cordialement,
Patrick Kolodziejczyk.

5

0

JackJnr

Membre confirmé

Le 27/03/2015 à 14:22

Du coup si je comprends bien, ces chercheurs sont de futurs chercheurs... d'emploi !

--> [] !

4

0

pcaboche

Rédacteur

Le 28/03/2015 à 2:06

Envoyé par Squisqui

Sans même parler d'implémentation, le test est tellement peu représentatif de la réalité qu'on se dit qu'on est bien Vendredi

Vu la méthodologie utilisée et les conclusions de l'étude, j'ai plutôt cru à un poisson d'Avril.

2

0

Traroth2

Membre émérite

Le 30/03/2015 à 11:15

En gros, leur étude, ça veut dire : "quand la seule opération qu'on veut faire dans le code, c'est écrire sur le disque, ça va plus vite d'écrire directement sur le disque sans faire d'opération en mémoire". C'est assez évident, non ?

2

0

Voyvode

Membre émérite

Le 27/03/2015 à 14:37

@Washmid
C’est vrai uniquement avec les concaténations simples. Le compilateur sait optimiser "a" + "b" + "c" sans problème.

Dans une boucle, en revanche, un StringBuilder est plus que recommandé. C’est exactement ce qu’ils n’ont pas fait dans leurs tests.

1

0

Identifiez-vous

Créer un compte

Est-ce toujours plus rapide d'exécuter des opérations dans la mémoire des machines ?

Non, selon des chercheurs

Identifiant
Mot de passe

Mot de passe oublié ?