More transistors, Moore’s Law, less juice
“Koomey’s Law” examines power per computation
It looks like an accident that Moore’s Law has been shadowed by a parallel phenomenon: that over time, the amount of power required per unit of computation falls. That’s the conclusion of Stanford PhD and consulting professor Jonathan Koomey, whose work has already been dubbed “Koomey’s Law”.
As Koomey writes in a paper to be published by the IEEE, over the timespan for which we’re able to observe the popular interpretation of Moore’s Law, “the electrical efficiency of computing (the number of computations that can be completed per kilowatt-hour of electricity) also doubled” every year-and-a-half.
It’s probably a good thing: otherwise by now we’d probably be in the market for a second Sun, just to power our computers.
In the transistor era, the Moore’s and Koomey’s observations are, in fact, inextricably linked.
How so? Moore’s law states that the complexity of chips would double every two years – and to do achieve that doubling, designers need to make transistors smaller, and they need to manage component power consumption.
Koomey writes that reducing the physical dimensions of a transistor – necessary to pack more devices onto a chip – demands that the transistor’s power consumption is also reduced. If a designer merely shrunk the device, but left its power consumption the same, the power densities on the silicon would “become unimaginable”, his paper states.
Shorter paths (between the transistor's source and drain) and fewer collisions between electrons also help, the paper states.
It’s not just the transistors, though: Koomey also documents (and calls for more study to completely explain) the way in which whole systems also appear to follow the power efficiency he observes in the silicon.
Interestingly, even back in the vacuum tube era, people were working hard to get more computation for less electricity, but for a different reason: heat was a great enemy of vacuum tubes. The curve seems to fit, all the way back to ENIAC.
All of this would be purely academic, except for one thing. As Koomey said to MIT’s Technology Review, most computers are under-utilised. And that wastes electricity. If the world can put the cloud to good use, we could have our computing cake without eating so much power.
And Koomey’s Law also predicts a continuation of what we’re already seeing: more computation for less electricity means more capable smartphones and tablets consuming less power.
Now all we need to do is come up with reasonably efficient software that doesn’t waste processor cycles doing not much.
Koomey’s paper, co-authored by Intel’s Henry Wong, Microsoft’s Stephen Berard, and Marla Sanchez of Carnegie Mellon University, is published in the IEEE Annals in the History of Computing. ®
Every 2 years*, software will evolve to require 2x as much processing power to do the same thing.
* This is only an average; looking just at MS Word and MS Excel, the doubling occurs every year.
Anyone remember when "laws" involved Lagrangians, or at least a citation of Maxwell and not some fuddy-duddy empirical stuff pulled out of a noisy spreadsheet ranging over a limited time like it's John Maynard Keynes pulling something pretentiously revolutionary out of his nether regions?
Skizz wrote: "From what I've seen, most graduates have trouble writing a "Hello World" program in less the 50K."
That is not because they are worse programmers than earlier generations, but mainly because even a cleverly written "Hello World" program in Java will be 50K+ as a binary, because the binary has to include the Java run-time system and some standard libraries. This gets worse when using so-called "frameworks" which are essentially huge libraries that allow certain types of application to be written with very little original code (or thought), but will give huge and slow binaries.
This is a consequence of the fact that the cost of memory and compute power has fallen drastically while programmer salaries have not. So it makes better economic for companies to make a resource-hogging program using few programmer hours than using many programmer hours to make a mean and lean program -- the cost of one more server is only about a dozen programmer hours (if that). This works only up to a limit, though. No amount of server power will help if the programmer uses an exponential-time, quadratic-space algorithm instead of an linear-time, linear-space algorithm -- unless the problem size never gets very big.