Rosemary.DF=>SwitchTypeCells.Mesa
Last Edited by: Spreitzer, April 18, 1984 12:24:24 pm PST
DIRECTORY IO, List, Rope, RoseCreate, RoseRun, RoseTypes, SwitchTypes, SwitchTypesPrivate;
SwitchTypeCells:
CEDAR
PROGRAM
IMPORTS IO, Rope, RoseCreate, RoseRun, SwitchTypes
EXPORTS SwitchTypes, SwitchTypesPrivate =
BEGIN OPEN RoseTypes, SwitchTypes, SwitchTypesPrivate;
Side: TYPE = {A, B};
NumberedPortList: TYPE = LIST OF NumberedPort;
NumberedPort: TYPE = RECORD [index: CARDINAL, port: Port];
SwitchMakeSplitJoin:
PUBLIC
PROC [within: Cell, a, b: StretchList, writeA, writeB:
BOOLEAN]
RETURNS [cell: Cell] =
BEGIN
Add:
PROC [old, sep, nu1, nu2, nu3:
ROPE ←
NIL]
RETURNS [new:
ROPE] =
BEGIN
new ← old.Cat[IF old.Length[] > 0 THEN sep ELSE "", nu1, nu2, nu3];
END;
Hello:
PROC [stretch: Stretch, side: Side]
RETURNS [length:
INTEGER] =
{oside: Side ← IF side = A THEN B ELSE A;
bits: INTEGER ← stretch.node.type.procs.Bits[stretch.node.type];
words: INTEGER ← (bits + 15)/16;
portName:
ROPE ←
IO.PutFR["%g%g",
IO.rope[SELECT side FROM A => "A", B => "B", ENDCASE => ERROR],
IO.int[portCount[side]]];
fieldOff: INTEGER ← 0;
rawLength: INTEGER ← 1;
IF NOT IsSwitchType[stretch.node.type] THEN ERROR;
WITH stretch
SELECT
FROM
ss: SubStretch =>
BEGIN
WITH stretch.node.type
SELECT
FROM
ant: ArrayNodeType =>
BEGIN
IF ss.first < ant.first OR ss.last > ant.last THEN ERROR;
fieldOff ← ss.first - ant.first;
rawLength ← 1 + ant.last - ant.first;
END;
ant: AtomNodeType => ERROR;
ENDCASE => ERROR;
length ← 1 + ss.last - ss.first;
END;
ss: SingleStretch => length ← 1;
ENDCASE => ERROR;
connections ← Add[connections, ", ", portName, ":", stretch.node.name];
instanceNames[side] ← Add[instanceNames[side], ",", stretch.node.name];
classNames[side] ← Add[classNames[side], ",", stretch.node.type.procs.UserDescription[stretch.node.type]];
wordOffset[side] ← nextWordOffset;
nextWordOffset ← nextWordOffset + words;
portList ←
CONS[
[nextPort,
[wordOffset[side], words, portName, stretch.node.type, write[oside], write[side]]],
portList];
fieldOffset[side] ← ((switchValsPerWord - (rawLength MOD switchValsPerWord)) MOD switchValsPerWord) + fieldOff;
curPort[side] ← nextPort;
portCount[side] ← portCount[side] + 1;
nextPort ← nextPort + 1;
};
sjd: SplitJoinData ← NEW [SplitJoinDataRep ← []];
connections: ROPE;
instanceNames, classNames: ARRAY Side OF ROPE ← ALL[NIL];
wordOffset, fieldOffset, curPort, portCount: ARRAY Side OF INTEGER ← ALL[0];
nextWordOffset: INTEGER ← 1;
nextPort: INTEGER ← 0;
write: ARRAY Side OF BOOLEAN = [writeA, writeB];
portList: NumberedPortList;
aList, bList: StretchList;
aLength, bLength: INTEGER ← 0;
sjd.direction ←
IF writeA
THEN (IF writeB THEN both ELSE toA)
ELSE (IF writeB THEN toB ELSE ERROR);
aLength ← Hello[(aList ← a).first, A];
bLength← Hello[(bList ← b).first, B];
DO
length: INTEGER ← MIN[aLength, bLength];
sjd.parts ←
CONS[
[
aWordOffset: wordOffset[A], aFieldOffset: fieldOffset[A],
bWordOffset: wordOffset[B], bFieldOffset: fieldOffset[B],
length: length,
ports: [curPort[A], curPort[B]]],
sjd.parts];
fieldOffset[A] ← fieldOffset[A] + length;
fieldOffset[B] ← fieldOffset[B] + length;
IF (aLength ← aLength - length) = 0 THEN aList ← aList.rest;
IF (bLength ← bLength - length) = 0 THEN bList ← bList.rest;
IF (aList = NIL) # (bList = NIL) THEN ERROR;
IF aList = NIL THEN EXIT;
IF aLength = 0 THEN aLength ← Hello[aList.first, A];
IF bLength = 0 THEN bLength ← Hello[bList.first, B];
ENDLOOP;
sjd.words ← nextWordOffset - 1;
cell ← RoseCreate.CreateCell[
within: within,
instanceName:
IO.PutFR[
"[%g]-[%g]",
IO.rope[instanceNames[A]],
IO.rope[instanceNames[B]]],
className: EnsureSplitJoin[
portList,
nextPort,
IO.PutFR["SwitchSplitter[%g]%g-%g[%g]",
IO.rope[classNames[A]],
IO.rope[IF writeA THEN "<" ELSE ""],
IO.rope[IF writeB THEN ">" ELSE ""],
IO.rope[classNames[B]]]].name,
interfaceNodes: connections,
initData: sjd];
END;
IsSwitchType:
PUBLIC
PROC [nt: NodeType]
RETURNS [switchy:
BOOLEAN] = {
WITH nt
SELECT
FROM
ant: ArrayNodeType => switchy ← IsSwitchType[ant.element];
ant: AtomNodeType => switchy ← ant = bitType;
ENDCASE => ERROR};
SplitJoinDataList: TYPE = LIST OF SplitJoinDataRep;
SplitJoinData: TYPE = REF SplitJoinDataRep;
SplitJoinDataRep:
TYPE =
RECORD [
parts: PartList ← NIL,
words: INTEGER ← 0,
direction: Direction ← toB];
Direction: TYPE = {toA, toB, both};
PartList: TYPE = LIST OF Part;
Part:
TYPE =
RECORD [
aWordOffset, bWordOffset, aFieldOffset, bFieldOffset, length: INTEGER,
ports: ARRAY Side OF CARDINAL
];
splitters: LIST OF CellClass ← NIL;
EnsureSplitJoin:
PROC [portList: NumberedPortList, portCount:
CARDINAL, className:
ROPE]
RETURNS [class: CellClass] =
BEGIN
ports: Ports;
pl: NumberedPortList;
FOR cl:
LIST
OF CellClass ← splitters, cl.rest
WHILE cl #
NIL
DO
i: CARDINAL;
class ← cl.first;
IF class.ports.length # portCount THEN LOOP;
pl ← portList;
FOR i
IN [0 .. portCount)
DO
IF pl.first.port # class.ports[pl.first.index] THEN EXIT;
pl ← pl.rest;
ENDLOOP;
IF i < portCount THEN LOOP;
IF pl # NIL THEN ERROR;
RETURN;
ENDLOOP;
ports ← NEW [PortsRep[portCount]];
pl ← portList;
FOR i:
CARDINAL
IN [0 .. portCount)
DO
ports[pl.first.index] ← pl.first.port;
pl ← pl.rest;
ENDLOOP;
class ← RoseCreate.RegisterCellClass[
className: className,
ioCreator: CreateSplitterIO,
initializer: InitializeSplitter,
evals: [
--should be spurrious: ValsChanged: SplitterValsChanged,--
PropQ: SplitterPropQ,
PropUD: SplitterPropUD,
FindVicinity: SplitterFindVicinity],
ports: ports];
splitters ← CONS[class, splitters];
END;
Words: TYPE = REF WordsRep;
WordsRep: TYPE = RECORD [words: SEQUENCE length: CARDINAL OF CARDINAL];
CreateSplitterIO: IOCreator
--PROC [cell: Cell, initData: REF ANY]-- =
BEGIN
sjd: SplitJoinData ← NARROW[initData];
cell.realCellStuff.switchIO ← NEW [WordsRep[sjd.words]];
cell.realCellStuff.newIO ← NEW [WordsRep[sjd.words]];
cell.realCellStuff.oldIO ← NEW [WordsRep[sjd.words]];
END;
InitializeSplitter: Initializer--PROCEDURE [cell: Cell, initData: REF ANY, leafily: BOOLEAN]-- = {cell.realCellStuff.state ← initData};
SplitterPropQ: CellProc
--PROC [cell: Cell]-- =
TRUSTED
BEGIN
sjd: SplitJoinData ← NARROW[cell.realCellStuff.state];
a, b: Switches;
FOR pl: PartList ← sjd.parts, pl.rest
WHILE pl #
NIL
DO
p: Part ← pl.first;
a ← LOOPHOLE[cell.realCellStuff.switchIOAsWP + p.aWordOffset];
b ← LOOPHOLE[cell.realCellStuff.switchIOAsWP + p.bWordOffset];
IF sjd.direction # toB
THEN
FOR i:
INTEGER
IN [0 .. p.length)
DO
a[p.aFieldOffset+i].s[q] ← MAX[a[p.aFieldOffset+i].s[q], b[p.bFieldOffset+i].s[q]]
ENDLOOP;
IF sjd.direction # toA
THEN
FOR i:
INTEGER
IN [0 .. p.length)
DO
b[p.bFieldOffset+i].s[q] ← MAX[a[p.aFieldOffset+i].s[q], b[p.bFieldOffset+i].s[q]]
ENDLOOP;
ENDLOOP;
END;
SplitterPropUD: CellProc
--PROC [cell: Cell]-- =
TRUSTED
BEGIN
sjd: SplitJoinData ← NARROW[cell.realCellStuff.state];
a, b: Switches;
FOR pl: PartList ← sjd.parts, pl.rest
WHILE pl #
NIL
DO
p: Part ← pl.first;
a ← LOOPHOLE[cell.realCellStuff.switchIOAsWP + p.aWordOffset];
b ← LOOPHOLE[cell.realCellStuff.switchIOAsWP + p.bWordOffset];
IF sjd.direction # toB
THEN
FOR i:
INTEGER
IN [0 .. p.length)
DO
a[p.aFieldOffset+i].s[u] ← MAX[a[p.aFieldOffset+i].s[u], b[p.bFieldOffset+i].s[u]];
a[p.aFieldOffset+i].s[d] ← MAX[a[p.aFieldOffset+i].s[d], b[p.bFieldOffset+i].s[d]];
ENDLOOP;
IF sjd.direction # toA
THEN
FOR i:
INTEGER
IN [0 .. p.length)
DO
b[p.bFieldOffset+i].s[u] ← MAX[a[p.aFieldOffset+i].s[u], b[p.bFieldOffset+i].s[u]];
b[p.bFieldOffset+i].s[d] ← MAX[a[p.aFieldOffset+i].s[d], b[p.bFieldOffset+i].s[d]];
ENDLOOP;
ENDLOOP;
END;
SplitterFindVicinity:
PROC [cell: Cell, index:
CARDINAL] =
BEGIN
sjd: SplitJoinData ← NARROW[cell.realCellStuff.state];
IF index = noPort THEN RETURN;
FOR pl: PartList ← sjd.parts, pl.rest
WHILE pl #
NIL
DO
IF pl.first.ports[A] = index AND sjd.direction # toA THEN RoseRun.FindExteriorVicinity[cell, pl.first.ports[B]];
IF pl.first.ports[B] = index AND sjd.direction # toB THEN RoseRun.FindExteriorVicinity[cell, pl.first.ports[A]];
ENDLOOP;
END;
SplitterValsChanged: CellProc--PROC [cell: Cell]-- =
BEGIN
sjd: SplitJoinData ← NARROW[cell.realCellStuff.state];
IF sjd.direction # toSub THEN RoseRun.PerturbPort[cell, 0];
IF sjd.direction # fromSub THEN RoseRun.PerturbPort[cell, 1];
END;
END.