Newsgroup: it.comp.java
Titolo: Exception stackTrace

Ciao a tutti, qualcuno sa dirmi perchè a volte nello stack trace di una
eccezione anzichè della riga del sorgente c'è un banale:
compiled code?
Mi capita che lo stesso programma genera eccezioni che a volte riportano
la linea del codice srogente altre volte si "rifugiano" dietro l'inutile
"compiled code"
Ciao e grazie
Marco
-- 
         \\|//
        ( @ @ )
+----oOO--(_)--OOo----------[Dott. Marco Azzalini]-------------------+
|                                                                    |
|              Consulente Sviluppo Software & Networking             |
|               Sun Certified Programmer (Java 2 Platf.)             |
|                                                                    |
|  cell:03470846528  -  e-mail: 
marco.a...@libero.it
             |
|  Web: 
http://utenti.tripod.it/Marco_Azzalini
 - Spedia Code: 459755 |
+--------------------------------------------------------------------+
|Legge di Hofstadter:                                                |
|         ci vuole sempre piu' tempo di quanto si pensi,             |
|         anche tenendo conto della Legge di Hofstadter.             |
+--------------------------------------------------------------------+


Perche' il codice e' compilato ;-) dal just-in-time compiler a runtime!
Lancia la VM con il parametro -nojit, in modo da disabilitare il just
in time compiler nelle fasi in cui fai test .
HTH,
    Bruno.
Sent via Deja.com 
http://www.deja.com/
Before you buy.

Ciao, quindi dici che il jit compila solo alcune parti del codice?
Altrimenti questo non spiega perchè lo stesso programma a volte mi da il
n. di riga altre volte no.
Ma questo non è un comportamento tipico da HotSpot? A parte che ormai
con il JDK1.2+ jit equivale ad HS...
Ad ogni modo farò la prova che mi consigli... grazie mille.
Marco
Bruno Bossola ha scritto:

-- 


 con il JDK1.2+ jit equivale ad HS...
Il comportamento dipende dalla versione di JVM che stai utilizzando, perche'
il compilatore JIT e la tecnologia HotSpot sono simili ma non perfettamente
identici.
Il compilatore JIT alla prima esecuzione di ogni metodo lo compila. Questo
avviene appena il codice e' pronto per essere eseguito (cioe' quando
registri, stack, heap sono pronti), da cui deriva il nome Just-In-Time.
Nelle successive invocazioni verra' utilizzato sempre il codice compilato in
sostituzione del bytecode. Per quanto ne so, anche la prima esecuzione
utilizza il codice nativo/compilato, quindi non si dovrebbe mai vedere il
numero di riga dell'errore, se non disabilitando il JIT compiler.
La tecnologia HotSpot migliora questo approccio con alcune tecniche, tra cui
l'ottimizzazione adattiva (adaptive optimization). Secondo questa tecnica
durante l'esecuzione del codice si analizzano i metodi invocati con maggiore
frequenza attraverso principi euristici. Il motivo di questo approccio
risiede nella convinzione della correttezza della regola detta "dell'
80-20", cioe' l'80% del tempo si e' impegnati ad eseguire il 20% del codice.
Una volta individuato questo 20% - detto appunto HotSpot - la macchina
virtuale esegue un Thread preposto alla compilazione, pesantemente
ottimizzata, del codice.
La differenza con il JIT e' proprio questa: con HotSpot si compila con
un'ottimizzazione pesante il 20% del codice, mentre il JIT compila con
un'ottimizzazione blanda (o nulla) l'intero codice (che in buona misura
verra' eseguito una sola volta).
Inoltre l'HotSpot e' variabile nel tempo, proprio come un mirino. Se un
metodo esce dall'HotSpot, il suo codice compilato viene scartato, ritornando
al bytecode originario.
Nel tuo caso quindi, se stai usando HotSpot, il metodo che genera
un'eccezione potrebbe essere in un dato momento nell'HotSpot - risultando
come 'Compiled Code' - oppure fuori - indicando il numero di riga
dell'errore.
Ciao
Marco

 al bytecode originario.
Questa non la sapevo/ricordavo e potrebbe spiegare  in effetti il
comportamento da me riscontrato. Non ho ben capito perchè dici: se stai
usando HS. Da quel che mi risluta dalla doc del jdk 1.3, non ci sono
possibilità... o usi le ottimizzazioni e allora usi HS o non le usi ed
allora si va di interprete puro; non mi sembra che si possa usare il
vecchio JIT (anche se l'opzione si chiama ancora 'nojit'.
Risulta anche a te così oppure ho letto in modo troppo affrettato le
novità del jdk1.3?
Ciao
Marco



E' corretto. Solamente non ero a conoscenza di quale versione di JVM stessi
usando all'epoca del messaggio originale, quindi rischiavo di darti una serie di
informazioni valide, ma inutili (ed eventualmente fuorvianti se le avessi
interpretate per la versione 1.1.x!!).
Per quanto riguarda il "mirino", c'e' da dire che la profilatura (cioe' l'analisi
di quali metodi vengono invocati con la relativa cronologia) viene eseguita
durante tutta la vita di una JVM con HotSpot, quindi lo spot viene continuamente
ricalcolato. Cosa significhi di preciso "continuamente" non saprei, magari si
segue una politica di schedulazione.
Se lo spot non venisse ricalcolato a run-time i metodi eseguiti all'inizio
risulterebbero i piu' utilizzati.
Nel caso di un server, ad esempio, le varie fasi di inizializzazione verrebbero
compilate, mentre probabilmente i metodi piu' usati a regime sarebbero quelli che
forniscono il servizio vero e proprio.
Ciao
Marco