Re: Doom Conversion (was Dragons Lair

[andrep@balboa.eng.uci.edu (Andre Prellwitz)]

In article <Zm3WWBt.wdphoenix@delphi.com>,
Leslie M. Barstow III  <wdphoenix@delphi.com> wrote:
>Joseph <jlee@clyde.ICS.UCI.EDU> writes:
> 
>>Now where are you getting this info from? Where's the benchmarks?  A 486
>>can execute most of its instructions in around 1 cpu cycle.  With a
> 
>Here's my basis...
>A GS's average cycle count is about 3-4.
>A Mac's average cycle count (excluding the PowerPC) is about 8
>A 386 (relative to a Mac) uses about 3 times more average.
>The 486 reduced this by half.

Bzzt!

>Therefore a GS should run things about 3 times faster than a 486 of equivalent
>speed, if both are optimized equally.
>The GS-Mac, Mac-386, GS-386, and 386-486 comparisons are all out there...
> 
>I don't know where you get your information - the 486 is not a pipelining
>chip.  It is impossible to do anything in one cycle without some advanced help
>The best the 486 can do (assuming intelligent cacheing) is about 3-4 cycles,
>assuming it accesses some information other than the instruction.

The 486 _is_ a pipelined processor, though the problem with (almost) all
pipelined processors is the latency due to instruction interdependencies.
It has four general-purpose 32-bit registers, and an additional 4 if you're
a clever programmer.  Additionally, only simple instructions are pipelined,
or those which do not have an SIB, for example (what's an SIB?  It's a
neat displacement parameter that is similar to the functional GS code of a
LDA index, ASL {up to four times}, CLC, ADC offset or equivalent code).
Instructions like these take a bit longer on a 486, though they are by
no means as slow as the equal GS code.  They can all run in 8, 16, or 32
bit mode as well.  Another _major_ factor for faster processing is a
multiply and divide opcode, something which would be used a lot in texture
mapping as done in Doom or W3D.

The Pentium is even faster, with _two_ pipelines.  It can execute most
cached code in an average of 1-2 cycles/instruction.  Don't try to
divide with it though :)

>For comparison, take the GS adc instruction:
>cycle   operation
>1       load instruction
>2       load immediate data
>3       A + M -> A (c)

And the GS multiply instruction....oops, there isn't one!

>This is typical of a simple instruction.  It is also NOT typical of most x86
>instructions, which require additional processing to determine addressing mode,
>length of instruction, etc.
> 
>Although Dhrystone exists for the GS, I am unsure if it is optimized, and I
>guarantee all x86 versions are quite well-optimized.  Benchmarks would be
>somewhat lopsided considering this - we're not measuring compilers, we're
>comparing chips.

If you wrote a Dhrystone test for the GS in ASM it would still not compare
to a 486 with a crappy compiled version.  The GS would compare to a 286 or
_perhaps_ a 386SX.  I wouldn't want to play Doom on anything other than
a 486DX2 with VLB graphics, though.  If you want to see some awesome
graphics on a GS, buy Mazer II.  It's fast (on a Zipped GS) and has some
tough puzzles to solve, unlike Doom.

Andre