DIRECTORY
Basics USING [BITSHIFT, LongNumber],
MesaRuntimeInit USING [StateVectorCounts],
PrincOps USING [Condition, ConditionVariable, ControlLink, FaultIndex, Frame, FrameHandle, FrameSizeIndex, InterruptItem, NoTimeout, NullFrame, NullLink, NullPsbHandle, NullStateVectorHandle, PDA, PDABase, Priority, ProcessDataArea, ProcessState, ProcessStateBlock, PsbHandle, PsbIndex, PsbLink, PsbNull, Queue, SD, sFork, sJoin, sProcessTrap, StartPsb, StateVector, StateVectorHandle, Ticks],
Process USING [DisableTimeout, EnableAborts, Milliseconds, Priority, priorityFaultHandlers, SetPriority, SetTimeout, Ticks],
ProcessBackdoor USING [ParentChildCallback, SingleCallback],
PrincOpsUtils USING [Alloc, Broadcast, ConditionPointer, DisableInterrupts, EnableAndRequeue, EnableInterrupts, Enter, Exit, FrameSize, Free, GetReturnFrame, LongCopy, MyLocalFrame, Notify, PsbHandleToIndex, PsbIndexToHandle, ReadPSB, ReEnter, Requeue, Wait, WritePSB, WriteWDC];

