tempi che si riducono?

[GK4]

Salve a tutti
Ho un problema riguardante i tempi della mia applicazione. Ho per semplicità un file java che contiene una sola funzione, se lancio più volte il file java ogni volta impiego 1,5sec a terminare.
Fin qui tutto ok ma ora ho il bisogno di lanciare in sequenza più volte questa funzione e annotare i tempi. Mi stampa una cosa del genere:
1,5sec
800msec
300msec
e si stabilizza per le successive chiamate sui 300msec. Il primo pensiero è andato a: cacchio ho sbagliato qualcosa, ma in effetti i risultati sono corretti. Mi occorre che ogni volta impieghi il medesimo tempo. Lanciare manualmente l'applicazione per n volte è da idioti e se chiamo il gc non cambia nulla. Ho provato come test a lanciare una funzione contente il caricamento di un array e vedere se funziona allo stesso modo e in effetti è così anche se i tempi si riducono in modo meno evidente. Non mi è semplice postarvi la funzione ma visto che anche il caricamento dell'array si comporta ugualmente la cosa mi pare superflua.

Sapete come posso risolvere?
Devo consegnare al più presto la documentazione al mio relatore, un grazie di cuore

[Scara95]

E' un effetto del JIT compiler di JVM, suppongo, in ogni caso perchè è così problematica la riduzione nel tempo di esecuzione?

[GK4]

perchè ho una funzione che viene chiamata 5 volte. La prima volta il processo interno è iterato 1 volta, la seconda 2 e così via. Non posso inserire nella tesi che il processo iterato 1 volta impiega di più del processo iterato 2
... ma in questo modo esce proprio questo, mi toccherà lanciarlo n volte

[valia]

fai una media:
Ti servono 2 variabili,
startTime, long, in cui metti l'istante iniziale della tua iterazione
endTime, long in cui metti l'istante finale della tua iterazione
sumtime += endTime - startTime ad ogni iterazione


Alla fine fai una media e usa quello come valore, dovresti abbattere i picchi

[MItaly]

Non c'è nulla di strano... la prima volta che viene richiamata una funzione deve essere JIT-compilata, per cui è normale che ci metta ben di più; poi ci sono effetti di cache e di branch prediction (che non sono specifici di Java ma di come funzionano i processori attuali): la cache del processore si "scalda" (tenendo pronti all'uso i dati a cui fa riferimento la funzione) e il branch predictor "impara" quali sono gli esiti più probabili dei branch, per cui è solo dopo qualche iterazione che si raggiunge un tempo di esecuzione "più o meno fisso". Non è un caso che, nel fare i benchmark di una funzione, in genere se ne ripete l'esecuzione molte volte, scartando i tempi delle prime esecuzioni.

Inoltre, per verificare se diversi algoritmi hanno differenze sostanziali nel tempo di esecuzione ricordati che non devi considerare solo la media, ma anche la deviazione standard: se i tempi medi misurati per due funzioni differiscono per neanche una deviazione standard (o meglio, la somma in quadratura delle deviazioni standard ottenute dai due set di misure) il risultato non è per nulla significativo.

[Scara95]

Puoi più intelligentemente aggiungere un paragrafo sulle ottimizzazioni e mostrare come la compilazione JIT migliori le performance su chiamate successive.
Oppure scrivere questa funzione in un'altro linguaggio compilato staticamente tipo C, C++, Pascal, Object Pascal, (D, Go), ...
Possibilmente evitando i linguaggi garbage collected (tra parentesi) in quanto è più probabile che i tempi di esecuzione risultino maggiormente diversi su chiamate successive della funzione...