LSL Script Efficiency/es

__TOC__
== Qué es la eficiencia ==
La eficiencia es la cantidad de recursos que un script específico usa para obtener un objetivo. La eficiencia va de la mano con la velocidad de ejecución, pero no siempre.
Este atento de los siguientes puntos, en orden de importancia aproximado:
* Usar muchos scripts para lograr algo. Consulte Diseño Eficiente.
* llSleep - Esta función usa de 0.2 a 0.3 ms por marco mientras que el script duerme, los temporizadores son mejores.
* Temporizador de frequecia corta (<5 sec)
* Escuchar - especialmente al canal 0 
* Cambiar texturas con frecuencia (Otros tienen que descargarlos)
* Uso poco apropiado de rotaciones físicas/de servidor en vez de omega
* Manejadores de eventos que no son necesarios (tocar, colisión, ...)
* Cantidad grande de correo electrónico o mensajes instantáneos
* Algoritmos ineficaces (como la búsqueda lineal)
* Bucles de llamadas selectivas ocupadas
== Diseño eficiente ==
Cada script inactivo en un objecto añade de 0.001 a 0.003 milisegundos por marco de uso de tiempo de script. Menos scripts son mejor.
* Si necesita tener varios "botones" no ponga un script en cada prim. En su lugar use llDetectedLinkNumber para detectar cual botón se tocó en su script principal. 
* Si necesita cambiar el color, alpha o textura de un prim hijo no ponga un script en cada prim. En su lugar use llSetLinkAlpha, llSetLinkColor, llSetLinkTexture, o llSetLinkPrimitiveParams.
* Nunca ponga un script en cada prim (de un conjunto de enlaces grande) que escuche en el canal 0 (o cualquier otro canal). Esto es lo peor que puede hacer para la eficiencia. Desafortunadamente es muy común.
* Considera usar XyzzyText en vez de XyText.
Lo más importante es que si te encuentras tentado de poner un script en cada prim, que pares y analizes como puedes hacerlo de otra manera con menos scripts. Casi siempre hay una alternativa. Está en tus manos decidir si la alternativa es viable para tu aplicación.
== Micro-optimización ==
Hay muchas maneras de acelerar los scripts, como usar ++a en vez de a++. Sin embargo, muchas de estas micro-optimizaciones no serán ciertas en el futuro.
== Cuán Rápido Corre el Código ==
El código siguiente obtendrá el tiempo de cada función llamada en millis. 
Primero proponga cambios en la pestaña discussion. No cambie el código aqui sin discutirlo, ya que cualquier cambio pequeño puede reducir la exactitud de las medidas. Sírvase notar que este código y sus comentarios deben igualar exactamente el código y comentarios en la página Efficiency Tester.
Gracias a por el código original, gracias a por optimar el código para producir medidas correctas, y gracias a los otros contribudores mencionados en la historia de este artículo.
//IMPORTANT: Solo haga pruebas en una región vacía. 
// Para reducir la contaminación asegure no tener accesorios puestos. 
// Haga las pruebas preferiblemente en un sim privado con uno en él.
// No se mueva mientras hace la prueba.
// Hay un margen de error así que corra varias pruebas para determinarlo. 
integer time() { // cuenta milisegundos desde que comenzó el día
 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());
 //variables de prueba
 float counter;
 //variables de marco de trabajo
 float i = 0;
 float j = 0;
 float max = 10000; // 2ms de trabajo toma 20 segundos para repetir 10,000 veces, más coste en tiempo 
 float t0 = time();
 do {
 //test
 counter += 1;
 
 }while (++i < max);
 float t1 = time();
 do ; while (++j < max);
 float t2 = time();//remueve el tiempo requerido por el marco de trabajo
 float elapsed = ((t1 - t0) - (t2 - t1))/max;
 llOwnerSay("The function in the loop took a total of " + (string)elapsed + " milliseconds.");
 }
}
== Eficiencia ==
Los siguientes datos fue compilada usando la función arriba en un sim vacío recientemente lanzado (aunque no privado) con solo un script corriendo un accesorio HUD. 20 pruebas de cada uno se corrieron y promediaron.
 ++a: 0.173780 ms Desviación típica: 0.003393 ms
 a += 1: 0.181720 ms Desviación típica: 0.013267 ms
 a++: 0.243500 ms Desviación típica: 0.013816 ms
Así que a++ toma 40% más tiempo para ejecutar que ++a (estimación aproximada).
A pesar que los datos siguientes son correctos, no se usó la funcion mencionada anteriormente. Se usó una versión menos optimada escrita por . Sírvase alguien repetir las pruebas de la función arriba.
 ++a: 0.364700 millis
 a += 1: 0.346900 millis
 a++: 0.413700 millis
Probando la misma función en bucles for (for loops):
 ++a: 0.358370 millis
 a += 1: 0.351200 millis
 a++: 0.424600 millis
llOwnerSay v. llSay v. llShout v. llWhisper (Canal 0 donde corresponda):
 llOwnerSay(): 4.359000 millis
 llWhisper(): 5.201000 millis
 llSay(): 5.226000 millis
 llShout(): 14.877000 millis
Diferentes Canales (llSay() Usado para todo):
 -100000000: 1.226400 millis
 -100000: 1.254300 millis
 -100: 1.296100 millis
 -1: 1.292400 millis
 0: 5.226000 millis
 1: 1.242300 millis
 100: 1.249100 millis
 100000: 1.219700 millis
 100000000: 1.228700 millis
Cantidad de texto (llSay() y Canal 1 usado para todo):
 1 Character: 1.242300 millis
 10 Characters: 1.309700 millis
 100 Characters: 1.965600 millis