ProcessImpl: MONITOR [pdaWords: CARDINAL, svCounts: MesaRuntimeInit.StateVectorCounts, wordsPerSV: CARDINAL, reservedNakedNotifyMask: WORD, millisecondsPerTick: CARDINAL]
LOCKS processLock
IMPORTS Basics, PrincOpsUtils, Process
EXPORTS MesaRuntimeInit, PrincOpsUtils, Process, ProcessBackdoor
= { OPEN PrincOps;

ConditionPointer: TYPE = PrincOpsUtils.ConditionPointer;

FsiFrame: TYPE = MACHINE DEPENDENT RECORD [
fsi (0): FrameSizeIndex,  -- must be at 3 MOD 4 boundary.
frame (1): local Frame];

NakedNotifyLevel: TYPE = [0..--VM.bitsPerWord--16);

DyingFrameHandle: TYPE = POINTER TO dying Frame;

ParentChildCallback: TYPE = ProcessBackdoor.ParentChildCallback;
SingleCallback: TYPE = ProcessBackdoor.SingleCallback;


processLock: MONITORLOCK;

rebirth: CONDITION;  -- queue of unused processes.
frameReady: CONDITION;  -- queue of parents waiting to rejoin their child.
frameTaken: CONDITION;  -- queue of children waiting to rejoin their parent.
dead: CONDITION;  -- queue of parents waiting for their child to clean up.
deadFrame: DyingFrameHandle _ NIL;  -- the top-level frame of a detached process which needs to be freed.

busyLevels: PACKED ARRAY NakedNotifyLevel OF BOOL;

ForkProc: ParentChildCallback _ NIL;
JoinProc: ParentChildCallback _ NIL;
DetachProc: SingleCallback _ NIL;
EndProc: SingleCallback _ NIL ;

MsecToTicks: PUBLIC SAFE PROC [ms: Process.Milliseconds] RETURNS [Process.Ticks] = TRUSTED {
RETURN[
(IF ms >= Process.Milliseconds.LAST-(millisecondsPerTick-1) THEN
Process.Milliseconds.LAST  -- (avoid overflow)
ELSE ms + millisecondsPerTick-1)
/ millisecondsPerTick
]
};

SecondsToTicks: PUBLIC SAFE PROC [sec: CARDINAL] RETURNS [Process.Ticks] = TRUSTED {
ticks: Basics.LongNumber =
[lc[(sec.LONG*1000 + millisecondsPerTick-1) / millisecondsPerTick]];
RETURN[IF ticks.highbits ~= 0 THEN Ticks.LAST ELSE ticks.lowbits]
};

TicksToMsec: PUBLIC SAFE PROC [ticks: Ticks] RETURNS [Process.Milliseconds] = TRUSTED {
RETURN[
IF ticks > Process.Milliseconds.LAST/millisecondsPerTick THEN
Process.Milliseconds.LAST
ELSE ticks*millisecondsPerTick
]
};

Detach: PUBLIC ENTRY PROC [process: PROCESS] = {
h: PsbHandle;
px: PsbIndex = LOOPHOLE[process];
IF (h _ ValidProcess[px]) = NullPsbHandle THEN
RETURN WITH ERROR InvalidProcess[process];
IF DetachProc # NIL THEN DetachProc[LOOPHOLE[process]];
PDA[h].flags.processState.detached _ TRUE;
BROADCAST frameTaken;  -- wake child if waiting to JOIN.
};

Abort: PUBLIC ENTRY PROC [process: PROCESS] = {
h: PsbHandle;
px: PsbIndex = LOOPHOLE[process];
IF (h _ ValidProcess[px]) = NullPsbHandle THEN
RETURN WITH ERROR InvalidProcess[process];
IF h = PrincOpsUtils.ReadPSB[] THEN {
PDA[h].flags.abort _ FALSE;
RETURN WITH ERROR ABORTED
}
ELSE {
PrincOpsUtils.DisableInterrupts[];  -- (also stops ProcessTimeoutCounter from ticking.)
IF ProcState[h].state = alive THEN {
PDA[h].flags.abort _ TRUE;
IF PDA[h].flags.waiting THEN {
PDA[h].flags.waiting _ FALSE;
PDA[PDA.timeout][PrincOpsUtils.PsbHandleToIndex[h]] _ NoTimeout;
PDA[h].--timeout--mds _ NoTimeout;
PrincOpsUtils.Requeue[NIL, @PDA.ready, h];
};
};
PrincOpsUtils.EnableInterrupts[];
};
};

CheckForAbort: PUBLIC ENTRY SAFE PROC = TRUSTED {
h: PsbHandle = PrincOpsUtils.ReadPSB[];
IF PDA[h].flags.abort THEN {
PDA[h].flags.abort _ FALSE;
RETURN WITH ERROR ABORTED
};
};

Pause: PUBLIC ENTRY SAFE PROC [ticks: Process.Ticks] = TRUSTED {
ENABLE ABORTED => GO TO Aborted;
c: CONDITION;
Process.SetTimeout[@c, ticks];
Process.EnableAborts[@c];
WAIT c;
EXITS
Aborted => RETURN WITH ERROR ABORTED;
};

SetTimeSlice: PUBLIC ENTRY SAFE PROC [ticks: Process.Ticks] = TRUSTED {
IF pSchedulingInterval = NIL THEN RETURN;
pSchedulingInterval^.timeout _ ticks;
NOTIFY pSchedulingInterval^;
};


CountFreeProcesses: PUBLIC ENTRY SAFE PROC RETURNS [freeProcesses: CARDINAL _ 0] = TRUSTED {
pbsIndex: PrincOps.PsbIndex;
firstPBSIndex: PrincOps.PsbIndex ;
pbsIndex _ LOOPHOLE[rebirth, ConditionVariable].condition.tail;
firstPBSIndex _ pbsIndex;
IF pbsIndex # PrincOps.PsbNull THEN DO
freeProcesses _ freeProcesses + 1;
pbsIndex _ PrincOps.PDA.block[pbsIndex].link.next;
IF pbsIndex = firstPBSIndex OR pbsIndex = PrincOps.PsbNull THEN EXIT;
ENDLOOP;
};

RegisterEventProcs: PUBLIC SAFE PROC [forkProc: ParentChildCallback, joinProc: ParentChildCallback, endProc: SingleCallback, detachProc: SingleCallback] RETURNS  [oldForkProc: ParentChildCallback, oldJoinProc: ParentChildCallback, oldEndProc: SingleCallback, oldDetachProc: SingleCallback] = CHECKED {
oldForkProc _ ForkProc;
ForkProc _ forkProc;
oldJoinProc _ JoinProc;
JoinProc _ joinProc;
oldEndProc _ EndProc ;
EndProc _ endProc ;
oldDetachProc _ DetachProc;
DetachProc _ detachProc;
};


ValidateProcess: PUBLIC ENTRY PROC [p: PROCESS] = {
IF ValidProcess[LOOPHOLE[p]] = NullPsbHandle THEN
RETURN WITH ERROR InvalidProcess[p];
};

InvalidProcess: PUBLIC ERROR [process: PROCESS] = CODE;


AllocateNakedCondition: PUBLIC ENTRY PROC
RETURNS [cv: ConditionPointer, mask: WORD] =
{
FOR level: NakedNotifyLevel IN NakedNotifyLevel DO
IF ~busyLevels[level] THEN {
busyLevels[level] _ TRUE;
RETURN[
cv: LOOPHOLE[@PDA.interrupt[level]],
mask: Basics.BITSHIFT[1, NakedNotifyLevel.LAST - level]
];
};
ENDLOOP;
ERROR
};

DeallocateNakedCondition: PUBLIC ENTRY PROC [cv: ConditionPointer] = {
FOR level: NakedNotifyLevel IN NakedNotifyLevel DO
IF busyLevels[level] AND
cv = LOOPHOLE[@PDA.interrupt[level], ConditionPointer] THEN {
busyLevels[level] _ FALSE;
PDA.interrupt[level].condition.tail _ PsbNull;
RETURN;
};
ENDLOOP;
ERROR;
};

ProcState: PROC [psbh: PsbHandle] RETURNS [ProcessState] = INLINE {
RETURN[PDA[psbh].flags.processState]
};

ProcessTrap: PROC RETURNS [BOOL] = {
LongEnter: PROC [a,b: --LONG POINTER TO MONITORLOCK--WORD]
RETURNS [BOOL] = LOOPHOLE[PrincOpsUtils.Enter];
abortee: FrameHandle;
state: RECORD [filler: WORD, v: StateVector];
state.v _ STATE;
UNTIL
(IF state.v.stkptr = 4 THEN LongEnter[state.v.stk[0], state.v.stk[1]]
ELSE PrincOpsUtils.Enter[LOOPHOLE[state.v.stk[0], POINTER TO MONITORLOCK]])
DO ENDLOOP;
abortee _ PrincOpsUtils.GetReturnFrame[];
abortee.pc _ [abortee.pc + 1];  -- step past ME(L) instruction.
PDA[PrincOpsUtils.ReadPSB[]].flags.abort _ FALSE;
ERROR ABORTED;
};

ValidProcess: INTERNAL PROC [p: PsbIndex] RETURNS [h: PsbHandle] = INLINE {
IF p < StartPsb OR p > LOOPHOLE[PDA.count+StartPsb, PsbIndex] THEN
RETURN [NullPsbHandle];
h _ PrincOpsUtils.PsbIndexToHandle[p];
IF ProcState[h].state IN [frameTaken..dead] THEN RETURN [NullPsbHandle];
};

Fork: PROC [--argsForRoot,-- root: ControlLink] RETURNS [childPsb: PsbIndex] = {
PForkFrame: TYPE = POINTER TO FRAME[Fork];
ChildBuilder: PROC [--parent's locals--] RETURNS [--MUST BE NULL!--] = {
pChild: LONG POINTER TO ProcessStateBlock _ @PDA.block[childPsb];
parentFrame: PForkFrame = LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];
fsi: FrameSizeIndex = LOOPHOLE[parentFrame-1, POINTER TO FsiFrame].fsi;
childFrame: PForkFrame = PrincOpsUtils.Alloc[fsi];
PrincOpsUtils.LongCopy[
from: parentFrame, to: childFrame, nwords: PrincOpsUtils.FrameSize[fsi]];
childFrame.identity _ child;
pChild.link.failed _ FALSE;
pChild.link.priority _ PDA[PrincOpsUtils.ReadPSB[]].link.priority;
pChild.flags _ [
processState: [state: alive, detached: FALSE],
cleanup: PsbNull, waiting: FALSE, abort: FALSE
];
pChild.context _ [frame[LOOPHOLE[childFrame, FrameHandle]]];
pChild.mds _ NoTimeout;
PDA[PDA.timeout][childPsb] _ NoTimeout;
PrincOpsUtils.Notify[@rebirth];
};
identity: {parent, child};
argsForChild: StateVector;
argsForChild _ STATE;  -- must be first! ("root" is automatically popped off the stack first.)
identity _ parent;
UNTIL PrincOpsUtils.Enter[@processLock] DO NULL ENDLOOP;
WHILE LOOPHOLE[rebirth, ConditionVariable].condition.tail = PsbNull DO
PrincOpsUtils.Wait[@processLock, @dead, LOOPHOLE[dead, ConditionVariable].timeout];
UNTIL PrincOpsUtils.ReEnter[@processLock, @dead] DO NULL ENDLOOP;
ENDLOOP;
childPsb _ PDA.block[LOOPHOLE[rebirth, ConditionVariable].condition.tail].link.next;  -- walk to tail, then to head.
[] _ ChildBuilder[--my local vars--];
SELECT identity FROM
parent => {
IF ForkProc # NIL THEN ForkProc[PrincOpsUtils.PsbHandleToIndex[PrincOpsUtils.ReadPSB[]], childPsb];
PrincOpsUtils.Exit[@processLock];
RETURN[childPsb]};  -- return child handle to FORKing parent.
child => {
argsForChild.stk[argsForChild.stkptr] _ LOOPHOLE[root];
argsForChild.dest _ root;
argsForChild.stk[argsForChild.stkptr+1] _ LOOPHOLE[End, WORD];
argsForChild.source _ LOOPHOLE[End, ControlLink];
IF ForkProc # NIL THEN { -- insure ForkProc was called in parent before child returns
UNTIL PrincOpsUtils.Enter[@processLock] DO NULL ENDLOOP;
PrincOpsUtils.Exit[@processLock];
};
RETURN WITH argsForChild;  -- "call" root procedure of child.
};
ENDCASE;
};

