Newsgroup: it.comp.java
Titolo: compilatore nativo JET

ho scaricato suddetto compilatore, l'ho installato (circa 40 minuti!!!)
e ho compilato un programma che avevo già fatto.
Il programma è un "robot" (solo grafica ;-) che deve evitare degli ostacoli
e raggiungere un goal.
Ora il problema di questo programma è che all'aumentare delle dimensioni
dello spazio
decresce in modo quadratico la performance! (tipo 30 secondi per trovare il
percorso!!)
Allora ho detto, beh vedrai che miglioramento con questo compilatore...
Macchè... i tempi sono gli stessi, se non addirittura superiori  =:-(
Qualcuno lo ha provato?
Compila davvero in codice nativo senza la jvm?
E' più veloce od ho sbagliato qualcosa?

 wrote:

Non so dirti molto sul compilatore Jet (l'ho provato un sacco di tempo
fa ma giusto per provare e non mi aveva dato grandi performance) ad ogni
modo su osnews c'e' stato di recente un articolo che comparava la
velocita' di molti linguaggi e in effetti nei calcoli Java non era per
niente piu' lento del C/C++ anzi in alcuni casi era piu' veloce. Quello
che voglio dire e' che se il tuo problema computazionale e' matematico
(presumo che siano i calcoli per trovare il percorso il grosso)
probabilmente non otterresti molte migliorie con un compilatore nativo.
Non so dirti nulla invece per quel che concerne la grafica, non so se
Jet traduca le chiamate swing in qualcosa di piu' veloce (nativo).
-- 
Ciao
Fabio

 niente piu' lento del C/C++ anzi in alcuni casi era piu' veloce. 
Se non ricordo male molti avevano criticato quell'articolo
Il link alla discussione e' questo:
http://developers.slashdot.org/article.pl?sid=04/01/09/1340223&mode=thread&tid=126&tid=156

> probabilmente non otterresti molte migliorie con un compilatore nativo.
Ho fatto un test al volo con .Net e Java :
un ciclo for per 98.000 elementi con la seguente operazione :
va3+=(((5*2*5*2*5)/2)%2)+4+2;
.net ha impiegato 2ms .
java invece 20ms.
max

 
Come sempre quando si confrontano dei linguaggi (o qualunque altra
cosa). Ad ogni modo sono ache io abbastanza convinto (premesso che non
sono certo un guro) che Java sui meri calcoli non sia molto piu' lento
del codice nativo. In fondo quando il JIT compiler e amenicoli vari
hanno fatto il loro lavoro quel che resta e' nativo (se ho ben capito).
-- 
Ciao
Fabio

 wrote:

Si ma considerando anche il tempo di caricamento dell'interperte java
(timpicamente mastodontico). Ora non ho mai fatto test riportavo solo
quanto avevo letto, su osnew cmq ci sono i sorgenti usati per il test
magari possono esserte utili. 
-- 
Ciao
Fabio

 (timpicamente mastodontico).
Scusa non ho capito :
io ho misurato solamente il ciclo for .
Come ho fatto a tenere traccia anche del tempo di caricamento
dell'interprete java ?
max

 wrote:

Bella domanda che in  effetti non mi ero posto inizialmente :-) mi sa
che andro' a rileggermi l'articolo, poi sapro' dirti meglio :-)
-- 
Ciao
Fabio

 ha scritto nel messaggio
news:c3pip6$au6$1...@news.ngi.it...

scusa ma ci sono alcuni errori...
il (((5*2*5*2*5)/2)%2)+4+2 è una COSTANTE, in effetti pari a
(((5*2*5*2*5)/2)%2 = 0  !!!!!!      + 4 + 2 = 6
Attenzione ai "test al volo" :-)
il compilatore in questo caso calcola la costante e a runtime
fai 98000 volte una somma!
Inoltre non so se il compilatore è anche così furbo da
agevolarsi la vita quando deve fare un ciclo for...
cioè se te gli dici di sommare per 98000 volte 6 al numero "va"
potrebbe fare semplicemente va = va*98000*6 in un'unica istruzione!!!!
(aspetto smentite :-)
prova questo: (lo lancio premendo un pulsante)
long t = System.currentTimeMillis();
    double va = 0.0001;
    for (int i = 1; i < 5000000; i++) {
      va += (((va*0.3*i)/(i*2))%17);
    }
long end = System.currentTimeMillis();
    System.out.println("va is: "+va);
    System.out.println("Elapsed: "+(end-t)+" ms");
  }
================================
JAVA
va is: 2.62696287416538E7   (prima esecuzione)
Elapsed: 250 ms
va is: 2.62696287416538E7  (seconda esecuzione)
Elapsed: 172 ms
il fatto che la seconda volta che lo rilancio (dal pulsante)
sia più bassa mi suona strano, comunque...
forse il fatto che questo ciclo è fatto nel thread di Swing
potrebbe essere la causa, ma cmq i valori sono di
certo dello stesso ordine di grandezza.
prova in C++ e ridimmi
Ciao
PS. in definitiva volevo dire che cmq dei test di questo genere
non sono molto attendibili nè significativi, in quanto dipendono
strettamente da come è implementato l'hardware di una certa
macchina, dal compilatore, dalla specifica del linguaggio, ecc ecc

 sia più bassa mi suona strano, comunque...
Effetto del JIT compiler?
http://wwws.sun.com/software/solaris/jit/
ciao
pole