Discussion :

[SnowStyle]

Salut,

pour mémorisé des points classé par coordonnées XYZ, je testais vite fait l'utilisation des vector multidimensionnel et array multidimensionnel

Au final je suis arrivé à des délais d’exécution quasiment similaire, le plus souvent à l'avantage du vector mais de peu

C'est peut être normal vu que les deux contiennent uniquement des valeurs boolean?

mais au cas je me demandais si j'avais fait une ou des erreurs quelque part vu que le Vector est sensé être plus rapide que ça par rapport au Array non ?

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
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
private var multiVector:Vector.<Vector.<Vector.<Boolean>>> = new Vector.<Vector.<Vector.<Boolean>>>(128,true);
 
private var multiArray:Array = new Array();
 
private var accessNumb:Number = 2000000;
 
private function populateMultiArray() {
 
	var nX:Number = 64;
	var nY:Number = 0;
	var nZ:Number = 0;
	var maxSize:Number = 128; 
 
	while (nY < maxSize) {
		multiArray[nY] = new Array();
		nZ = 0;
		while (nZ < maxSize) {
			multiArray[nY][nZ] = new Array();
			nZ++;
		}
		nY++;
	}
 
	//insertion valeurs de 65x65x65 à 128x128x128
	nZ = 64;
	nY = 64;
	while (nY < maxSize) {
		nZ = 64;
		while (nZ < maxSize) {
			nX = 64;
			while (nX < maxSize) {
				multiArray[nY][nZ][nX] = true;
				nX++;
			}
 
			nZ++;
		}
 
		nY++;
	}
 
}
 
private function accessMultiArray() {
 
	var i:Number = 0;
 
	while (i < accessNumb) {
 
		if (multiArray[rand(0,127)][rand(0,127)][rand(0,127)]) {
			//true mais osef
		}
 
		i++;
	}
 
}
 
private function populateMultiVec() {
 
	var nX:Number = 0;
	var nY:Number = 0;
	var nZ:Number = 0;
	var maxSize:Number = 128;
 
	while (nY < maxSize) {
 
		multiVector[nY] = new Vector.<Vector.<Boolean>>(maxSize,true);
		nZ = 0;
		while (nZ < maxSize) {
 
			multiVector[nY][nZ] = new Vector.<Boolean>(maxSize,true);
			nZ++;
		}
		nY++;
 
	}
 
	//insertion valeurs de 65x65x65 à 128x128x128
	nX = nY = nZ = 64;
 
	while (nY < maxSize) {
 
		nZ = 64;
		while (nZ < maxSize) {
 
			nX = 64;
			while (nX < maxSize) {
				multiVector[nY][nZ][nX] = true;
				nX++;
			}
 
			nZ++;
		}
 
		nY++;
	}
 
}
 
private function accessMultiVec() {
 
	var i:Number = 0;
 
	while (i < accessNumb) {
 
		if (multiVector[rand(0,127)][rand(0,127)][rand(0,127)]) {
			//true mais osef
		}
		i++;
	}
 
}

Délai populate multivector: 0.031 seconds
Délai populate multiarray: 0.046 seconds

Délai d'accès multivector: 1.688 seconds
Délai d'accès multiarray: 1.703 seconds

A moins que ce soit la façon de calculer le délai d'execution qui n'est pas fiable ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
//Start
init = new Date();
 
//...fonction
 
//End
done = new Date();
 
//Display
trace("text: " + ( ( done.getTime()-init.getTime() ) / 1000 ) + " seconds");

D'ailleurs au passage, il y a moyen de savoir combien de mémoire ça bouffe précisément? Dans l'espoir que le Vector soit plus light

[IP-Fix]

Hello,

pour les vector c'est plus rapide quand t accède au propriété de l objet dans le vector car tu cast pas. Après c est pas ouf non plus sur des petits algo mais visible sur les tres gros. Si tu modifie souvent ton vector array peut etre preferable.

tu peux faire getTimer() pour avoir direct le temps en ms depuis le lancement du programme.

edit : sur les tri vector est mieux en generale

[SnowStyle]

Hmm ok, c'est encore assez obscure pour moi l'OO donc je saisi pas trop le concept accès propriété objet pas caster mais c'est pas grave dans l'immédiat vu que c'est pas l'utilisation que j'en fais pour l'instant, cependant je retiens et vais me renseigner davantage sur le sujet, merci.

Y'a quand même un autre détail qui me chagrine, j'ai utiliser System.totalMemory pour voir un peu la conso ram, étonnament mon Vector multidimensionnel bouffe 4mo de plus que l'array multidimensionnel, pourtant le vector est typé, taille précisé et fixe. Et le compileur arrive cependant à rendre l'array plus light.
En plus des boolean c'est pas ce qu'il y a de plus lourd lol, 4mo ça fait quand même une différence énorme.
A moins que System.totalMemory soit pas fiable mais j'ai vérifié plusieurs fois, en ayant aucune autre anim flash ouverte.
Ou que ma façon de crée le vector soit mal optimisé.

C'est peut être tout simplement que le Vector est pas vraiment prévu pour une utilisation multidimensionnel ? même si on peux le faire.
En tout cas pour l'instant, vu la faible différence de vitesse mais l'énorme différence en charge mémoire, l'array multidimensionnel me parait supérieur à son homologue, surtout que je risque d'en utiliser plusieurs simultanément.

[SnowStyle]

Après d'autres test j'ai fini par laisser tomber le multidimensionnel, ça consomme + de ram et c'est pas indispensable pour des coordonnées.

Je suis revenu à un seul vector et un seul array, conversion des coords par décalage binaire, et là résultat sans appel, le vector est nettement plus rapide que l'array.
Cependant l'array est toujours + light sur la ram vu que j'ai pas besoin d'utiliser toutes les coordonnées, le vector il s'en fout il utilise tout mais le gain de vitesse est non négligeable cette fois.

Pour 5millions d'accès :

vector (sans rand) 0.359 seconds
array (sans rand) 0.593 seconds

ça varie mais ça reste dans ces eaux là

Je me demande juste si le fait de pas utiliser de random et d'accéder tout le temps au même index peux fausser le résultat ? je suppose que non, je lui demande d'aller prendre une valeur dans mon tableau, il devrait y aller même si il a déjà retourner cette valeur une microseconde avant non ?

Et aussi si il y a une conversion plus rapide que le décalage binaire ?

En tout cas, j'ai bien l'impression que le multidimensionnel arrange pas trop le Vector
Si on est forcé d'utiliser du multi et qu'on a des espaces vide entre des index, autant utiliser l'array, moins de conso ram et tout aussi rapide.