[Indigo]<Cedar>Viewers>ViewerLocksImpl.mesa!3

ViewerLocksImpl.mesa; Edited by McGregor on October 27, 1982 10:27 am

Last Edited by: Maxwell, February 7, 1983 12:50 pm

Last Edited by: Paul Rovner, June 15, 1983 5:46 pm

DIRECTORY

AMEvents USING [Debugged, Debugging],

Interminal USING [terminal],

Process USING [GetCurrent, InitializeCondition, MsecToTicks, Pause],

DebuggerSwap USING [CallDebugger],

Terminal USING [BlinkBWDisplay],

ViewerClasses USING [Column, Lock, Viewer],

ViewerLocks,

ViewerOps USING [EnumerateChildren, EnumerateViewers, EnumProc];

ViewerLocksImpl: MONITOR

IMPORTS AMEvents, Interminal, Process, DebuggerSwap, Terminal, ViewerOps

EXPORTS ViewerLocks = BEGIN OPEN ViewerClasses, ViewerOps;

lockFree: CONDITION; -- new viewer or column has been released

treeLockSynch: CONDITION; -- synchronise read & write requests pending a tree request

treeRequest: BOOL ← FALSE; -- viewer tree lock pending request state

ColumnInfo: TYPE = RECORD [

lock: Lock,

wedgeCount: CARDINAL

];

columns: ARRAY Column OF ColumnInfo ;

Error: PROC = INLINE {DebuggerSwap.CallDebugger["ViewerLocks bug"]};

InOrder: PROC[v1, v2: Viewer] RETURNS [BOOLEAN] = INLINE { -- highest to lowest

RETURN[LOOPHOLE[v1, LONG CARDINAL] >= LOOPHOLE[v2, LONG CARDINAL]]};

CallUnderWriteLock: PUBLIC SAFE PROC [proc: PROC, viewer: Viewer] = TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => MarkColumnWedged[ViewerColumn[viewer]];

AMEvents.Debugged => MarkColumnUnWedged[ViewerColumn[viewer]]};

AcquireWriteLock[viewer];

proc[];

ReleaseWriteLock[viewer];

END;

CallUnderWriteLocks: PUBLIC SAFE PROC [proc: PROC, v0, v1, v2: Viewer ← NIL] =

TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => {

IF v0 # NIL THEN MarkColumnWedged[ViewerColumn[v0]];

IF v1 # NIL THEN MarkColumnWedged[ViewerColumn[v1]];

IF v2 # NIL THEN MarkColumnWedged[ViewerColumn[v2]]};

AMEvents.Debugged => {

IF v0 # NIL THEN MarkColumnUnWedged[ViewerColumn[v0]];

IF v1 # NIL THEN MarkColumnUnWedged[ViewerColumn[v1]];

IF v2 # NIL THEN MarkColumnUnWedged[ViewerColumn[v2]]}};

AcquireWriteLocks[v0, v1, v2];

proc[];

ReleaseWriteLocks[v0, v1, v2];

END;

CallUnderReadLock: PUBLIC SAFE PROC [proc: PROC, viewer: Viewer] = TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => MarkColumnWedged[ViewerColumn[viewer]];

AMEvents.Debugged => MarkColumnUnWedged[ViewerColumn[viewer]]};

AcquireReadLock[viewer];

proc[];

ReleaseReadLock[viewer];

END;

CallUnderReadLocks: PUBLIC SAFE PROC [proc: PROC, v0, v1, v2: Viewer ← NIL] =

TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => {

IF v0 # NIL THEN MarkColumnWedged[ViewerColumn[v0]];

IF v1 # NIL THEN MarkColumnWedged[ViewerColumn[v1]];

IF v2 # NIL THEN MarkColumnWedged[ViewerColumn[v2]]};

AMEvents.Debugged => {

IF v0 # NIL THEN MarkColumnUnWedged[ViewerColumn[v0]];

IF v1 # NIL THEN MarkColumnUnWedged[ViewerColumn[v1]];

IF v2 # NIL THEN MarkColumnUnWedged[ViewerColumn[v2]]};

};

AcquireReadLocks[v0, v1, v2];

proc[];

ReleaseReadLocks[v0, v1, v2];

END;

CallUnderColumnLock: PUBLIC SAFE PROC [proc: PROC, column: Column] = TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => MarkColumnWedged[column];

AMEvents.Debugged => MarkColumnUnWedged[column]};

Wait: ENTRY PROC = INLINE {ENABLE UNWIND => NULL; WAIT lockFree};

AcquireColumnWriteLock[column ! Wedged => {Wait; RETRY}];

proc[];

ReleaseColumnWriteLock[column];

END;

CallUnderColumnLocks: PUBLIC SAFE PROC [proc: PROC, c0, c1: Column] = TRUSTED BEGIN

ENABLE {

AMEvents.Debugging => {MarkColumnWedged[c0]; MarkColumnWedged[c1]};

AMEvents.Debugged => {MarkColumnUnWedged[c0]; MarkColumnUnWedged[c1]}};

Wait: ENTRY PROC = INLINE {ENABLE UNWIND => NULL; WAIT lockFree};

IF c0 > c1 THEN {c: Column ← c0; c0 ← c1; c1 ← c};

AcquireColumnWriteLock[c0 ! Wedged => {Wait; RETRY}];

AcquireColumnWriteLock[c1 ! Wedged => {Wait; RETRY}];

proc[];

ReleaseColumnWriteLock[c1];

ReleaseColumnWriteLock[c0];

END;

CallUnderViewerTreeLock: PUBLIC SAFE PROC [proc: PROC] = TRUSTED BEGIN

LockViewerTree[];

proc[];

ReleaseViewerTree[];

END;

ViewerColumn: PROC [viewer: Viewer] RETURNS [column: Column] = INLINE

{RETURN[IF viewer.iconic THEN static ELSE viewer.column]};

AcquireWriteLock: PUBLIC ENTRY SAFE PROC [viewer: Viewer] = TRUSTED {

ENABLE UNWIND => NULL;

IF ~WriteLock[viewer] THEN RETURN WITH ERROR Wedged[ViewerColumn[viewer]]};

WriteLock: INTERNAL PROC [viewer: Viewer] RETURNS[success: BOOL ← TRUE] =

INLINE BEGIN OPEN viewer;

process: PROCESS ~ Process.GetCurrent[];

IF treeRequest THEN WAIT treeLockSynch; -- pause

IF ~ReadLockColumn[viewer] THEN RETURN[FALSE];

UNTIL (lock.count=0 OR lock.process=process) DO WAIT lockFree; ENDLOOP;

lock ← [process, lock.count+1];

END;

ReleaseWriteLock: PUBLIC ENTRY SAFE PROC [viewer: Viewer] = TRUSTED BEGIN OPEN viewer;

ENABLE UNWIND => NULL;

ReleaseReadLockColumn[ViewerColumn[viewer]];

IF lock.count = 0 THEN Error[];

IF (lock.count ← lock.count-1) = 0 THEN {lock.process ← NIL; BROADCAST lockFree};

END;

AcquireWriteLocks: PUBLIC ENTRY SAFE PROC [v0, v1, v2: Viewer ← NIL] = TRUSTED BEGIN

Viewers must be sorted so that they are locked from highest to lowest, by column.

ENABLE UNWIND => NULL;

v: Viewer;

IF ~InOrder[v0, v1] THEN {v ← v0; v0 ← v1; v1 ← v};

IF ~InOrder[v1, v2] THEN {v ← v1; v1 ← v2; v2 ← v};

IF ~InOrder[v0, v1] THEN {v ← v0; v0 ← v1; v1 ← v};

IF v0#NIL THEN IF ~WriteLock[v0] THEN

RETURN WITH ERROR Wedged[ViewerColumn[v0]];

IF v1#NIL THEN IF ~WriteLock[v1] THEN {

ReleaseWriteLock[v0]; RETURN WITH ERROR Wedged[ViewerColumn[v1]]};

