Ri: Perché scrivere e chiamare la funzione può accelerare significativamente il tempo di esecuzione? E quali sono le regole empiriche per scrivere JSL per la complessità tempo/spazio più efficiente?Non me lo aspetterei neanche io. C'è un piccolo sovraccarico per la chiamata di funzione, relativo alla copia dei parametri e all'impostazione delle variabili locali.
Ma ... se è coinvolto un enorme array, che utilizza più della metà della memoria disponibile, l'utilizzo di una variabile locale nella funzione assicurerebbe che la memoria venga liberata prima che sia nuovamente necessaria.Considera questo JSL:
x = J(20000,20000,0);
...
x = J(20000,20000,0);
la prima allocazione richiede 3 GB di memoria. La seconda allocazione richiede altri 3 GB prima di poter rilasciare la prima (quando x viene sovrascritta). Se x è locale nella funzione, piuttosto che globale, la memoria per x viene liberata quando la x locale viene dimenticata alla fine della funzione. In caso contrario, una macchina da 4 GB eseguirà il paging del vecchio x su disco azzerando la memoria per la nuova memoria che sostituirà x. Quindi dimenticherà ciò che ha paginato su disco.
Se suona come quello che stai facendo, prova questo per dimostrarlo:
x = J(20000,20000,0);
...
x=0; // forget the old allocation first
x = J(20000,20000,0);
Ri: Perché scrivere e chiamare la funzione può accelerare significativamente il tempo di esecuzione? E quali sono le regole empiriche per scrivere JSL per la complessità tempo/spazio più efficiente?...e hptime() è la funzione dei microsecondi. (prestazioni elevate? non sono sicuro di cosa stia per hp.)
Perché la funzione di scrittura e chiamata può accelerare significativamente il tempo di esecuzione? E quali sono le regole empiriche per scrivere JSL per la complessità tempo/spazio più efficiente?Ciao a tutti,
Uno dei miei compiti è fare l'analisi dell'affidabilità, in cui faccio uso di Fit Life di X.
In tal modo, ho due script JSL che emettono esattamente gli stessi risultati ma avere diversi approcci di codifica .
Il primo approccio ha semplicemente diversi pezzi di codice in cascata insieme. Lo pseudo codice è simile al seguente:
// 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
Il secondo ha un'unica funzione che chiamiamo ripetuta con colonne X, Y e censore diverse. Lo pseudo codice è simile al seguente:
// 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
Quello che ho sperimentato è che il secondo codice è molto più veloce del primo, nell'ordine di quasi 10 volte più veloce. (Il mio JSL effettivo con il set di dati reale ha il tempo di esecuzione (misurato tramite il tempo dell'orologio da parete) di ~ 17 secondi dal codice n. 2 rispetto a ~ 170 secondi dal codice n. 1)
Ho tre domande come segue:
1. Perché chiamare la funzione è molto più veloce che scrivere esplicitamente tutti i codici?
2. Quali sono altre pratiche/suggerimenti che dovrei generalmente fare per garantire che il mio codice abbia la complessità di tempo e/o spazio più efficiente?
3. Non sono sicuro che JSL abbia funzioni di temporizzazione integrate come l'ora della CPU e l'ora dell'orologio da parete? Ho cronometrato le esecuzioni del codice utilizzando la funzione today (), ma comporta molta codifica manuale. Inoltre, i tempi trascorsi calcolati in questo modo sono sempre leggermente diversi a seconda che ci siano altre attività in esecuzione.
Grazie mille per il vostro aiuto.
Versione JMP: 17.0
Automazione e scriptingQualità e ingegneria di processofinestreRe: Perché scrivere e chiamare una funzione può accelerare significativamente il tempo di esecuzione? E quali sono le regole pratiche per scrivere JSL per la complessità di tempo/spazio più efficiente?Un'altra possibilità: se il grafico precedente è aperto e la tabella dati viene modificata per creare il nuovo grafico, il vecchio grafico potrebbe rispondere a ogni modifica alla tabella dati. Forse la versione della funzione chiude prima il vecchio grafico?
