Ottimizzazioni migliori (scala e altre lingue che target java vm)

Question

Stavo solo leggendo sull'implementazione di scala di generics specialization e ho davvero attirato la mia attenzione sull'aumento della velocità raggiunta con questa funzione. Mi stavo chiedendo quali altre caratteristiche hanno i linguaggi che hanno come obiettivo java vm implementato che li ha effettivamente resi migliori di java? So che più il codice generato si allontana da Java, più diminuiscono le sue prestazioni. Quindi mi chiedo davvero quali altre funzionalità possono implementare un linguaggio per ottenere prestazioni migliori in java.

Si prega di non rispondere a questa domanda parlando di caratteristiche veramente belle di scala su java, sto parlando rigorosamente di prestazioni.

Anche se avete suggerimenti che ancora non sono stati implementati, si prega di rispondere!

Grazie!

Answer 1

Scala fa support tail-call optimization, che Java, tramite la JVM da solo, don't fully support yet.

Answer 2

forse questo è troppo banale/vecchio/ben noto, ma il compilatore Java ottimizza stringhe letterali e concatenazioni che utilizzano un pool di stringa e StringBuilders:

String a = "a"; 
String b = "a"; 
String c = a + b + someUserInput; 

sarà effettivamente più vicino al

String a = "a"; 
String b = a; 
String a_b = "aa"; 
String c = new StringBuilder(a_b).append(someUserInput).toString(); 

o forse anche (non sicuro)

String a_b = "aa"; 
String a = a_b.substring(0,1); 
String b = a; 
String c = new StringBuilder(a_b).append(someUserInput).toString(); 

Inoltre, l'obiettivo di ottimizzazione per il compilatore Java è passato dalla compilazione a bytecode (javac) alla compilazione da bytecode a codice macchina (Hotspot). Penso che in javac ci fossero più ottimizzazioni, ma hanno trovato che sia un po 'prematuro visto che Hotspot può fare un lavoro molto più completo qui (e attingere alla conoscenza runtime dell'hardware e dei modelli di utilizzo reali).

Un altro aspetto interessante di questo è che le ottimizzazioni di Hotspot possono migliorare le prestazioni molto tempo dopo che il codice è stato scritto e compilato. Ad esempio, l'ottimizzazione StringBuilder sopra utilizzata per utilizzare la classe StringBuffer (leggermente meno efficiente) prima di Java 5. Per ottenere gli ultimi miglioramenti, è necessario ricompilare il codice (che è ancora meglio che avere ottimizzato manualmente per utilizzare StringBuffer prima, nel qual caso dovresti effettivamente aggiornare il codice).

Answer 3

Scala ottimizza le cose come

val nullSafeToString = "" + foo 

a

val nullSafeToString = String.valueOf(foo) 

Java non, in Java sembra

val nullSafeToString = new StringBuilder("").append(foo) 

che prende 4 volte più bytecode di codice più semplice di Scala e crea una nuova istanza StringBuilder e un'inutile String.

Da un lato la JVM è stata creata per supportare le cose che avevano pianificato di utilizzare in Java, anche se la JVM esegue solo bytecode.

Ci sono caratteristiche che mancano da secoli per supportare meglio le lingue funzionali (tailleur) e non tipizzate (InvokeDynamic).

Ma dall'altra parte sono sorpreso di quanto il compilatore JIT sia in grado di ottimizzare il codice e gli strati di codice indiretto molto astratti e finire con il codice che si comporta quanto il codice Java.

Penso che il pattern "Pimp My Library" non sarebbe così popolare se la JVM non fosse in grado di rimuovere le creazioni di istanza di questi semplici modelli implicit + class RichFoo con analisi di escape.