Data Types for Process machinery (wizards only)
Queue: TYPE = LONG POINTER TO QueueRep;
QueueRep:
TYPE =
RECORD [
busy: Process, -- a GSL that protects the chain
chain: Process -- points to the tail of a circular process queue
];
MetaQueue: TYPE = LONG POINTER TO Process;
MetaQueueRep:
TYPE = Process;
Locks
MonitorLock: TYPE = LONG POINTER TO MonitorLockRep;
MonitorLockRep:
TYPE =
RECORD [
queue: QueueRep, -- the GQ of waiting processes
owner: Process -- the process owning the lock
];
InitializeMonitorLock:
PROC [monitorLock: MonitorLock]
= TRUSTED INLINE {monitorLock^ ← [queue: [NIL, NIL], owner: NIL]};
Condition: TYPE = LONG POINTER TO ConditionRep;
ConditionRep:
TYPE =
RECORD [
queue: QueueRep, -- the GQ of waiting processes
timeout: Ticks, -- the timeout initialization
flags: CondFlags -- option flags
];
Ticks:
TYPE =
CARD;
NoTimeout: Ticks = 0;
Milliseconds: TYPE = CARD;
Seconds: TYPE = CARD;
CondFlags:
TYPE = Word;
abortEnableBit: NAT = 31;
condRequestBit: NAT = 30;
InitializeCondition:
PROC [condition: Condition, ticks: Ticks]
= TRUSTED INLINE {
condition^ ← [queue: [NIL, NIL], timeout: NoTimeout, flags: DragOps.ZerosWord]
};
MsecToTicks: SAFE PROC [Milliseconds] RETURNS [Ticks];
SecondsToTicks: SAFE PROC [Seconds] RETURNS [Ticks];
TicksToMsec: SAFE PROC [Ticks] RETURNS [Milliseconds];
Timeouts
SetTimeout:
PROC [condition: Condition, ticks: Ticks]
= TRUSTED INLINE {condition.timeout ←
IF ticks = NoTimeout THEN NoTimeout+1 ELSE ticks};
DisableTimeout:
PROC [condition:
Condition]
= TRUSTED INLINE {condition.timeout ← NoTimeout};
InterruptCondition: TYPE = LONG POINTER TO InterruptConditionRep;
InterruptConditionRep:
TYPE =
RECORD [queue: QueueRep, timeout: Word, requests: Word];
ProcessPtr: TYPE = LONG POINTER TO Process;
Process: TYPE = LONG POINTER TO ProcessRep;
ProcessRep:
TYPE =
RECORD [
queue: Queue, -- pointer to queue that this process is waiting for
next: Process, -- next process in above circular queue
meta: Process, -- next process in ready queue, timeout queue or page fault queue
when: Word, -- when timeout will occur OR page number for fault
priority: Priority, -- priority of this process
abort: AbortState, -- aborting state
state: ProcessState, -- process state
euState: EUstate -- useful registers in EU
];
Priority:
TYPE =
MACHINE
DEPENDENT {
slothful (0), -- user-level deep background processing (idle)
sluggish (1), -- user-level background processing
normal (2), -- user-level normal processing
perky (3), -- user-level foreground processing
nervous (4), -- system-level ?? processing
jumpy (5), -- system-level ?? processing
excited (6), -- system-level real-time processing
hyper (7) -- system-level emergency processing
};
ProcessState:
TYPE =
MACHINE
DEPENDENT {
free (0), -- process is on free list
running (1), -- process is running (assigned to a processor)
ready (2), -- process is ready to run (on ready queue)
waitingPage (3), -- process is waiting for page fault (on page fault queue)
waitingCV (4), -- process is waiting for CV
waitingML (5), -- process is waiting for ML
waitingICV (6), -- process is waiting for ICV
done (7) -- process is done (waiting for Join)
};
AbortState:
TYPE =
MACHINE
DEPENDENT {
none (0), -- process not requested to abort
requested (1), -- process abort requested
inhibited (2), -- process abort not allowed & not requested
delayed (3) -- process abort requested but not allowed
};
EUstateIndex:
TYPE =
MACHINE
DEPENDENT {
carry (0), -- the carry bit (not really a register)
field (1), -- shifter control
hook (2), -- pointer to the youngest frame saved to memory (a nacho)
framesLeft (3), -- frames left before fault occurs
temp0 (4), -- user aux reg 0
temp1 (5), -- user aux reg 1
temp2 (6), -- user aux reg 2
temp3 (7) -- user aux reg 3
};
EUstate: TYPE = ARRAY EUstateIndex OF Word;
Detaching processes
Detach: PROC [PROCESS];
Identity of the currently executing process
GetCurrent: SAFE PROC RETURNS [Process]
= TRUSTED INLINE {
};
Priorities of processes
SetPriority:
SAFE
PROC [p: Priority]
= TRUSTED INLINE {
};
GetPriority: SAFE PROC RETURNS [Priority]
= TRUSTED INLINE {
};
Aborting a process
Abort:
PROC [Process];
Requests that the indicated process be aborted.
CheckForAbort:
SAFE
PROC;
Checks for the current process being asked to abort by Abort. Raises ABORTED if such a request has been made. Otherwise CheckForAbort is a null operation.
DisableAborts:
PROC [condition: Condition]
= TRUSTED INLINE {condition^.flags[abortEnableBit] ← FALSE};
EnableAborts:
PROC [condition: Condition]
= TRUSTED INLINE {condition^.flags[abortEnableBit] ← TRUE};
Control of Scheduling
Pause:
SAFE
PROC [ticks: Ticks];
Yield: SAFE PROC = TRUSTED INLINE{ DirectedYield[] };
DirectedYield: UNSAFE PROC [nextState: ProcessState ← ready, nextProcess: Process ← NIL, when: Ticks ← 0];
SetTimeSlice: SAFE PROC [ticks: Ticks];
Process validation
ValidateProcess: PROC [Process];
InvalidProcess: ERROR [process: Process];
Processor data
Processors are chained together in a circular queue that is not modified after initialization. Processor data is, of course, pinned.
Processor: TYPE = LONG POINTER TO ProcessorRep;
ProcessorRep:
TYPE =
RECORD [
next: Processor, -- next processor in ring
orders: ProcessorOrders, -- orders for what to do after reschedule
switchTo: Process, -- if orders = switchToGiven, then this is the one to switch to
running: Process -- the process currently being run
];
ProcessorOrders:
TYPE =
MACHINE
DEPENDENT {
reset (0), -- useful during system init (?)
noChange (1), -- ignore the reschedule
switchToGiven (2), -- switch to process given by processor.switchTo (NIL => to best)
panicStop (3), -- save current process, then spin on these orders
stopped (4) -- stopped in response to panicStop
};
RequestKind: TYPE = [0..31];
RequestWordPtr: TYPE = LONG POINTER TO RequestWord;
RequestWord:
TYPE =
PACKED
ARRAY RequestKind
OF
BOOL;
NullRequestWord: RequestWord = LOOPHOLE[LONG[0]];