La linea di fondo è che dovrai misurarlo tu stesso per la tua applicazione per vedere se è importante . È possibile ottenere risultati piuttosto controintuitivi con l'attuale JVM. Prova questo.
File TraitAbstractPackage.scala
package traitvsabstract
trait T1 { def x: Int; def inc: Unit }
trait T2 extends T1 { def x_=(x0: Int): Unit }
trait T3 extends T2 { def inc { x = x + 1 } }
abstract class C1 { def x: Int; def inc: Unit }
abstract class C2 extends C1 { def x_=(x0: Int): Unit }
abstract class C3 extends C2 { def inc { x = x + 1 } }
TraitVsAbstract.scala File
object TraitVsAbstract {
import traitvsabstract._
class Ta extends T3 { var x: Int = 0}
class Tb extends T3 {
private[this] var y: Long = 0
def x = y.toInt
def x_=(x0: Int) { y = x0 }
}
class Tc extends T3 {
private[this] var xHidden: Int = 0
def x = xHidden
def x_=(x0: Int) { if (x0 > xHidden) xHidden = x0 }
}
class Ca extends C3 { var x: Int = 0 }
class Cb extends C3 {
private[this] var y: Long = 0
def x = y.toInt
def x_=(x0: Int) { y = x0 }
}
class Cc extends C3 {
private[this] var xHidden: Int = 0
def x = xHidden
def x_=(x0: Int) { if (x0 > xHidden) xHidden = x0 }
}
def Tbillion3(t: T3) = {
var i=0; while (i<1000000000) { t.inc; i+=1 }; t.x
}
def Tbillion1(t: T1) = {
var i=0; while (i<1000000000) { t.inc; i+=1 }; t.x
}
def Cbillion3(c: C3) = {
var i=0; while (i<1000000000) { c.inc; i+=1 }; c.x
}
def Cbillion1(c: C1) = {
var i=0; while (i<1000000000) { c.inc; i+=1 }; c.x
}
def ptime(f: => Int) {
val t0 = System.nanoTime
val ans = f.toString
val t1 = System.nanoTime
printf("Answer: %s; elapsed: %.2f seconds\n",ans,(t1-t0)*1e-9)
}
def main(args: Array[String]) {
for (i <- 1 to 3) {
println("Iteration "+i)
val t1s,t3s = List(new Ta, new Tb, new Tc)
val c1s,c3s = List(new Ca, new Cb, new Cc)
t1s.foreach(x => ptime(Tbillion1(x)))
t3s.foreach(x => ptime(Tbillion3(x)))
c1s.foreach(x => ptime(Cbillion1(x)))
c3s.foreach(x => ptime(Cbillion3(x)))
println
}
}
}
Ognuno dovrebbe stampare 1000000000 come la risposta, e il tempo impiegato dovrebbe essere pari a zero (se la JVM è davvero intelligente) o circa il tempo necessario per aggiungere un miliardo di numeri. Ma almeno sul mio sistema, Sun JVM ottimizza al contrario - le corse ripetute si rallentano - e le classi astratte sono più lente dei tratti. (Si potrebbe voler correre con java -XX:+PrintCompilation per cercare di capire cosa va storto, ho il sospetto di zombi.)
Inoltre, vale la pena notare che scalac -optimise non fa nulla per migliorare le cose: dipende interamente dalla JVM.
La JVM JRockit al contrario si trasforma in una prestazione mediocre, ma ancora una volta, i tratti battono le classi. Dal momento che i tempi sono coerenti, li segnalerò: 3.35 per le classi (3.62s per quella con un'istruzione if) contro 2.51 secondi per tutti i tratti, if-statement o no.
(Trovo che questa tendenza sia generalmente vera: Hotspot produce prestazioni veloci e brillanti in alcuni casi, mentre in altri (come in questo caso) si confonde ed è tremendamente lento, JRockit non è mai super veloce - non disturbare cercando di ottenere prestazioni simili a C anche da primitive, ma raramente errori grossolani.)
Se stai pensando seriamente a questo tipo di ottimizzazione a basso livello, stai usando un linguaggio di programmazione sbagliato. – Raphael
@Raphael Se stai usando Scala su un sistema Android o simili potresti aver bisogno di prestare attenzione a tutte quelle cose alle quali normalmente non penserai due volte. – wheaties
Non sto cercando di ottimizzare nulla. È più di un esercizio di apprendimento e soddisfare la mia curiosità. Apprezzo comunque il tuo commento @Raphael. –