Re: ¿Por qué escribir y llamar a la función puede acelerar significativamente el tiempo de ejecución? ¿Y cuál es la regla general para escribir JSL para la complejidad de tiempo/espacio más eficiente?Yo tampoco esperaría eso. Hay una pequeña sobrecarga para la llamada a la función, relacionada con la copia de los parámetros y la configuración de las variables locales.
Pero... si hay una matriz enorme involucrada, usando más de la mitad de la memoria disponible, usar una variable local en la función aseguraría que la memoria se libere antes de que se vuelva a necesitar.Considere este JSL:
x = J(20000,20000,0);
...
x = J(20000,20000,0);
la primera asignación necesita 3 GB de memoria. La segunda asignación necesita 3 GB adicionales antes de poder liberar la primera (cuando x se sobrescribe). Si x es local en la función, en lugar de global, la memoria para x se libera cuando la x local se olvida al final. de la función De lo contrario, una máquina de 4 GB buscará la antigua x en el disco mientras pone a cero la memoria para la nueva memoria que reemplazará a x. Entonces olvidará lo que paginó en el disco.
Si eso suena como lo que estás haciendo, prueba esto para probarlo:
x = J(20000,20000,0);
...
x=0; // forget the old allocation first
x = J(20000,20000,0);
Re: ¿Por qué escribir y llamar a la función puede acelerar significativamente el tiempo de ejecución? ¿Y cuál es la regla general para escribir JSL para la complejidad de tiempo/espacio más eficiente?...y hptime() es la función de microsegundos. (¿alto rendimiento? No estoy seguro de qué significa hp).
¿Por qué escribir y llamar a la función puede acelerar significativamente el tiempo de ejecución? ¿Y cuál es la regla general para escribir JSL para la complejidad de tiempo/espacio más eficiente?Hola a todos,
Una de mis tareas es hacer el análisis de confiabilidad, en el cual lo hago usando Fit Life by X.
Al hacerlo, tengo dos scripts JSL que generan exactamente los mismos resultados pero tienen diferentes enfoques de codificación .
El primer enfoque simplemente tiene varias piezas de código en cascada juntas. El pseudocódigo se parece a lo siguiente:
// Plot Fit Life by X #1
Fit Life by X(...);
// Plot Fit Life by X #2
Fit Life by X(...);
// Plot Fit Life by X #3
Fit Life by X(...);
// And so on
El segundo tiene una sola función que llamamos repetido con diferentes columnas X, Y y censura. El pseudocódigo se parece a lo siguiente:
// Function that contains Fit Life by X
reli_analysis = function(
{input parameters},
{local variables},
Fit Life by X(...);
);
// Call the above function multiple times
reli_analysis(input parameters set #1);
reli_analysis(input parameters set #2);
reli_analysis(input parameters set #3);
// And so on
Lo que experimenté es que el segundo código es mucho más rápido que el primero, del orden de casi 10 veces más rápido. (Mi JSL real con el conjunto de datos real tiene un tiempo de ejecución (medido a través del tiempo del reloj de pared) de ~17 segundos del Código n.º 2 frente a ~170 segundos del Código n.º 1)
Tengo tres preguntas de la siguiente manera:
1. ¿Por qué llamar a la función es mucho más rápido que escribir todos los códigos de forma explícita?
2. ¿Cuáles son otras prácticas/consejos que generalmente debo hacer para asegurar que mi código tenga la complejidad de tiempo y/o espacio más eficiente?
3. No estoy seguro de si JSL tiene funciones de temporización integradas, como la hora de la CPU y la hora del reloj de pared. Cronometré las ejecuciones del código usando la función today(), pero implica mucha codificación manual. Además, los tiempos transcurridos calculados de esta manera siempre son ligeramente diferentes dependiendo de si hay otras tareas en ejecución.
Muchas gracias por tu ayuda.
Versión JMP: 17.0
Automatización y secuencias de comandosIngeniería de Calidad y ProcesosventanasRe: ¿Por qué escribir y llamar a una función puede acelerar significativamente el tiempo de ejecución? ¿Y cuáles son las reglas generales para escribir JSL para lograr la complejidad temporal/espacial más eficiente?Otra posibilidad: si el gráfico anterior está abierto y se modifica la tabla de datos para crear el nuevo gráfico, es posible que el gráfico anterior responda a cada cambio en la tabla de datos. ¿Quizás la versión de la función cierre antes el gráfico anterior?
