🚀 go-pugleaf

In article <3256@wpi.wpi.edu> jhallen@wpi.wpi.edu (Joseph H Allen) writes:
>A question for those old diehard dec fans...  We (WPI) used to have a
>DECSYSTEM 20.  One interesting thing about the DEC 20 (and I guess DEC 10 and
>pdp-6 as well) is that the registers are the first 8 or 16 locations in the
>main memory map.  Does anyone know if code can be run in the registers?  And
>if so, does it execute any faster than if it was in normal memory?

On the PDP-6 and the earlier PDP-10s, running code in the registers was
considerably faster than from core.  Fitting your inner loop into the registers
was a pleasant intellectual exercise.  On the '20 there was a cache so running
from the registers no longer helped.

>Here's some other interesting DEC 20 features for those who don't know:
>
>	- Each address had an indirect bit.  Therefore you could do
>	  infinite levels of indirections.  You can even crash your program
>	  by having self indirections.

If an interrupt arruved while calculating an address, it abandoned the address
calculation, took the interrupt, and restarted the instruction when the
interrupt returned.  It occurred to me that I could find the interval between
clock interrupts by writing a program that made a longer and longer indirect
chain until it finally stalled because the chain was too long to deference
between clock interrupts.

>	- An address was calculated for all instructions.  Even those which
>	  didn't use the address.
Quite true.  The instruction set was quite orthogonal which meant there were
more different kinds of no-ops than on any machine before or since, e.g.
test register and don't jump, test memory and don't skip, test bits against
a register and disregard the result, etc.

>	- There's an execute instructions which executes the instruction at
>	  the calculated address.  (and yes, executing an execute instruction
>	  got things very confused)
It wasn't confusing at all.  Execute instructions were a very fast way to have
a program switch.  I had complicated switches with two or three nested executes
which worked very nicely.

>	- The family of computers which the DEC 20 was based didn't originally
>	  use a stack.  There are a bunch of instructions which allow
>	  subroutine calls to occure with linked lists instead of stacks.

Not true.  When they designed the PDP-6 it wasn't clear what kind of subroutine
linkage would be the most useful, so they gave you three -- store the return
address in a register, store it in the memory location at the beginning of
the routine, or push it on the stack.  In fact all three turned out to be
useful, though the last dominated in later years.  Gordon Bell has said that
the goal of the PDP-6 was to be an efficient Lisp and Fortran machine, so they
put stacks in for the benefit of Lisp.

>	- The DEC 20 didn't really have CC bits and all instructions were 1
>	  word long so the O.S. (Tops-20 aka. Twenex) indicated different
>	  return conditions from O.S. calls by returning at different places.
>	  So an error return might be the next instruction after the O.S. call
>	  and a success condition would be 2 at 2 instructions after the O.S.
>	  call.
This was consistent with the conditional instructions, most of which skipped
the next instruction if the condition was met.

The PDP-6 architecture was an excellent one for its day.  It was both easy to
program in assembler and easy to compile code for.  It would probably
still be around if the addresses were more than 18 bits long.  They put a
truly stupendous addressing crock into the DEC-20 but it was too incompatible
with the regular addressing, and by then it was clear that 32-bit byte
addressed machines, e.g. the Vax, would dominate.
-- 
John R. Levine, Segue Software, POB 349, Cambridge MA 02238, +1 617 492 3869
{ bbn | spdcc | decvax | harvard | yale }!ima!johnl, Levine@YALE.something
Massachusetts has 64 licensed drivers who are over 100 years old.  -The Globe