From: John Levine on
>One of the original motivations of RISC was that a regular, orthogonal,
>instruction set might be easier for compilers to deal with.
>
>Now the line goes that a compiler can deal with an irregular,
>non-orthogonal, instruction set.

It is my impression that the Berkeley RISC team was using PCC, which
was by modern standards a rather dumb compiler, so they made their
RISC orthogonal because that's what PCC could dealt with. They also
invented register windows, since PCC was hopeless about remembering
what registers it used.

Meanwhile in a small town in suburban New York, the 801 project was
using the PL.8 compiler with state of the art analysis and
optimization. It dealt just fine with somewhat irregular instruction
sets (it generated great code for S/360) and had its registers firmly
under control, so the 801 reflected that.

Now we all have compilers as good as PL.8, so we find that where RISC
and 801 differed, 801 was right.

R's,
John

From: Nick Maclaren on
In article <i3p9h5$ejq$1(a)gal.iecc.com>, John Levine <johnl(a)iecc.com> wrote:
>>One of the original motivations of RISC was that a regular, orthogonal,
>>instruction set might be easier for compilers to deal with.
>>
>>Now the line goes that a compiler can deal with an irregular,
>>non-orthogonal, instruction set.
>
>It is my impression that the Berkeley RISC team was using PCC, which
>was by modern standards a rather dumb compiler, so they made their
>RISC orthogonal because that's what PCC could dealt with. They also
>invented register windows, since PCC was hopeless about remembering
>what registers it used.
>
>Meanwhile in a small town in suburban New York, the 801 project was
>using the PL.8 compiler with state of the art analysis and
>optimization. It dealt just fine with somewhat irregular instruction
>sets (it generated great code for S/360) and had its registers firmly
>under control, so the 801 reflected that.
>
>Now we all have compilers as good as PL.8, so we find that where RISC
>and 801 differed, 801 was right.

Well, maybe, but the saner supporters of RISC (who go back to the
1960s) were less interested in the minor details than the new
generation of dogmatists were. We knew by 1975 that it wasn't hard
to code-generate for pretty weird instruction sets. Just very
tedious ....

The fault of far too many architectures is that they provide a
semantically inconsistent interface, and expect the software to
kludge it up. That is rarely feasible without a large loss in
performance, so usually isn't done, and the result is that the
edge cases are got wrong under SOME circumstances but not others.

I am referring to things like when an integer overflow exception
is raised, subtleties of rounding etc. for floating-point (still
present, even with IEEE 754), when unaligned operands are allowed
and so on.


Regards,
Nick Maclaren.
From: Anne & Lynn Wheeler on

John Levine <johnl(a)iecc.com> writes:
> Meanwhile in a small town in suburban New York, the 801 project was
> using the PL.8 compiler with state of the art analysis and
> optimization. It dealt just fine with somewhat irregular instruction
> sets (it generated great code for S/360) and had its registers firmly
> under control, so the 801 reflected that.

for the fun of it ... old email with comparison between various pascals
and pl.8 with pascal front-end (on same pascal program) ... includes
some with execution on the same 3033 (a 4.5mip "high-end" 370):
http://www.garlic.com/~lynn/2006t.html#email810808

in this past post
http://www.garlic.com/~lynn/2006t.html#9 32 or even 64 registers for x86-64?

with misc. other old emails mentioning 801:
http://www.garlic.com/~lynn/2006t.html#email781128
http://www.garlic.com/~lynn/2006t.html#email790607
http://www.garlic.com/~lynn/2006t.html#email790711
http://www.garlic.com/~lynn/2006t.html#email811104

--
virtualization experience starting Jan1968, online at home since Mar1970