[comp.arch] Cost per Pixel

stein@dhw68k.cts.com (Rick 'Transputer' Stein) (04/13/90)

I'm curious to know if anyone has a cost metric for the various
graphics workstations.  Does it make sense to ask if I have a $100K
workstation with a 1280x1024 tube, that the cost/pixel is: $100K/(1280*1024)
= $.08/pixel ?

Is there another way to look at this problem other than comparing MIPS, MFLOPS,
Vectors/sec, polygons/sec, etc...?

The bottom line I'm trying to achieve with this query is that suppose
you had a completely scalable, and contentionless graphics system, something
that pumps pixels in direct proportion to the number of the processors in
the machine.  The current graphics workstations are contention bound, and
therefore are not scalable.  At what point would the contentionless system
overtake the shared-memory type ghettoblasters?  In terms of cost/performance,
pixels/sec, etc.
-- 
Richard M. Stein (aka, Rick 'Transputer' Stein)
Sole proprietor of Rick's Software Toxic Waste Dump and Kitty Litter Co.
"You build 'em, we bury 'em." uucp: ...{spsd, zardoz, felix}!dhw68k!stein 

mpogue@dg.dg.com (Mike Pogue) (04/14/90)

In article <31554@dhw68k.cts.com> stein@dhw68k.cts.com (Rick 'Transputer' Stein) writes:
>I'm curious to know if anyone has a cost metric for the various
>graphics workstations.  Does it make sense to ask if I have a $100K
>workstation with a 1280x1024 tube, that the cost/pixel is: $100K/(1280*1024)
>= $.08/pixel ?
>
>Is there another way to look at this problem other than comparing MIPS, MFLOPS,
>Vectors/sec, polygons/sec, etc...?
>
>The bottom line I'm trying to achieve with this query is that suppose
>you had a completely scalable, and contentionless graphics system, something
>that pumps pixels in direct proportion to the number of the processors in
>the machine.  The current graphics workstations are contention bound, and
>therefore are not scalable.  At what point would the contentionless system
>overtake the shared-memory type ghettoblasters?  In terms of cost/performance,
>pixels/sec, etc.
>-- 
>Richard M. Stein (aka, Rick 'Transputer' Stein)

   Let me take a stab at this, in multiple parts:

	1) Does $$ per pixel make sense as a metric for a workstation?

		I don't think so.  The cost of the GRAPHICS SUBSYSTEM in
		a workstation design is almost directly proportional to the
		amount of video memory required.  In looking at many graphics
		designs (including multiple vendors), I found that 90-95% of
		the cost of a graphics design was in the video memory itself.

		At the low end (TIGA, 8514A, VGA), this did not hold, since typically
		the resolution was much less than workstation quality (1280x1K nowadays)
		and therefore the cost of the graphics coprocessor itself and labor costs
		tend to dominate.

		Therefore, I think that $$/pixel will only give you an indication of the
		profit margins of a vendor, and not much else.  Of course, if this is
		what you want to measure, then you are asking a different question.

	2) How would one put a quantitative measure on graphics, such that "pixel pumpers"
		and "standard" graphics designed could be compared?

		From an application programmer's point of view, here is what usually 
		happens:

		step #1: determine what resolution is required by the task at
			hand.  Pick a set of workstations, or graphics designs,
			that meet this criteria.  Be sure to consider the effect
			that higher resolution has on customer perception (which
			after all, is worth something!).  For example, if you had
			two designs that met the minimum resolution criteria,
			1024x800 and 1280x1024, the second would tend to be about
			twice the cost, but might sell better.

		step #2:  determine the minimum level of performance required.
			This is HIGHLY application dependent, so it would be
			best (in the ideal case) to write your code for both
			designs, then choose.  Failing this, write a SHORT
			benchmark that approximates typical conditions of your
			application.  Compare.

			  Remember that higher resolution often requires MORE
			graphics performance, because there are more pixels
			in an object of the same apparant size.  (First determine
			if you even care about this fact.)

		step #3: Calculate:

				profit = f(per unit cost, performance, development cost);

			Choose the design that maximizes PROFIT.  

		Note that this procedure works for comparing pixel pumpers against
		standard frame buffer designs, even though no single quantitative
		measure was calculated.

		Note also that PRICE, or PRICE/PERFORMANCE, or PERFORMANCE, did NOT enter
		into the calculation, except indirectly, somewhere in the PROFIT equation.
		Many companies forget this.

Mike Pogue
Workstations and Graphics Development
Data General Corp.

My opinions are my own....