End: PROC = {
sv: RECORD [filler: WORD, results: StateVector];
frame: DyingFrameHandle;
h: PsbHandle;
sv.results _ STATE;  -- save stack containing returned results.
h _ PrincOpsUtils.ReadPSB[];
IF EndProc # NIL THEN EndProc[Psb: PrincOpsUtils.PsbHandleToIndex[h]];
UNTIL PrincOpsUtils.Enter[@processLock] DO NULL ENDLOOP;
frame _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
frame.state _ alive;
PDA[h].flags.processState.state _ frameReady;
PDA[h].flags.abort _ FALSE; -- too late for Aborts: they no-op
PrincOpsUtils.Broadcast[@frameReady];  -- wake any parent process waiting to Join.
UNTIL ProcState[h].state = frameTaken OR ProcState[h].detached DO
PrincOpsUtils.Wait[@processLock, @frameTaken, LOOPHOLE[frameTaken, ConditionVariable].timeout];
WHILE ~PrincOpsUtils.ReEnter[@processLock, @frameTaken] DO ENDLOOP;
ENDLOOP;
IF deadFrame ~= NIL THEN {PrincOpsUtils.Free[deadFrame]; deadFrame _ NIL};
IF ProcState[h].detached THEN deadFrame _ frame;  -- If detached, leave our frame for freeing.
frame.state _ dead;  -- tell Joiner that we're done.
PDA[h].flags.processState.state _ dead;
PrincOpsUtils.Broadcast[@dead];  -- tell parent our frame has been left for freeing.
PrincOpsUtils.Wait[@processLock, @rebirth, LOOPHOLE[rebirth, ConditionVariable].timeout];
UNTIL PrincOpsUtils.ReEnter[@processLock, @rebirth] DO ENDLOOP;
sv.results.dest _ LOOPHOLE[frame.returnlink, ControlLink];  -- (frame.returnlink was set by Join[] to point to the context of JOIN.)
sv.results.source _ NullLink;
PrincOpsUtils.Exit[@processLock];
RETURN WITH sv.results
};

