Groovy per il tempo di esecuzione del ciclo

Question

O Groovy Guru,

Questo frammento di codice viene eseguito in circa 1 secondo

for (int i in (1..10000000)) { 
     j = i; 
    } 

mentre questo prende quasi 9 secondi

for (int i = 1; i < 10000000; i++) { 
     j = i; 
    } 

Perché è così?

Answer 1

Ok. Ecco la mia opinione sul perché?

Se si converte entrambi gli script in bytecode, si noterà che

1. ForInLoop utilizza Range. Iterator viene utilizzato per avanzare durante ogni ciclo. Il confronto (<) viene effettuato direttamente su int (o Integer) per determinare se la condizione di uscita è stata soddisfatta o meno
2. ForLoop utilizza l'incremento tradizionale, verifica la condizione ed esegue l'azione. Per verificare la condizione i < 10000000 utilizza Groovy's ScriptBytecodeAdapter .compareLessThan. Se si scava in profondità nel codice che di metodo, si trovano entrambi i lati del confronto è preso come oggetto e ci sono tante cose in corso, casting, confrontandoli come oggetto, ecc

ScriptBytecodeAdapter .compareLessThan - >ScriptBytecodeAdapter .compareTo ->DefaultTypeTransformation .compareTo

non ci sono altre classi in package che implementa typehandling metodo compareTo appositamente per i tipi di dati per la matematica, non so perché non vengono utilizzati, (se non sono utilizzati)

Sono sospettoso che questo sia il motivo per cui il secondo ciclo richiede più tempo. Ancora, per favore correggimi se ho torto o mi manca qualcosa ...

Answer 2

Durante i test, assicurarsi di "riscaldare" la JVM prima di prendere la misura, altrimenti è possibile che vengano attivate varie azioni di avvio nella piattaforma (caricamento della classe, compilazione JIT). Esegui i tuoi test più volte di seguito. Inoltre, se hai effettuato il secondo test mentre stava svolgendo un processo di raccolta dei dati, ciò potrebbe avere un impatto. Prova a eseguire ciascuno dei tuoi test 100 volte e stampare i tempi dopo ogni test, e guarda cosa ti dice.

Answer 3

Se è possibile eliminare i potenziali artefatti dal tempo di avvio come suggerisce Jim, azzarderei quindi un'ipotesi che lo stile Java per il ciclo in Groovy non sia così ben implementato come lo stile originale per ciclo di Groovy. È stato aggiunto solo a partire dalla v1.5 dopo le richieste degli utenti, quindi forse la sua implementazione è stata un po 'ripensata.

Hai dato un'occhiata al bytecode generato per i tuoi due esempi per vedere se ci sono delle differenze? C'è stata una discussione su prestazioni Groovy here in cui uno dei commenti (da un 'johnchase') dice:

Mi chiedo se la differenza avete visto legato al modo in Groovy utilizza i numeri (primitive) - dal momento che avvolge tutti i primitivi nelle loro equivalenti classi di wrapper Java (int -> Integer), immagino che rallenterebbero un po 'le cose. Sarei interessato a vedere le prestazioni del codice Java che esegue il ciclo di 10.000.000 utilizzando le classi wrapper invece di ints.

Quindi forse il loop originale di Groovy non ne risente? Solo speculazioni da parte mia, però.