-- ConnectorImpl.mesa
-- last edited  by Suzuki:  5-Jan-82 15:24:38 

DIRECTORY
	Connector,
	MOSSIMFunc,
	Process,
	Rope,
	RandomCard,
	SimTsim,
	Storage,
	TTY;

ConnectorImpl: MONITOR
	IMPORTS RandomCard, SimTsim, Storage, Process, TTY
	EXPORTS Connector, MOSSIMFunc = {

Node: PUBLIC TYPE = RECORD [
  value: REF ANY,
  cond: CONDITION,
  waitingArrayLength: CARDINAL _ 0,
  waiting: POINTER TO ARRAY OF LONG POINTER TO CONDITION _ NIL,
  port: REF Port,
  max: CARDINAL _ 0,
  body: SEQUENCE size: [0..LAST[INTEGER]] OF RECORD [
        choice: PrivateChoice,
	response: CARDINAL,
	direction: {Up, Down, Change}]
  ];
PrivateHandle: TYPE = REF Node;
Port: TYPE = RECORD [
  body: SELECT size: {Single, Multiple} FROM
    Single => [handle: SimTsim.nptr],
    Multiple => [handle: REF PortSequence],
    ENDCASE];
PortSequence: TYPE = RECORD[SEQUENCE size: [0..LAST[INTEGER]] OF SimTsim.nptr];
    
ChoiceNode: PUBLIC TYPE = RECORD [
  response: CARDINAL,
  cond: CONDITION];
PrivateChoice: TYPE = REF ChoiceNode;

TooManyWaiting: SIGNAL = CODE;

OutOfBounds: ERROR = CODE;

Assign: PUBLIC PROC [cond: LONG POINTER TO CONDITION, h:PrivateHandle] 
    RETURNS [CARDINAL] = {
  IF h.waiting=NIL THEN {
    h.waiting _ Storage.Node[20];
    h.waitingArrayLength _ 10;
    FOR i: NAT IN [0..10) DO
      h.waiting[i] _ NIL ENDLOOP};
  FOR i: NAT IN [0..10) DO
    IF h.waiting[i]=NIL THEN {h.waiting[i] _ cond; RETURN[i]};
    REPEAT
      FINISHED => SIGNAL TooManyWaiting
    ENDLOOP;
  RETURN[0]};

CreateChoice: PUBLIC PROC RETURNS [PrivateChoice] = {
	choice: PrivateChoice _ NEW[ChoiceNode];
	Process.DisableTimeout[@choice.cond];
	RETURN[choice]};

RegisterUp: PUBLIC PROC [choice: PrivateChoice, retValue: CARDINAL, port: PrivateHandle] = {
	port.body[port.max] _ [choice, retValue, Up];
	port.max _ port.max+1};

Remove: PUBLIC PROC [loc: CARDINAL, h: PrivateHandle] = {
  IF loc>=h.waitingArrayLength THEN ERROR OutOfBounds;
  h.waiting[loc] _ NIL};

GetChoice: PUBLIC PROC [choice: PrivateChoice] RETURNS [CARDINAL] = {
	Wait[@choice.cond];
	RETURN[choice.response]};

Create: PUBLIC PROC [size: CARDINAL] RETURNS [ret: PrivateHandle] = {
	ret _ NEW[Node[size]];
	Process.DisableTimeout[@ret.cond]};

Put: PUBLIC PROC [n: PrivateHandle, v: REF ANY] = {
--	WF.WF1["Put S:%u ", v];
	CheckAbort[];
	StuffIt[n, v];
	WakeUp[n];
--	StandardDelay[];
	Process.Yield[];
--	WF.WF0["Put F "]
	};

Stuff: PROC [n: PrivateHandle, v: REF ANY] = {
--	WF.WF1["  Stuff S:%b ", v];
	StuffIt[n, v];
	WakeUp[n];
	Process.Yield[];
--	WF.WF0["  Stuff F "]
	};

StuffIt: ENTRY PROC [n: PrivateHandle, v: REF ANY] = {
	n.value _ v};

Place: PUBLIC PROC [n: PrivateHandle, v: REF ANY] = {
	CheckAbort[];
	StuffIt[n, v];
	};

Get: PUBLIC PROC [n: PrivateHandle] RETURNS [ret: REF ANY] = {
--	WF.WF0["    Get S "];
	CheckAbort[];
	ret _ GrabIt[n];
	UNTIL ret#NIL DO
	  StandardDelay[];
          ret _ GrabIt[n];
	  ENDLOOP;
	Process.Yield[]
--	StandardDelay[];
--	WF.WF0["    Get F "]
	};

Grab: PUBLIC ENTRY PROC [n: PrivateHandle] RETURNS [ret: REF ANY] = {
--	WF.WF0["      Grab S"];
	CheckAbort[];
	ret _ n.value;
--	WF.WF0["      Grab F "]
	};

GrabIt: ENTRY PROC [n: PrivateHandle] RETURNS[REF ANY] = {
	RETURN[n.value]};

GetNew: PUBLIC PROC [n: PrivateHandle, v: BOOLEAN] = {
--	WF.WF1["        GetNew S:%b ", v];
	CheckAbort[];
	StandardDelay[];
	GetNewBody[n, v];
--	WF.WF0["        GetNew F"]
	};

GetNewChange: PUBLIC PROC [n: PrivateHandle] = {
	CheckAbort[];
	Wait[@n.cond]
	};
	
GetNewBody: ENTRY PROC[n: PrivateHandle, v: BOOLEAN] = {
	DO
		WaitInternal[@n.cond];
		IF v=NARROW[n.value, REF BOOLEAN]^ THEN EXIT;
	ENDLOOP;
	};

WakeUp: ENTRY PROC [h: PrivateHandle] = {
	BROADCAST h.cond;
	FOR i: NAT IN [0..h.waitingArrayLength) DO
	  IF h.waiting[i]#NIL THEN BROADCAST h.waiting[i]^;
	  ENDLOOP;
	FOR i: NAT IN [0..h.max) DO
	  IF (SELECT h.body[i].direction FROM
	    Change => TRUE,
	    Up => NARROW[h.value, REF BOOLEAN]^,
	    Down => NOT NARROW[h.value, REF BOOLEAN]^,
	    ENDCASE => FALSE) THEN {
	      h.body[i].choice.response _ h.body[i].response;
	      BROADCAST h.body[i].choice.cond};
	  ENDLOOP;
	};


MOSSIMGet: PUBLIC PROC [node: PrivateHandle] = {
    n: SimTsim.nptr;
    CheckAbort[];
    WITH s: node.port SELECT FROM
      Single => {
        n _ s.handle;
        IF SimTsim.pchars[n.npot]='X THEN 
          SimTsim.error3String["Undefined value: ", "%s*n", n.nname]
        ELSE {
          val: REF BOOLEAN _ NEW[BOOLEAN _ SimTsim.boolvalue[n.npot]];
	  Stuff[node, val]}};
      Multiple => IF s.handle.size<=16 THEN {
          val: REF CARDINAL _ NEW[CARDINAL _ CARDPort[node]];
	  Stuff[node, val]}
        ELSE IF s.handle.size<=32 THEN {
          val: REF LONG CARDINAL _ NEW[LONG CARDINAL _ LongCARDPort[node]];
          Stuff[node, val]}
        ELSE SimTsim.error3String["Unimplemented port type for port: ", 
          "%s*n", n.nname];
      ENDCASE
    };

  MOSSIMSet: PUBLIC PROC [node: PrivateHandle] = {
  -- Assigns value from Sakura to MOSSIM through input ports
    CheckAbort[];
    IF node.value=NIL THEN { -- make nodes undefined
      WITH p: node.port SELECT FROM
        Single => SimTsim.setin[p.handle, 'x];
	Multiple => FOR i: NAT IN [0..p.handle.size) DO
	  SimTsim.setin[p.handle[i], 'x] ENDLOOP;
	ENDCASE;
      RETURN};
    WITH node.value SELECT FROM
      n: REF BOOLEAN => 
        WITH p: node.port SELECT FROM
	  Single => SimTsim.setin[p.handle, IF n^ THEN 'h ELSE 'l];
	  ENDCASE => ERROR;
      n: REF CARDINAL =>
        WITH p: node.port SELECT FROM
	  Multiple => IF p.handle.size<=16 THEN {
	    val: CARDINAL _ n^;
	    FOR i: NAT IN [p.handle.size..16) DO val _ val*2 ENDLOOP;
	    FOR i: NAT IN [0..p.handle.size) DO
	      SimTsim.setin[p.handle[i], IF val>=100000B THEN 'h ELSE 'l];
	      val _ val*2;
	      ENDLOOP}
	    ELSE ERROR;
	  ENDCASE => ERROR;
      n: REF LONG CARDINAL =>
        WITH p: node.port SELECT FROM
	  Multiple => IF p.handle.size<=32 THEN {
	    val: LONG CARDINAL _ n^;
	    FOR i: NAT IN [p.handle.size..32) DO val _ val*2 ENDLOOP;
	    FOR i: NAT IN [0..32) DO
	      SimTsim.setin[p.handle[i], IF val>=20000000000B THEN 'h ELSE 'l];
	      val _ val*2;
	      ENDLOOP}
	    ELSE ERROR;
	  ENDCASE => ERROR;
      ENDCASE => ERROR};

  MOSSIMConnect: PUBLIC PROC [node: PrivateHandle, name: STRING] = {
    n: SimTsim.nptr _ SimTsim.ufind[name];
    CheckAbort[];
    IF n=NIL THEN 
      SimTsim.error3String["Cannot find the name: ", "%s*n", name]
    ELSE {
      node.port _ NEW[Single Port];
      node.port^ _ [Single[n]]}};
    
  MOSSIMMultiConnectInit, CharMultiConnectInit: PUBLIC PROC [node: PrivateHandle, size: CARDINAL] = {
    node.port _ NEW[Multiple Port];
    node.port^ _ AllocatePorts[size]}; 
    
  AllocatePorts: PROC [size: CARDINAL] 
      RETURNS [h: Multiple Port] = {
    h.handle _ NEW[PortSequence[size]]};
      
  MOSSIMMultiConnectAssign, CharMultiConnectAssign: 
    PUBLIC PROC [node: PrivateHandle, name: STRING,  
      loc: CARDINAL] = {
    n: SimTsim.nptr _ SimTsim.ufind[name];
    CheckAbort[];
    IF n=NIL THEN 
      SimTsim.error3String["Cannot find the name: ", "%s*n", name]
    ELSE WITH h: node.port SELECT FROM
      Single => ERROR;
      Multiple => h.handle[loc] _ n;
      ENDCASE => ERROR};
      
 CARDPort: PROC [node: PrivateHandle] RETURNS [ret: CARDINAL] = {
   WITH n: node.port SELECT FROM
     Single => ERROR;
     Multiple => 
       SELECT n.handle.size FROM
         <= 16 => {
           ret _ 0;
	   FOR i: CARDINAL IN [0..n.handle.size) DO
	     SELECT SimTsim.pchars[n.handle[i].npot] FROM
	       '1  => ret _ 2*ret+1;
	       '0 => ret _ 2*ret;
	       ENDCASE => SimTsim.error3String[
	         "This node returns undefined value: ", "%s*n", 
		 n.handle[i].nname];
	     ENDLOOP};
	 ENDCASE => ERROR;
     ENDCASE};
   
 LongCARDPort: PROC [node: PrivateHandle] RETURNS [ret: LONG CARDINAL] = {
   WITH n: node.port SELECT FROM
     Single => ERROR;
     Multiple => 
       SELECT n.handle.size FROM
         <= 32 => {
           ret _ 0;
	   FOR i: CARDINAL IN [0..n.handle.size) DO
	     SELECT SimTsim.pchars[n.handle[i].npot] FROM
	       '1  => ret _ 2*ret+1;
	       '0 => ret _ 2*ret;
	       ENDCASE => SimTsim.error3String[
	         "This node returns undefined value: ", "%s*n", 
		 n.handle[i].nname];
	     ENDLOOP};
	 ENDCASE => ERROR;
     ENDCASE};
   
  CharGet: PUBLIC PROC [node: PrivateHandle] = {
    n: SimTsim.nptr;
    ArrayPort: TYPE = RECORD[SEQUENCE size: [0..LAST[INTEGER]] OF CHARACTER];
    CharPorts: PROC [handle: REF PortSequence, size: CARDINAL] 
        RETURNS [val: REF ArrayPort] = {
      val _ NEW [ArrayPort[size]];
      FOR i: NAT IN [0..size) DO
        val[i] _ SimTsim.pchars[handle[i].npot];
        ENDLOOP;
      }; -- CharPorts
    CheckAbort[];
    WITH s: node.port SELECT FROM
      Single => {
        val: REF CHARACTER _ NEW[CHARACTER _ SimTsim.pchars[s.handle.npot]];
	Stuff[node, val]};
      Multiple => IF s.handle.size=16 THEN Stuff[node, CharPorts[s.handle, 16]]
        ELSE IF s.handle.size=32 THEN Stuff[node, CharPorts[s.handle, 32]]
        ELSE SimTsim.error3String["Unimplemented port type for port: ", 
          "%s*n", n.nname];
      ENDCASE
    };
  
  Notify: PUBLIC PROC [node: PrivateHandle] = {
    val: REF BOOLEAN;
    CheckAbort[];
    IF node=NIL THEN ERROR;
    val _ NARROW[GrabIt[node], REF BOOLEAN];
    IF val=NIL THEN
      val _ NEW[BOOLEAN]
    ELSE IF val^ THEN
      {val^ _ FALSE;
      StuffIt[node, val]};
    val^ _ TRUE;
    Put[node, val]};
  

-- Scheduler

currentProcessSize: CARDINAL;

Pool: TYPE = RECORD [
	cond: CONDITION, free: POINTER TO Pool];
MaxCond: CARDINAL = 100;
ConditionPool: ARRAY [0..MaxCond) OF Pool;
FreePool: POINTER TO Pool;
UniversalTime: LONG CARDINAL;

TimeQueue: TYPE = RECORD [
	next: REF TimeQueue,
	time: LONG CARDINAL,
	size: CARDINAL,
	events: POINTER TO Pool];
AllTime: REF TimeQueue _ NIL;

Fork: PUBLIC PROC[newProcess: PROC] RETURNS[PROCESS] = {
	p: PROCESS;
	CheckAbort[];
	IncCurrentEntry[];
	p _ FORK newProcess[];
	Process.Yield[];
	RETURN[p]
	};

Join: PUBLIC PROC[process: PROCESS] = {
	[] _ JOIN process;
	};

NotifyAll: PUBLIC PROC[p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, 
  p14, p15: PrivateHandle] = {
  NotifyInternal[p1];
  NotifyInternal[p2];
  NotifyInternal[p3];
  NotifyInternal[p4];
  NotifyInternal[p5];
  NotifyInternal[p6];
  NotifyInternal[p7];
  NotifyInternal[p8];
  NotifyInternal[p9];
  NotifyInternal[p10];
  NotifyInternal[p11];
  NotifyInternal[p12];
  NotifyInternal[p13];
  NotifyInternal[p14];
  NotifyInternal[p15]};

NotifyInternal: ENTRY PROC [p: PrivateHandle] = {
  IF p=NIL THEN RETURN;
  NOTIFY p.cond;
  FOR i: NAT IN [0..p.waitingArrayLength) DO
    IF p.waiting[i]#NIL THEN NOTIFY p.waiting[i]^
    ENDLOOP;
  FOR i: NAT IN [0..p.size) DO
    IF p.body[i].choice#NIL THEN NOTIFY p.body[i].choice.cond;
    ENDLOOP};
    
ProcessEnd: PUBLIC ENTRY PROC = {
	DecCurrentInternal[];
	IF AllTime = NIL THEN RETURN;
	IF ~CurrentMore[] THEN NotifyEarliest[];
	};

GetProcessSize: PUBLIC ENTRY PROC RETURNS[CARDINAL] = {
	RETURN[currentProcessSize]};

Delay: PUBLIC PROC [max: CARDINAL] = {
	CheckAbort[];
	DelayInternal[max];
	Process.Yield[];
	};

RandomDelay: PUBLIC PROC [min, max: CARDINAL] = {
	CheckAbort[];
	DelayInternal[RandomCard.Choose[min, max]]
	};

DelayInternal: ENTRY PROC [max: CARDINAL] = {
	index: CARDINAL;
	startTime: LONG CARDINAL _ UniversalTime+max;
	DecCurrentInternal[];
	IF currentProcessSize#0 THEN {
		PutThisProcess[startTime];
		RETURN};
	IF startTime<Earliest[] THEN {
		currentProcessSize _ currentProcessSize+1;
		UniversalTime _ startTime; RETURN};
	IF startTime>Earliest[] THEN {
		NotifyEarliest[];
		PutThisProcess[startTime];
		RETURN};
	index _ RandomCard.Choose[0,EarliestSize[]];
	IF index=0 THEN {
		currentProcessSize _ currentProcessSize+1;
		UniversalTime _ startTime; RETURN};
	NotifyEarliestAt[index-1];
	PutThisProcess[startTime]
	};

StandardDelay: PUBLIC PROC = {
	CheckAbort[];
	DelayInternal[RandomCard.Choose[1, 2]];
	Process.Yield[];
	};

Wait: PUBLIC ENTRY PROC [c: LONG POINTER TO CONDITION] = {
	CheckAbort[];
	IF currentProcessSize = 0 THEN ERROR;
	currentProcessSize _ currentProcessSize-1;
	IF AllTime#NIL AND currentProcessSize = 0 THEN NotifyEarliest[];
	WAIT c^;
	currentProcessSize _ currentProcessSize+1};

WaitInternal: INTERNAL PROC [c: LONG POINTER TO CONDITION] = {
	IF currentProcessSize = 0 THEN ERROR;
	currentProcessSize _ currentProcessSize-1;
	IF AllTime#NIL AND currentProcessSize = 0 THEN NotifyEarliest[];
	WAIT c^;
	currentProcessSize _ currentProcessSize+1};
	
IncCurrent: PUBLIC PROC = {
	CheckAbort[];
	IncCurrentEntry[];
	Process.Yield[]};

-- Current process size manipulation

CurrentMore: INTERNAL PROC RETURNS[BOOLEAN] = {
	RETURN[currentProcessSize#0]
	};

DecCurrentInternal: INTERNAL PROC = {
	IF currentProcessSize = 0 THEN ERROR;
	currentProcessSize _ currentProcessSize-1;
	};

IncCurrentEntry: ENTRY PROC = {
	currentProcessSize _ currentProcessSize+1;
	};

-- Time queue manipulation

Earliest: INTERNAL PROC RETURNS[LONG CARDINAL] = {
	IF AllTime=NIL THEN RETURN[LAST[LONG CARDINAL]];
	RETURN[AllTime.time]};

EarliestSize: INTERNAL PROC RETURNS[CARDINAL] = {
	RETURN[AllTime.size]};

NotifyEarliest: INTERNAL PROC = {
	index: CARDINAL _ RandomCard.Choose[0,AllTime.size-1];
	NotifyEarliestAt[index]
	};

NotifyEarliestAt: INTERNAL PROC [index: CARDINAL] = {
	eventQueue: POINTER TO Pool _ AllTime.events;
	back: POINTER TO Pool;
	currentProcessSize _ currentProcessSize+1;
	UniversalTime _ AllTime.time;
	IF index=0 THEN {
		AllTime.events _ eventQueue.free;
		NOTIFY eventQueue.cond;
		eventQueue.free _ FreePool;
		FreePool _ eventQueue;
		IF AllTime.size=1 THEN {
			time: REF TimeQueue _ AllTime;
			AllTime _ AllTime.next}
		ELSE AllTime.size _ AllTime.size-1;
		RETURN};
	THROUGH [0..index-1) DO
		eventQueue _ eventQueue.free;
	ENDLOOP;
	back _ eventQueue;
	eventQueue _ eventQueue.free;
	NOTIFY eventQueue.cond;
	back.free _ eventQueue.free;
	eventQueue.free _ FreePool;
	FreePool _ eventQueue;
	AllTime.size _ AllTime.size-1;
	};

PutToQueue: PROC[newProcess: PROC] = {
	LockAndPutThisProcess[UniversalTime];
	newProcess[]
	};

LockAndPutThisProcess: ENTRY PROC[startTime: LONG CARDINAL] = {
	PutThisProcess[startTime]
	};

PutThisProcess: INTERNAL PROC[startTime: LONG CARDINAL] = {
	timeQueue: REF TimeQueue;
	{IF AllTime=NIL OR AllTime.time>startTime THEN GOTO PutFront;
	timeQueue _ AllTime;
	IF AllTime.time=startTime THEN GOTO PutHere;
	FOR timeQueue_ AllTime, timeQueue.next UNTIL timeQueue.next=NIL DO
		IF timeQueue.time=startTime THEN GOTO PutHere;
		IF timeQueue.next.time>startTime THEN GOTO PutAfter
	REPEAT
		FINISHED => 
			IF timeQueue.time=startTime THEN GOTO PutHere
			ELSE GOTO PutAfter
	ENDLOOP;
	EXITS
		PutFront => {
			time: REF TimeQueue _ NEW[TimeQueue];
			event: POINTER TO Pool;
			time.next _ AllTime;
			AllTime _ time;
			time.time _ startTime;
			time.size _ 1;
			time.events _ FreePool;
			IF FreePool = NIL THEN ERROR;
			FreePool _ FreePool.free;
			time.events.free _ NIL;
			event _ time.events;
			WAIT event.cond};
		PutHere => {
			pool: POINTER TO Pool _ FreePool;
			IF FreePool=NIL THEN ERROR;
			FreePool _ FreePool.free;
			pool.free _ timeQueue.events;
			timeQueue.events _ pool;
			timeQueue.size _ timeQueue.size+1;
			WAIT pool.cond};
		PutAfter => {
			time: REF TimeQueue _ NEW[TimeQueue];
			event: POINTER TO Pool;
			time.next _ timeQueue.next;
			timeQueue.next _ time;
			time.time _ startTime;
			time.size _ 1;
			time.events _ FreePool;
			IF FreePool = NIL THEN ERROR;
			FreePool _ FreePool.free;
			time.events.free _ NIL;
			event _ time.events;
			WAIT event.cond};
	}};

-- Abort

CheckAbort: PROC = {
  IF TTY.UserAbort[] THEN ERROR ABORTED};
    
-- Main part

[] _ RandomCard.InitRandom[seed: -1];
FreePool _ @ConditionPool[0];
{i: CARDINAL;
FOR i IN [0..MaxCond) DO
	Process.DisableTimeout[@ConditionPool[i].cond];
ENDLOOP;
FOR i IN [0..MaxCond-1) DO
	ConditionPool[i].free _ @ConditionPool[i+1]
ENDLOOP};
ConditionPool[MaxCond-1].free _ NIL;
UniversalTime _ 0;
currentProcessSize _ 0;
}.