Join: ENTRY PROC [process: PROCESS] RETURNS [loadResults: FrameHandle] = {
h: PsbHandle;
px: PsbIndex = LOOPHOLE[process];
frame: DyingFrameHandle;
self: FrameHandle = PrincOpsUtils.MyLocalFrame[];
IF (h _ ValidProcess[px]) = NullPsbHandle THEN
RETURN WITH ERROR InvalidProcess[process];
IF JoinProc # NIL THEN JoinProc[PrincOpsUtils.PsbHandleToIndex[PrincOpsUtils.ReadPSB[]], px];
WHILE ProcState[h].state ~= frameReady DO WAIT frameReady ENDLOOP;
frame _ LOOPHOLE[PDA[h].context.frame, DyingFrameHandle];
PDA[h].flags.processState.state _ frameTaken;
BROADCAST frameTaken;  -- tell child process we've got his frame.
WHILE frame.state ~= dead DO WAIT dead ENDLOOP;
frame.returnlink _ self.returnlink;
RETURN[frame]  -- JOINer will next Xfer to "frame", which will reload the results into the stack and return them to the JOINer.
};

defaultInterval: Process.Milliseconds = 100;
schedulerPriority: Process.Priority = Process.priorityFaultHandlers;

pSchedulingInterval: ConditionPointer _ NIL;

Schedule: ENTRY PROC = {
QueueToPsbHandle: PROC [queue: Queue] RETURNS [PsbHandle] = INLINE
{RETURN[PrincOpsUtils.PsbIndexToHandle[queue.tail]]};
schedulingLevels: PACKED ARRAY Process.Priority OF BOOL _
[FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE];
schedulingInterval: CONDITION _ [timeout: MsecToTicks[defaultInterval]];
pSchedulingInterval _ @schedulingInterval;  -- enable use of SetTimeSlice
Process.SetPriority[schedulerPriority];
DO
WAIT schedulingInterval;
FOR priority: Process.Priority DECREASING IN [FIRST[Process.Priority]..schedulerPriority) DO
IF schedulingLevels[priority] THEN {
psb: PsbHandle;
PrincOpsUtils.DisableInterrupts[];
psb _ PrincOpsUtils.PsbIndexToHandle[PDA[QueueToPsbHandle[PDA.ready]].link.next];
DO
SELECT PDA[psb].link.priority FROM
= priority => {PrincOpsUtils.Requeue[@PDA.ready, @PDA.ready, psb]; EXIT};
< priority => EXIT;
ENDCASE => IF psb = QueueToPsbHandle[PDA.ready] THEN EXIT;
psb _ PrincOpsUtils.PsbIndexToHandle[PDA[psb].link.next];
ENDLOOP;
PrincOpsUtils.EnableInterrupts[];
};
ENDLOOP;
ENDLOOP;
};



