Adobe^® Flex^™ Tutorial

Le dernier article parlait de la manière la plus rapide de copier une ArrayAS3. Ce genre d'optimisation simple peut vous permettre d'accélérer vos temps de calcul lorsque vous faîtes de lourdes opérations en ActionScript. Voici quelques conseils qui vous permettront d'optimiser facilement votre code ActionScript. La plupart de ces conseils sont repris de plusieurs blog dont le wiki d'OsFlash

Conseils et généralités

N'utilisez pas de type Object si  vous connaissez les propriétés que vous allez utiliser. Par exemple, si vous voulez définir un point dans l'espace, vous pourriez créer un Object avec 3 propriétés (x, y, z). Pourtant, il faudrait mieux créer une classe Vertex avec ces 3 propriétés xyz. Les performances sont bien meilleures!

Quand vous parcourez un tableau (Array), n'effectuez pas directement des opérations sur la case que vous êtes en train de lire. Par exemple, si vous savez que vous avez un tableau d'objets BitmapData, ne faîtes pas images[index].getPixel(x, y). Avant d'appeler la méthode, enregistrez l'instance dans une variable typée, ici var image:BitmapData = images[index]. En effet, cela évite à flash de faire une recherche de Native Type et votre traitement sera bien plus rapide.

Si vous connaissez le type d'objet qui sera contenu dans votre Array, faîtes plutôt un Vector (Array typé apparu avec Flash Player 10), les performances seront 20x meilleures.

Pour le parcours de vos boucles, utilisez des entiers (int/uint) et pas de Number qui ralentissent les boucles for. Pour vos boucles for, pensez aussi à travailler avec des longueurs fixes. au lieu d'avoir un for(var i:uint = 0;i  < arr.length;i++)…, enregistrez arr.length en dehors de la boucle for dans une variable et utilisez cette variable dans votre condition d'arrêt.

Addition d'entier (Integer), Increment/Decrement

Que ce soit dans des boucles ou pour modifier des valeurs, vous aurez toujours besoin d'incrémenter des entiers ou de les décrémenter. Plusieurs options s'offrent à vous:

• a = a +1;
• a++;
• a += 1;

Et bien la méthode la plus rapide d'incrémenter une valeur est d'utiliser l'opérateur ++. Quant à la décrémentation, l'opérateur — n'est pas plus rapide que les autres.

Division et opérateurs Bitwise Shift

Vous avez sûrement déjà entendu qu'il est plus rapide de multiplier par  0.5 que de diviser par 2. Et bien oui, les tests le prouvent. Même si la différence n'est pas flagrante (25%), la différence est bien là.

Mais il y a une méthode qui est encore plus rapide, les opérations Bitwise shift (opérateurs sur le bit). Par exemple, vous pouvez diviser par 2 avec un right shift:

10 >> 1 donne 5

Et multiplier par 2 par un left shift:

10 << 1 donne 20

Si on fait le test sur un million de valeurs, voici le résultat pour une division par 2:

• Opérateur sur le bit: 16.75ms
• Multiplication par 0.5: 33.8ms
• Division par 2: 54.2ms

Attention, ces opérations sont faîtes sur des type int (Integer). N'utilisez pas les opérateurs bit sur des types Number car le bit shift va faire un arrondi. Utilisez * 0.5 à la place.

Math.floor / Math.ceil et arrondis

La classe Math de Flash possède les opérations floor() et ceil() permettant de faire des arrondis (vers le bad ou vers le haut respectivement). Mais vous pouvez aussi passer un nombre à virgule au constructeur des types int et uint qui vont supprimer tout ce qui est derrière la virgule. Vous pouvez aussi effectuer cette opération avec des décalages de bits. Voyons alors lequel est le plus rapide avec ce test:

for(var i:uint=0;i<10000000;i++)
{
	var n:Number = 1.5;
	// code testé
}

• (floor) var test:Number = Math.floor(n): 1733ms
• (floor) var test:uint = uint(n): 176ms
• (floor) var test:int = int(n): 157ms
• (floor) var test:Number = n >> 0: 178ms
• (ceil) var test:uint = n == uint(n) ? n : uint(n)+1: 650ms
• (ceil) var test:int = n == int(n) ? n : int(n)+1: 384ms

Math.abs et valeurs absolues

Pour appliquer une valeur absolue, vous pouvez soit multiplier un nombre négatif par -1, soit utiliser la méthode Math.abs:

• n = Math.abs(n):  1539.92ms
• n = n < 0 ? n * -1 : n: 89.47ms
• n = n < 0 ? -n : n: 63.28ms
• if (n < 0)  n = -n: 43.52ms

Et il faut garder à l'esprit que ces test ont été effectués sur des nombres toujours négatifs, le test if (n < 0) pourrait donc être encore plus rapide avec des nombres soit positifs soit négatifs.

Autres optimisations AS3

• Pour la lecture d'un Array, la méthode for…in est plus rapide que des boucles while ou for.
• Utilisez if…else au lieu d'un try/catch quand il n'y a rien à catcher
• N'utilisez pas de variables static ou global quand des instances de variable peuvent suffir
• Utilisez les déclarations en ligne var i:int, j:int, k:int = 0; si possible
• Pour des fonctions dont le calcul est très long (trigo par exemple), conservez le résultat en mémoire dans un tableau et avant de faire les prochains calculs, vérifiez s'il n'a pas déjà été fait. Si oui, récupérer la valeur du tableau sera plus rapide que de refaire le calcul
• N'utilisez pas de PNG avec de la transparence si possible. Les calculs d'alpha sont intensifs pour le processeur (idem pour les masques)
• Utilisez onEnterFrame avec précaution  et si vous ne l'utilisez plus, n'oubliezpas de faire onEnterFrame = null et delete onEnterFrame
• Supprimez les listeners et les références vers les objets quand elles ne sont plus utilisées (utile aussi pour le garbage collector AS3)
• Utilisez des Object Pools pour réutiliser frequemment les instances de classe crées/détruites (bientôt un article sur les Object Pools sur flex-tutorial.fr)

• Flex ActionScript – Copier un Array AS3 (tableau) le plus rapidement possible
• Flex ActionScript – Test des performances de l'ActionScript 3
• Flex SDK Coding Conventions et Best Practices
• Flex ActionScript – Array et Object en ActionScript 3
• Flex Chart – Modifier la donnée en temps réel, basculement de Series