IF v2#NIL THEN IF ~WriteLock[v2] THEN {

ReleaseWriteLocks[v0, v1]; RETURN WITH ERROR Wedged[ViewerColumn[v2]]};

END;

ReleaseWriteLocks: PUBLIC SAFE PROC [v0, v1, v2: Viewer ← NIL] = TRUSTED BEGIN

no sort required

IF v0#NIL THEN ReleaseWriteLock[v0];

IF v1#NIL THEN ReleaseWriteLock[v1];

IF v2#NIL THEN ReleaseWriteLock[v2];

END;

AcquireReadLock: PUBLIC ENTRY SAFE PROC [viewer: Viewer] = TRUSTED {

ENABLE UNWIND => NULL;

IF ~ReadLock[viewer] THEN RETURN WITH ERROR Wedged[ViewerColumn[viewer]]};

ReadLock: INTERNAL PROC [viewer: Viewer] RETURNS[success: BOOL ← TRUE] =

INLINE BEGIN OPEN viewer;

process: PROCESS ~ Process.GetCurrent[];

IF treeRequest THEN WAIT treeLockSynch; -- pause

IF ~ReadLockColumn[viewer] THEN RETURN[FALSE];

UNTIL (lock.process=NIL OR lock.process=process) DO WAIT lockFree; ENDLOOP;

lock.count ← lock.count+1;

END;

ReleaseReadLock: PUBLIC ENTRY SAFE PROC [viewer: Viewer] = TRUSTED BEGIN

ENABLE UNWIND => NULL;

ReleaseReadLockColumn[ViewerColumn[viewer]];

IF viewer.lock.count = 0 THEN Error[];

IF (viewer.lock.count ← viewer.lock.count-1) = 0 THEN BROADCAST lockFree;

END;

AcquireReadLocks: PUBLIC ENTRY SAFE PROC [v0, v1, v2: Viewer ← NIL] = TRUSTED BEGIN

viewers must be sorted so that they are locked from highest to lowest

ENABLE UNWIND => NULL;

v: Viewer;

IF ~InOrder[v0, v1] THEN {v ← v0; v0 ← v1; v1 ← v};

IF ~InOrder[v1, v2] THEN {v ← v1; v1 ← v2; v2 ← v};

IF ~InOrder[v0, v1] THEN {v ← v0; v0 ← v1; v1 ← v};

IF v0#NIL THEN IF ~ReadLock[v0] THEN

RETURN WITH ERROR Wedged[ViewerColumn[v0]];

IF v1#NIL THEN IF ~ReadLock[v1] THEN {

ReleaseReadLock[v0]; RETURN WITH ERROR Wedged[ViewerColumn[v1]]};

IF v2#NIL THEN IF ~ReadLock[v2] THEN {

ReleaseReadLocks[v0, v1]; RETURN WITH ERROR Wedged[ViewerColumn[v2]]};

END;

ReleaseReadLocks: PUBLIC SAFE PROC [v0, v1, v2: Viewer ← NIL] = TRUSTED BEGIN

no sort required

IF v0#NIL THEN ReleaseReadLock[v0];

IF v1#NIL THEN ReleaseReadLock[v1];

IF v2#NIL THEN ReleaseReadLock[v2];

END;

AcquireColumnWriteLock: PUBLIC ENTRY SAFE PROC [column: Column] = TRUSTED BEGIN

ENABLE UNWIND => NULL;

IF ~ColumnLock[column] THEN RETURN WITH ERROR Wedged[column];

END;

ColumnLock: INTERNAL PROC [column: Column] RETURNS[success: BOOL ← TRUE] = BEGIN

Same as AcquireColumnWriteLock except does ERROR since internal proc

process: PROCESS ~ Process.GetCurrent[];

IF columns[column].wedgeCount>0 THEN RETURN[FALSE];

UNTIL (columns[column].lock.count=0 OR columns[column].lock.process=process) DO

WAIT lockFree;