Initialize: PROC = {
AlignUp: PROC [unaligned, modulus: WORD] RETURNS [aligned: WORD] =
INLINE {RETURN[ ((unaligned + modulus-1) / modulus) * modulus]};
AlignDown: PROC [unaligned, modulus: WORD] RETURNS [aligned: WORD] =
INLINE {RETURN[unaligned  - unaligned MOD modulus]};
rAlloc: PDABase RELATIVE POINTER TO WORD _ LOOPHOLE[pdaWords];  -- allocation pointer.
Process.DisableTimeout[@dead];
Process.DisableTimeout[@frameReady];
Process.DisableTimeout[@frameTaken];
Process.DisableTimeout[@rebirth];
SD[sProcessTrap] _ LOOPHOLE[ProcessTrap];
SD[sFork] _ LOOPHOLE[Fork];
SD[--sCedarFork-- 153B] _ LOOPHOLE[Fork];  -- temporary until Compiler is fixed
SD[sJoin] _ LOOPHOLE[Join];

{
alignmentStateVector: CARDINAL = 4;  -- (a D0 requirement)
sizeStateVector: CARDINAL =
AlignUp[MAX[SIZE[StateVector], wordsPerSV], alignmentStateVector];
rState: StateVectorHandle _ LOOPHOLE[AlignDown[LOOPHOLE[rAlloc], alignmentStateVector]];
FOR pri: Priority IN Priority DO
PDA.state[pri] _ NullStateVectorHandle;
FOR k: CARDINAL IN [0..svCounts[pri]) DO
IF LOOPHOLE[rState, CARDINAL] < sizeStateVector THEN ERROR;
rState _ rState - sizeStateVector;
PDA[rState].stk[0] _ LOOPHOLE[PDA.state[pri]];  -- chain onto list.
PDA.state[pri] _ LOOPHOLE[rState];
ENDLOOP;
ENDLOOP;
rAlloc _ LOOPHOLE[rState];
};

{
sizePSBTimeout: CARDINAL = SIZE[ProcessStateBlock] + SIZE[Ticks];
alignmentTimeoutVector: CARDINAL = 16;  -- (PrincOps requirement)
rStartPsb: PDABase RELATIVE POINTER TO WORD =
LOOPHOLE[PrincOpsUtils.PsbIndexToHandle[StartPsb]];
totalPsbs: CARDINAL;
PDA.count _ 0;
FOR nUseful: CARDINAL DECREASING IN [0..(rAlloc - rStartPsb)/sizePSBTimeout] DO
totalPsbs _ StartPsb + nUseful;
PDA.timeout _ LOOPHOLE[AlignDown[LOOPHOLE[rAlloc - totalPsbs], alignmentTimeoutVector]];
IF (LOOPHOLE[PDA.timeout, CARDINAL] + StartPsb  -- (first used word of timeout vector)
- LOOPHOLE[rStartPsb, CARDINAL]) / SIZE[ProcessStateBlock]  >=  nUseful THEN
{PDA.count _ nUseful; EXIT};  -- that many Psbs fit in available space.
REPEAT
FINISHED => ERROR;
ENDLOOP;
IF PDA.count <= 1 THEN ERROR;
};

FOR psb: PsbIndex IN [StartPsb..StartPsb+PDA.count) DO
PDA[PDA.timeout][psb] _ NoTimeout;
ENDLOOP;

PDA.block[StartPsb] _ ProcessStateBlock[
link: [failed: FALSE, priority: FIRST[Priority], next: StartPsb, vector: NULL],
flags: [
processState: [state: alive, detached: TRUE],
cleanup: PsbNull, waiting: FALSE, abort: FALSE],
context: NULL,
mds: NoTimeout
];
FOR root: FrameHandle _ PrincOpsUtils.MyLocalFrame[], root.returnlink.frame DO
IF root.returnlink.frame = NullFrame THEN {
root.returnlink _ LOOPHOLE[End, procedure ControlLink];
EXIT};
ENDLOOP;
PrincOpsUtils.WritePSB[PrincOpsUtils.PsbIndexToHandle[StartPsb]];  -- tell the processor.
PDA.ready _ Queue[tail: StartPsb];

{
firstFree: PsbIndex _ StartPsb+1;
lastFree: PsbIndex _ StartPsb+PDA.count-1;
LOOPHOLE[rebirth, ConditionVariable].condition.tail _ PsbNull;
FOR psb: PsbIndex IN [firstFree..lastFree] DO
PDA.block[psb].link.next _ IF psb=firstFree THEN lastFree ELSE psb-1;
PDA.block[psb].flags.processState.state _ dead;
PDA.block[psb].mds _ NoTimeout;
REPEAT
FINISHED => LOOPHOLE[rebirth, ConditionVariable].condition.tail _ firstFree;
ENDLOOP;
};

FOR fi: FaultIndex IN FaultIndex DO
PDA.fault[fi] _ [queue: [tail: PsbNull], condition: [tail: PsbNull, abortable: FALSE, wakeup: FALSE]];
ENDLOOP;

busyLevels _ LOOPHOLE[reservedNakedNotifyMask];

PrincOpsUtils.WriteWDC[0];  -- start interrupts.
Detach[FORK Schedule[]];
};

Initialize[];

}.
^ProcessImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Levin on September 28, 1983 12:03 pm
Birrell on August 25, 1983 4:29 pm
Russ Atkinson (RRA) February 19, 1985 1:08:25 pm PST
Bob Hagmann May 3, 1985 11:15:51 am PDT
Types and Related Declarations


Global Variables (protected by processLock)

This really should be protected by a completely separate monitor from the above, but it isn't worth the trouble.

procedures to call during fork, join, detach and end

Exported to Process

Initializing monitors and condition variables
Detaching processes

Aborting a process

Wake the victim up.
TEMP until microcode uses timeout vector:
Control of Scheduling

Process Monitoring
Process validation
Exported to PrincOpsUtils
Internal Procedures

This procedure is invoked by microcode when an aborted process attempts to reenter its monitor.
Acquire abortee's monitor lock:
if ABORTED is made resumable, we should return [monitorEntered: TRUE]
as the result of the MonitorEnter instruction that got us here.
This procedure returns NullPsbHandle if "p" is invalid.

