PDP manual describing coroutines

[Gordon Chillcott]

I recall a description of co-routines somewhere in the RT-11
documentation.   Just where in that documentation, I can't recall.
I should mention that that documentation filled a number of binders. 

If you do find a full set of manuals, the only advice I can offer is my
own rule that you look about a quarter of the way into the one manual
that should have the least to do with the subject you're investigating.

I seem to remember there was an Editor manual . . .

Gordon


On Sat, 2013-11-02 at 21:33 -0400, D. Hugh Redelmeier wrote:
> | From: Paul Tarvydas <paultarvydas-Re5JQEeQqe8AvxtiuMwx3w at public.gmane.org>
> 
> | Over on the FBP google group, Brad Cox mentioned that he learned about
> | coroutines from a PDP-x manual, which described coroutines and subroutines as
> | equals.   He thought that it was the PDP-8 assembler manual, but this appears
> | not to be the case.
> | 
> | Does anyone know which manual contained this explanation, and, does anyone
> | have a copy of this manual that can be shared?
> 
> There was no "the PDP-8 assembler manual" as far as I remember.  There
> were books like the 1967 "The Digital Small Computer Handbook", the
> somewhat different 1968 book with the same title, and the
> "Introduction to programming:  PDP-8 Family Computers".  At least
> those are the ones I have in storage.
> 
> <https://www.flickr.com/photos/walkingsf/sets/72157628922224107/>
> <http://highgate.comm.sfu.ca/pdp8/>
> 
> The PDP-10 and PDP-11 also supported coroutines.
> 
> See, for example <http://www.inwap.com/pdp10/usenet/coroutines> (random
> Google hit).
> 
> Coroutines are easy to implement on any machine that doesn't use a
> stack discipline.  Once you have a stack, you need some way to kludge
> a branching stack, possibly behind the back of the runtime system.
> 
> As I remember it, I invented coroutines on the PDP-8 (in 1968).  Not
> that I was the first!  But it means that I don't think that those
> PDP-8 manuals describe coroutines.  I may only have had the first
> book at that time.
> 
> The PDP-8 subroutine call instruction
> 	jms sub
> would:
> 1) store the return address in sub
> 2) transfer control to sub+1
> 
> All addresses are of 12-bit words and all addresses fit in a 12-bit
> work.  Note: the return address is stored amongst the instruction
> stream.  Supporting recursion takes work.
> 
> Coroutines could be coded like this (re-invented just now; may be
> wrong or not optimal):
> 
> a_entry: .word 0	; entry point and return address
> 	 jmp @a_yield	; jump to where a_yield points
> a_yield: .word a_start	; where to resume a
> 	 jmp @a_entry	; jump to where a_entry points
> 
> ; sample body for a.
> ; Each call of a yields a charcter in the accumulator.
> ; It yields the characters a, b, c in sequence and then repeats
> a_start: cla	; clear the accumulator
> 	 tad ='a'	; add 'a'
> 	 jms a_yield	; yield to a's caller
> 	 cla
> 	 tad ='b'
> 	 jms a_yield
> 	 cla
> 	 tad ='c'
> 	 jmp a_start
> 
> (I've taken a lot of liberties with the notation to make it look like
> conventional modern assembly languages.)
> 
> - aentry is the entry point to the corouting (each time).
>   To call the routine (from outside): jms aentry
> 
> - astart would be the label on the initial starting point of the
>   coroutine.
> 
> - the coroutine would yield control (return to its caller) by calling
>   ayield: jms ayield
> 
> - the very first time the coroutine is called, the aentry+1 jmp
>   would use the intial content of ayield as the starting point
>   of the couroutine.  So it must be suitably initialized (astart).
> 
> Notice how, to the body of the coroutine, the caller looks like a
> subroutine?  That's the magic of coroutines.
> 
> The machine with the easiest implementation of coroutines must be the
> RCA CDP-1802.  It had 16 registers.  You could switch which one was
> the program counter (SEP command).  So if you had a small number of
> coroutines, you could dedicate one register for each to be the program
> counter.  To transfer to another coroutine, just switch to that
> coroutine's program counter.
> --
> The Toronto Linux Users Group.      Meetings: http://gtalug.org/
> TLUG requests: Linux topics, No HTML, wrap text below 80 columns
> How to UNSUBSCRIBE: http://gtalug.org/wiki/Mailing_lists


--
The Toronto Linux Users Group.      Meetings: http://gtalug.org/
TLUG requests: Linux topics, No HTML, wrap text below 80 columns
How to UNSUBSCRIBE: http://gtalug.org/wiki/Mailing_lists