ENDLOOP;

columns[column].lock ← [process, columns[column].lock.count+1];

END;

ReleaseColumnWriteLock: PUBLIC ENTRY SAFE PROC [column: Column] =

TRUSTED {ENABLE UNWIND => NULL; ReleaseColumnLock[column]};

ReleaseColumnLock: INTERNAL PROC [column: Column] = INLINE {

IF columns[column].lock.count = 0 THEN Error[];

IF (columns[column].lock.count ← columns[column].lock.count-1) = 0 THEN {columns[column].lock.process ← NIL; BROADCAST lockFree}};

ReadLockColumn: INTERNAL PROC [viewer: Viewer] RETURNS[success: BOOL ← TRUE] =

INLINE BEGIN

column: Column ← ViewerColumn[viewer];

process: PROCESS ~ Process.GetCurrent[];

IF columns[column].wedgeCount>0 THEN RETURN[FALSE];

UNTIL (columns[column].lock.process=NIL OR columns[column].lock.process=process) DO

WAIT lockFree;

column ← ViewerColumn[viewer];

IF columns[column].wedgeCount>0 THEN RETURN[FALSE];

ENDLOOP;

columns[column].lock.count ← columns[column].lock.count+1;

END;

ReleaseReadLockColumn: INTERNAL PROC [column: Column] = INLINE BEGIN

IF columns[column].lock.count = 0 THEN Error[];

IF (columns[column].lock.count ← columns[column].lock.count-1) = 0 THEN {columns[column].lock.process ← NIL; BROADCAST lockFree};

END;

Wedged: PUBLIC SAFE ERROR [wedged: Column] = CODE;

ColumnWedged: PUBLIC ENTRY SAFE PROC [column: Column]

RETURNS[wedged, write: BOOLEAN] =

TRUSTED {RETURN[columns[column].wedgeCount # 0, columns[column].lock.process # NIL]};

MarkColumnWedged: PUBLIC ENTRY SAFE PROC [column: Column] = TRUSTED BEGIN

ENABLE UNWIND => NULL;

IF columns[column].wedgeCount = 0 THEN THROUGH [0..3) DO

Interminal.terminal.BlinkBWDisplay[];

Process.Pause[Process.MsecToTicks[100]];

ENDLOOP;

columns[column].wedgeCount ← columns[column].wedgeCount+1;

END;

MarkColumnUnWedged: PUBLIC ENTRY SAFE PROC [column: Column] = TRUSTED BEGIN

ENABLE UNWIND => NULL;

IF (columns[column].wedgeCount ← columns[column].wedgeCount-1) = 0

THEN BROADCAST lockFree;

END;

LockViewerTree: PUBLIC ENTRY SAFE PROC = TRUSTED BEGIN

ENABLE UNWIND => NULL;

treeRequest ← TRUE; -- synchronise further read and write lock requests

FOR column: Column IN Column DO

IF ~ColumnLock[column] THEN {

FOR c: Column IN [FIRST[Column]..column) DO

ReleaseColumnLock[c];

ENDLOOP;

treeRequest ← FALSE;

RETURN WITH ERROR Wedged[column]};

ENDLOOP;

treeRequest ← FALSE;

END;

ReleaseViewerTree: PUBLIC ENTRY SAFE PROC = TRUSTED BEGIN

ENABLE UNWIND => NULL;

FOR column: Column IN Column DO ReleaseColumnLock[column]; ENDLOOP;

END;

ClearAllLocks: ENTRY PROC = BEGIN

ClearLock: ViewerOps.EnumProc = CHECKED {

IF v.parent = NIL THEN ViewerOps.EnumerateChildren[v, ClearLock];

v.lock ← [NIL, 0]};

FOR c: Column IN Column DO columns[c] ← [[NIL, 0], 0]; ENDLOOP;

ViewerOps.EnumerateViewers[ClearLock];

BROADCAST lockFree;

END;

Process.InitializeCondition[@treeLockSynch, Process.MsecToTicks[50]];

END.