Email or username:

Password:

Forgot your password?
leah & asm & forth, oh my!

has anyone measured the relative power consumption of a system which executes a simple VM's code in a relatively straightforward way (and therefore ends up with lots of pipeline stalls, etc) and one which uses a JIT to compile the same code into machine code the second time it's executed, and then run that?

the best i can find from a quick google is a 2006 paper by Shiwen Hu and Lizy K John, which measures the energy impact of JIT optimisation and garbage collection. their most interesting result is that garbage collection reduces power consumption! so does JIT optimisation, which i assume is not entirely accidental; but interestingly they find that the optimisation stage itself also reduces power (presumably over executing unoptimised JITted code), rather than spending to recoup as one might assume

4 comments
Your friendly 'net denizen

@millihertz The only other paper I know of for energy efficiency comparisons is this one:

greenlab.di.uminho.pt/wp-conte

Too coarse for the sorts of things you're interested in. For the paper you're talking about, was it this one?

ittc.ku.edu/~kulkarni/teaching

leah & asm & forth, oh my!

@cstanhope yes it was... and if that's the only paper on the subject that anyone can find, we direly need more research!

Your friendly 'net denizen

@millihertz Following the references might lead to some other hits, but I'm skimming through the ones in the paper I linked... I'm not seeing a lot in terms of language implementation energy comparisons. Some related papers from references:

green-haskell.github.io/papers

people.rennes.inria.fr/Tomofum

eecis.udel.edu/~manotas/prepri

It seems mobile and Java pop up a lot, which I guess makes sense.

sirjofri

@millihertz maybe there's something about the Inferno OS, which has its own virtual machine called Dis. It can run in JIT mode, pure interpreted mode, as well as native on hardware. You might be lucky since it's always the exact same code that runs, and the same byte code that's interpreted/compiled.

Go Up