LSL Script Efficiency/fr

__TOC__
== Qu'est-ce que l'efficacité? ==
L'efficacité est l'inverse des ressources consommées pour effectuer une tâche donnée. Plus le script est efficace, moins il consomme de ressouces. L'efficacité va souvent de pair avec la rapidité, mais cela n'est pas une généralité.
Les points qui ont un impact négatif sur l'efficacité sont, à peu près par ordre d'importance :
* Le nombre de scripts utilisés pour accomplir une même tâche. Cf. Conception Optimale.
* llSleep - Cette fonction consomme 0.2 à 0.3 milliseconde par tranche de temps pendant que le script dort. Les timers (llSetTimerEvent) sont bien plus efficaces.
* Les timers "courts" (< 5 sec) sont grands consommateurs de ressources.
* Listen - particulièrement sur le canal 0
* Les changements fréquents de texture (les autres utilisateurs sont contraints de les charger)
* L'utilisation des rotations côté serveur au lieu de llTargetOmega
* Les gestionnaires d'évènements inutiles (touch, collision, ...)
* Un grand volume de mails ou d'IM
* Les algorithmes non optimaux (recherche linéaire par exemple, par opposition à dichotomie)
* Les boucles d'attente actives
== Conception optimale ==
Chaque script dormant dans un objet ajoute de 0.001 à 0.003 milliseconde par tranche de temps. Moins il y a de scripts, meilleure est l'efficacité.
* Si vous avez besoin d'un tas de "boutons", évitez de mettre un script dans chaque prim. Utilisez llDetectedLinkNumber dans le prim racine pour détecter quel sous-prim a été touché.
* Si vous avez besoin de changer la couleur, la transparence (alpha) ou la texture d'un sous-prim, évitez encore de mettre un script dans chaque prim. Utilisez plutôt llSetLinkAlpha, llSetLinkColor, llSetLinkTexture ou llSetLinkPrimitiveParams.
* Ne mettez jamais un script qui écoute sur le canal 0 (ou autre) dans chaque prim d'un objet complexe . C'est sans doute la pire des choses à faire. Malheureusement, elle est trop fréquente.
* Pensez à utiliser XyzzyText à la place de XyText.
En résumé, si vous êtes sur le point de mettre un script dans chaque prim d'un objet, arrêtez et cherchez comment faire autrement avec moins de scripts. Il existe pratiquement toujours une autre solution. À vous de décider si elle est viable dans le contexte de votre application.
== Micro-optimisation ==
Il existe beaucoup d'astuces pour accélérer les scripts, comme utiliser ++a au lieu de a++. Cependant, ce genre d'optimisations peut se révéler sans effet dans le futur (en cas de changement d'implémentation de LSL).
== Combien de temps prend ce code ? ==
Le code suivant mesure le temps passé dans chaque appel de fonction, en millisecondes.
Atention, ne modifiez pas ce code sur le wiki sans une discussion préalable. Un changement même mineur peut entraîner des discordances dans les mesures. Ce code est un étalon de mesure et doit être recopié exactement, commentaires inclus, tel que figurant ici.
Merci à pour le code original, à pour l'amélioration de sa précision, et à tous les autres contributeurs listés dans l'historique de cette page.
//IMPORTANT: Only perform tests in an empty region.
// To reduce contamination and be sure to wearing no attachments.
// Preferably do tests in a private sim with one on it.
// Don't move while performing the test.
// There is a margin of error so run the tests multiple times to determine it.
integer time() { // count milliseconds since the day began
 string stamp = llGetTimestamp(); // "YYYY-MM-DDThh:mm:ss.ff..fZ"
 return (integer) llGetSubString(stamp, 11, 12) * 3600000 + // hh
 (integer) llGetSubString(stamp, 14, 15) * 60000 + // mm
 llRound((float)llGetSubString(stamp, 17, -2) * 1000000.0)/1000; // ss.ff..f
}
default {
 state_entry() {
 llOwnerSay((string) llGetFreeMemory());
 //test variables
 float counter;
 //framework variables
 float i = 0;
 float j = 0;
 float max = 10000; // 2ms of work takes 20 seconds to repeat 10,000 times, plus overhead
 float t0 = time();
 do {
 //test
 counter += 1;
 
 }while (++i < max);
 float t1 = time();
 do ; while (++j < max);
 float t2 = time();//remove the time required by the framework
 float elapsed = ((t1 - t0) - (t2 - t1))/max;
 llOwnerSay("The function in the loop took a total of " + (string)elapsed + " milliseconds.");
 }
}
== Mesures d'efficacité ==
Les mesures suivantes ont été collectées avec la fonction ci-dessus dans un simulateur récent et vide, avec ce seul script s'exécutant dans un ATH. Elles sont la moyenne de 20 exécutions.
 ++a : 0,173780 ms dév. std. : 0,003393 ms
 a += 1 : 0,181720 ms dév. std. : 0,013267 ms
 a++ : 0,243500 ms dév. std. : 0,013816 ms
a++ prend en gros 40% de temps de plus que ++a.
Bien que les données qui suivent soient correctes, elles n'ont pas été obtenues avec le code de référence ci-dessus, mais avec une version légèrement moins optimisée écrite par . Si quelqu'un pouvait répéter les tests avec la version de référence, merci.
 ++a : 0,364700 ms
 a += 1 : 0,346900 ms
 a++ : 0,413700 ms
Même test pour la boucle for :
 ++a : 0,358370 ms
 a += 1 : 0,351200 ms
 a++ : 0,424600 ms
llOwnerSay par rapport à llSay, llShout еt llWhisper (canal 0) :
 llOwnerSay() : 4,359000 ms
 llWhisper() : 5,201000 ms
 llSay() : 5,226000 ms
 llShout() : 14,877000 ms
Autres canaux (llSay() utilisé dans tous les cas) :
 -100000000 : 1,226400 ms
 -100000 : 1,254300 ms
 -100 : 1,296100 ms
 -1 : 1,292400 ms
 0 : 5,226000 ms
 1 : 1,242300 ms
 100 : 1,249100 ms
 100000 : 1,219700 ms
 100000000 : 1,228700 ms
Longueur du texte (llSay() et canal 1) :
 1 Caractère : 1.242300 ms
 10 Caractères : 1.309700 ms
 100 Caractères : 1.965600 ms