Implementation of Language Constructs (FORK and JOIN)
TEMP until microcode uses timeout vector:
pChild.mds _ Inline.HighHalf[LONG[LOOPHOLE[1, POINTER]]];
The following starts the new process executing.  Its PC is set to begin execution at the instruction after the call to ChildBuilder.  Its stack is empty.  Therefore, ChildBuilder MUST NOT RETURN ANY RESULTS!
Both parent and child processes will execute the following code:
To simulate a procedure call, we must also store dest and source links *above* the stack since ReturnWithState doesn't. (stack pointer is *not* incremented.)
Set child's top context to call End when it returns:
When the top context of a process "returns", it Xfers to this procedure with its results on the stack.
Wait till this process is Detached or Joined:
Free any frame left over from a previous dead detached process:
This process is dead.  Its PSB sits in the rebirth queue until it is recycled into a new process by Fork.  Our current frame however, has one of two fates:
(a) If this process was detached, the frame will simply be freed by the next process that finishes ("deadFrame").
(b) if this process is being Joined, the parent process will have acquired a pointer to our frame.  The JOIN code will Xfer to our frame and the code below will be executed BY THE PARENT PROCESS.  The parent process therefore MUST BE RUNNING IN THE SAME MDS as the child process!
Reload returned results into stack, return to parent:
Wait till process ready to be joined:
Guaranteed to be a dying frame by the time we get here.
Wait till he has finished cleaning up:
At this point, we (the parent process)  have acquired responsibility for the child's frame.  IT MUST BE IN THE SAME MDS AS THE PARENT.  We use the child frame's return link as a mailbox to pass to the child's frame the address of the JOINer's frame, which the child should return to.

Time Slicer
The following is intended to be altered only by the debugger.
Note:  this procedure only touches resident structures and does not call any procedures. It therefore can never consume a state vector and consequently does not need a reserved one, even though it is executing at the reserved priority level.
Note that readyList can't be empty, since we are running!
Initialization
This procedure is implicitly parameterized by the module parameters.

Initialize monitored variables and SD
Allocate StateVector pool:
Find number of {PSB, timeout words} that will fit in space remaining, considering TimeoutVector alignment and unused TimeoutVector positions.
Initialize TimeoutVector: (Note: TimeoutVector unused portions overlay Psbs)
Set up the executing context as a legitimate process (detached) in the first Psb:
TEMP until microcode uses timeout vector:
mds: Inline.HighHalf[LONG[LOOPHOLE[1, POINTER]]] ];
Note: the following assumes that someone has previously set the return link of the topmost frame to NullFrame.

Initialize the ready list
Put rest of PSBs into free pool:  (chained off "rebirth" condition)
TEMP until microcode uses timeout vector:
Initialize FaultVector:
Initialize naked-notify allocator:

Start the time slicer

Bob Hagmann January 30, 1985 3:29:28 pm PST
add ProcessBackdoor
changes to: ParentChildCallback, SingleCallback, Detach, CountFreeProcesses, RegisterEventProcs, Fork, End, Join, DIRECTORY, ParentChildCallback, SingleCallback




 
Κ™–

"Cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<K™$K™"J™4J™'—K˜š
Οk	˜	Kšœžœžœ˜$Kšœžœ˜*Kšœ	žœ²
žœužœO˜‰Kšœžœo˜|Kšœžœ'˜<Kšœžœ„˜——K˜šœ
žœžœ;žœžœžœ
˜ͺ
Kšžœ˜Kšžœ˜&Kšžœ9˜@Kšœžœ
˜K˜Kšœžœ"˜8—K˜Kš
œ™™š	œ
žœžœ
ž	œ
žœ˜+KšœΟc˜9K˜K˜—KšœžœŸœ˜3K˜Kšœžœžœ
žœ
˜0K˜Kšœžœ'˜@Jšœžœ"˜6K˜K™—Kš
Ÿ+™+˜Kšœ
žœ
˜K˜Kšœ	ž	œŸ˜2Kšœž	œŸ2˜JKšœž	œŸ4˜LKšœž	œŸ8˜JK™KšœžœŸE˜iK˜š	œžœ
žœžœ
žœ
˜2Kš
œp™pK˜—K™—š
œ4™4JšΟbœžœ
˜$Jš œžœ
˜$Jš 
œžœ
˜!Jš œžœ˜K™—Kš
œ™™Kš
œ-™-K˜šΟnœžœ
žœ
žœžœžœ˜\šžœ
˜šœ
žœžœž˜@KšœžœŸ˜.—Kšžœ˜ K˜K˜
—˜K˜——š‘œžœ
žœ
žœžœžœžœ˜Tš
œ˜Kšœ	žœ7˜D—Kš
žœ
žœžœžœ
žœ˜AK˜K˜—š‘œžœ
žœ
žœžœžœ˜Wšžœ
˜šžœžœž˜=Kšœž˜—Kšžœ˜Kš
œ
˜
—Kš
œ˜—K˜Kš
œ™K™š
‘œžœ
žœ
žœžœ˜0K˜
Kšœžœ
˜!šžœ(ž˜.Kšžœ
žœ
žœ˜*—Kšžœžœ
žœžœ˜7Kšžœ"žœ
˜*Kšž	œŸ!˜8Kš
œ˜—K˜Kš
œ™K™š
‘œžœ
žœ
žœžœ˜/K˜
Kšœžœ
˜!šžœ(ž˜.Kšžœ
žœ
žœ˜*—šžœžœ˜%Kšžœžœ
˜Kšžœ
žœ
žœ
ž˜Kš
œ
˜
—šžœ˜Kšœ$Ÿ3˜Wšžœžœ˜$Kšžœžœ
˜šžœ
žœžœ˜Kš
œ™Kšžœžœ
˜Kšžœ
žœ9˜@Kš
œ)™)KšžœŸœ˜"Kšœžœžœ˜*Kš
œ˜—Kš
œ˜—Kš
œ!˜!K˜—Kš
œ˜—K˜š‘
œžœ
žœ
žœ
žœžœ˜1Kš
œ'˜'šžœ
žœžœ˜Kšžœžœ
˜Kšžœ
žœ
žœ
ž˜Kš
œ˜—Kš
œ˜K˜—Kš
œ™K™š‘œžœ
žœ
žœ
žœžœ˜@Kšžœ
žœžœ
žœ	˜ Kšœž	œ
˜
K˜K˜Kšžœ˜š
ž˜Kš	œžœ
žœ
žœ
žœ
˜%—Kš
œ˜—K˜š‘œžœ
žœ
žœ
žœžœ˜GKšžœžœ
žœ
žœ
˜)K˜%Kšžœ˜K˜K˜—Jš
œ™J˜š‘œžœ
žœ
ž	œ
žœžœžœ˜\Jš
œ˜Kš
œ"˜"Kšœžœ,˜?Kš
œ˜šžœžœ
ž˜&Kš
œ"˜"Kšœžœ˜2Kšžœžœžœ
žœ
˜EKšžœ
˜—Jš
œ˜—J˜š‘œžœ
žœ
žœužœ„
žœ˜­Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—J˜Kš
œ™K˜š
‘œžœ
žœ
žœžœ˜3šžœžœž˜1Kšžœ
žœ
žœ˜$—Kš
œ˜—K˜Kš	œžœ
žœžœžœ
˜7K˜Kš
œ™K˜š‘œžœ
žœ
ž˜)Kšžœžœ˜,Kš
œ
˜
šžœžœž˜2šžœžœ˜Kšœžœ
˜šžœ
˜Kšœžœžœ˜$Kšœ
žœžœ	˜7Kš
œ˜—Kš
œ˜—Kšžœ
˜—Kš
ž˜Kš
œ˜—K˜š‘œžœ
žœ
žœ˜Fšžœžœž˜2šžœž˜Kšœžœžœ%žœ˜=Kšœžœ
˜Kšžœ+˜.Kšžœ
˜Kš
œ˜—Kšžœ
˜—Kšžœ
˜Kš
œ˜—K˜—K™™š‘	œžœžœžœ˜CKšžœ
žœ˜$Kš
œ˜—K˜š‘œžœ
žœžœ˜$Kš
œ_™_š‘	œžœŸžœ
˜:Kšžœžœžœ˜/—K˜Kšœžœ
žœ˜-Kšœ
žœ
˜Kš
œ™š
ž˜Kšœ
žœžœ*˜EKš
žœžœžœ
žœ
žœ˜KKšžœ
žœ
˜—Kš
œ)˜)Kšœ Ÿ˜?Kšžœ(žœ
˜1Kšžœ
žœ
˜Kš
œE™EKš
œ?™?Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜KKš
œ7™7š	žœžœžœ
žœž˜BKšžœ˜—Kš
œ&˜&Kšžœžœžœ
žœ˜HKš
œ˜—K™—K™5˜š‘œžœŸœžœ˜PKš	œžœžœ
žœ
žœ˜*š
‘œžœŸœžœŸœ˜HKš	œžœ
žœ
žœžœ˜AKšœžœ!˜CKšœžœžœ
žœ˜GK˜2š
œ˜Kš
œI˜I—K˜Kšœžœ
˜Kšœžœ(˜B˜Kšœ'žœ˜.Kšœžœ	ž˜.Kš
œ˜—Kšœžœ˜<Kš
œ)™)Kš
œ9™9K˜Kšžœ
žœ ˜'Kš
œΟ
™Ο
Kš
œ˜Kš
œ˜—K˜K˜KšœžœŸG˜^K˜Kšžœ#žœ
žœ
žœ
˜8šžœ
žœ6ž˜FKšœ(žœ#˜SKšžœ,žœ
žœ
žœ
˜AKšžœ
˜—Kšœžœžœ9Ÿ˜tKšœŸœ˜%Kš
œ@™@šžœ
ž˜š
œ˜Jšžœžœ
žœM˜cKš
œ!˜!KšžœŸ)˜=—˜
Kš
œ
™
Kšœ(žœ˜7K˜Kš
œ4™4Kšœ*žœžœ˜>Kšœžœ˜1šžœžœ
žœŸ<˜UKšžœ#žœ
žœ
žœ
˜8Kš
œ!˜!K˜—Kšžœ
žœŸ"˜=Kš
œ˜—Kšžœ
˜—Kš
œ˜—K˜š‘œžœ˜
Kš
œf™fKšœžœ
žœ˜0K˜K˜
Kšœ
žœŸ*˜?Kš
œ˜Jšžœžœ
žœ1˜FKšžœ#žœ
žœ
žœ
˜8Kšœžœ˜/K˜Kšžœ*˜-KšžœžœŸ"˜>Kšœ'Ÿ+˜RKš
œ-™-šžœ!žœž˜AKšœ.žœ)˜_Kšžœ3žœ
žœ
˜CKšžœ
˜—Kš
œ?™?Kšžœžœ
žœ-žœ˜JKšžœžœŸ,˜^KšœŸ˜4Kšžœ$˜'Kšœ!Ÿ3˜TKšœ+žœ&˜Yš
œ›
™›
Kš
œq™qKš
œ—™——Kšžœ/žœ
žœ
˜?Kšœžœ"ŸH˜„
K˜Kš
œ!˜!Kš
œ5™5Kšžœ
žœ˜Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜JK˜
Kšœžœ
˜!K˜Kš
œ1˜1šžœ(ž˜.Kšžœ
žœ
žœ˜*—Kšžœžœ
žœG˜]Kš
œ%™%Kšžœ"žœ
žœžœ
˜BKš
œ7™7Kšœžœ
žœ%˜9Kšžœ*˜-Kšž	œŸ*˜AKš
œ&™&Kšžœžœ
žœžœ
˜/Kšœˆ
Ÿœ{™›Kš
œ#˜#Kšžœ	Ÿp˜Kš
œ˜—K™—K™K˜K˜,K˜DK˜Kšœ(žœ
˜,K˜š‘œžœ
žœ˜š‘œžœžœž˜BKšœ
žœ.˜5—Kš
œ=™=š	œžœ
žœžœ
žœ˜9Kšœ
žœžœžœžœžœžœžœžœ˜5—Kšœž	œ+˜HKšœ,Ÿ˜IKš
œρ
™ρ
K˜'š
ž˜Kšžœ˜š	žœž
œ
žœžœ'ž˜\šžœžœ˜$K˜K˜"Kš
œ9™9Kšœ%žœžœ˜Qš
ž˜šžœ
žœž˜"Kšœ&žœ	žœžœ˜IKšœžœ
˜Kš
žœžœžœžœ
žœ
˜:—Kšœ%žœ˜9Kšžœ
˜—K˜!K˜—Kšžœ
˜—Kšžœ
˜—K˜K˜K˜—Kš
œ™˜š‘
œžœ˜Kš
œD™Dš
‘œžœžœžœžœ˜BKšžœžœ2˜@—š
‘	œžœžœžœžœ˜DKšžœžœžœ˜4—Kšœžœ
žœ
žœ
žœžœ
Ÿ˜VK™Kš
œ%™%K˜K˜$K˜$K˜!Kšžœžœ˜)Kšžœ
žœ˜Kšžœ
Ÿœ	žœ	Ÿ$˜OKšžœ
žœ˜K˜Kš
œ™š
œ
˜
KšœžœŸ˜:šœžœ˜Kšœžœ
žœ2˜B—Kšœžœžœ!˜Xšžœžœ
ž˜ Kšžœ$˜'šžœžœ
žœž˜(Kš
žœ
žœ	žœžœ
žœ
˜;K˜"Kšžœžœ
žœŸ˜CKšžœžœ	˜"Kšžœ
˜—Kšžœ
˜—Kšœ	žœ	˜Kš
œ˜—K˜š
œ
˜
Kš
œ
™
Kšœžœžœžœ˜AKšœžœŸ˜Aš	œžœ
žœ
žœ
žœ˜-Kšžœ+˜3—Kšœžœ
˜Kšžœ˜š	žœ
žœ
ž
œ
žœ*ž˜OK˜Kšžœžœžœ/˜Xš	žœžœ
žœ
žœŸ&˜VKšœžœžœžœ!ž˜LKšœ
žœžœŸ)˜G—š
ž˜Kšžœžœ
˜—Kšžœ
˜—Kšžœ
žœžœ
žœ
˜Kš
œ˜—K˜Kš
œL™Lšžœžœžœž˜6Kšžœ
žœ˜"Kšžœ
˜K˜—Kš
œQ™Qšžœ%˜(Kšœžœžœ$žœ˜Oš
œ˜Kšœ'žœ˜-Kšœžœ	žœ˜0—Kšœ	žœ
˜Kš
œ)™)Kš
œ3™3K˜K˜—Kš
œn™nšžœIž˜Nšžœ#žœ˜+Kšœžœ˜7Kšžœ˜—Kšžœ
˜—KšœCŸ˜YK™Kš
œ™Kšžœ˜"K˜Kš
œC™Cš
œ
˜
K˜!Kšœžœ	˜*Kšžœ6˜>šžœžœž˜-Kšžœžœžœ
žœ˜EKšžœ,˜/Kš
œ)™)Kšžœ˜š
ž˜Kšžœžœ8˜L—Kšžœ
˜—Kš
œ˜—K˜Kš
œ™šžœžœž˜#KšžœLžœ
žœ˜fKšžœ
˜K˜—Kš
œ"™"Kšœ
žœ˜/K˜KšœŸ˜0K™K™Kšœžœ
˜Kš
œ˜—K˜K˜
K˜—š
œ˜K™š
œ+™+K™KšœΟr”
™ 
—K™K™K™K™Kš
’
™
——…—ARhI