Hi,
I found this really interesting: The PDP-8 has no concept of a
stack. It does have sub-routines though. Instead of pushing the
instruction pointer onto a stack, it's being written at the
location to which the call is directed (first address of the
subroutine). Then a return is simply an indirect jump to that
first address of the subroutine.
This is hillarious! Wasn't the notion of a stack arond already
before 1965?
The coolest thing is that inspite of this "unique" way of handling
subroutines, the PDP-8 had a timesharing system TSS-8. I suppose
they could not share code segments then, so if three users were
doing FOCAL, they would have 3 instances of the FOCAL code in
memory (or swapping in and out to disk.) And all this at maximally
32 kB of memory! Amazing.
I just wonder how the kernel calls were handled. The kernel was
called "Monitor." That may be the revealing piece of it: perhaps
the Monitor was a monitor, so only one thread could ever execute
any of the monitor's code at the same time.
That raises a last question: what was first, the TSS-8 kernel
called "Monitor" or the operating system technical term "monitor"?
Dijkstra's classic semaphore paper was back in 1968, and my "new"
Introduction to Programming book is printed 1968 too. AFAIK
the monitor construct is younger than the semaphore, right? So,
could it be that the technical term "monitor" comes from taking the
functioning of the TSS-8 kernel as a paradigma?
fun stuff, isn't it?
-Gunther
PS: I think one could emulate something like a stack on the
PDP-8 using the auto-increment registers in the PDP-8's zero
page. Of course it would work without them, but it may make
the one of the operations push or pop more efficient...
--
Gunther Schadow, M.D., Ph.D. gschadow_at_regenstrief.org
Medical Information Scientist Regenstrief Institute for Health Care
Adjunct Assistant Professor Indiana University School of Medicine
tel:1(317)630-7960 http://aurora.regenstrief.org
Received on Thu Dec 13 2001 - 10:27:26 GMT