🚀 go-pugleaf

In article <423@bnr-fos.UUCP>, schow@bnr-public.uucp (Stanley Chow) writes:
> "Compilers can do optimizations", I hear the yelling. This is another
> interesting phenomenon - reduce the complexity in the CPU so that the 
> compiler must do all these other optimizations. I have also now seem any
> indications that a compiler can to anywhere close to an optimal job on
> scheduling code or pipelining. Even discounting the NP-completeness of
> just about everything, theoratical indications point the other way,
> especially when the compiler has to juggle so many conflicting constraints.
> 

I am quite naive on this subject (but that won't stop me from throwing in my
two cents worth :^)), but it seems to me that if we still programmed mostly
in assembler, then CISC would beat RISC.  I did a lot of programming of the
8086 using assembler language, and I became (painfully) aware of some of the
unusual instructions, and the difference the choice a a particular register,
or way of doing something would make on overall performance.  By skillfully
picking my instructions, I could improve performance *significantly*.  On the
other hand, I can't imagine any compiler (apologies to the compiler writers)
smart enough to have figured out what I wanted to do, and to choose the
optimal instructions if I had coded the algorithm in a high level language.
In fact, I suspect that a lot of the weird instructions were never used by
compilers at all.  This means that compilers often generate RISC code for CISC
machines (ie. they use the simplest instructions they can).

On the other hand, I can see that while a RISC processor programmed in assembler
might not be quite as quick as an expertly assembled CISC program, the compiler
has a reasonable chance of generating a good sequence of instructions.  At
least it doesn't have to ask questions like:
  1) If I use register A for this operation, the next 10 instructions will
     be quick, but
  2) would I be better to not use A, use B (slow) and wait until a really
     critical set of instructions comes up to use A.
Even if your compiler is brainy enough to figure that out, there is almost
no way it can recognize that the algorithm I'm performing is a Fast Fourier
Transform.  It will generate the code to perform it instead of using a
(hypothetical) FFT CISC instruction.

My point is that since almost everything is written in high level languages
today, they are better suited for RISC.  For applications that still use
assembler (eg. control systems) CISC makes sense.

But what do I know??

                                  Terry Ingoldsby
                                  Land Information Related Systems
                                  The City of Calgary
                                  ctycal!ingoldsb@calgary.UUCP
                                           or
                             ...{alberta,ubc-cs,utai}!calgary!ctycal!ingoldsb