Overhead

Overhead

"The same old whinning. Todays GPU are bigger than the CPU. Just look at
the specs for playstation3, 1.8TFlops!!"

I have a pet peeve: People who trivialize performance costs by quoting
only the _maximum_ performance capabilities of _the most recent_ hardware,
as if these numbers actually mean something.

The first part of the peeve is the assumption that I'm necessarily using
the very newest hardware, and operating it in its highest throughput mode.
I still have many machines in production that can barely manage a single
gigaflop at the peak of their performance, but I keep them because they
operate without error for years at a time. I also do a lot of
battery-powered computing, where keeping CPU throughput below 100 MIPS is
actually desirable because of the longer battery life.

A modern PC (e.g. a HT-capable P4 desktop) is made of three parts: Two
machines, each about 1/8 the size and power of a Commodore 64, that run at
3.2 GHz; a machine the size of an Amiga 500 that runs at half that speed,
and the rest of the machine which runs about 5-6 times slower.

Sure, you can add a few levels of indirection here and there in the
software, and it won't cost anything--that is, until the bloat exceeds a
"magic size" that forces the system to use hardware with a different
size/cost/performance tradeoff for its inner loops. Once that happens, it
makes much more sense to look at the _minimum_ performance numbers, since
that's all that will ever come out of the hardware.

Even worse, the minimum level of performance will bear all the same costs
as full performance. Data structure A might require a 3000mAh battery to
run for an hour, while data structure B (which is the same as A except
with a double-indirection feature) might require 7000mAh to run for an
hour, even though the application that manipulates the data structure runs
at the same speed.

End of rant. ;-)

One interesting (and somewhat counterintuitive) observation is that
systems where the application core and the user interface are strongly
separated actually have better performance in many cases than systems
where these two parts are tightly coupled. There is more latency when the
two systems communicate, but this can be offset by higher performance of
the two systems individually.