DIRECTORY
Arbiter, BitOps, CedarProcess, Core, CoreFlat, CoreProperties, IO, Ports, Rosemary, RosemaryUser;

ArbSysTests: CEDAR PROGRAM
IMPORTS BitOps, CedarProcess, CoreFlat, CoreProperties, IO, Ports, Rosemary, RosemaryUser
=
BEGIN OPEN Arbiter;

State: TYPE = REF StateRec _ NIL;
StateRec: TYPE = RECORD [
tester: RosemaryUser.Tester _ NIL,
simulation: Rosemary.Simulation _ NIL,
cellType: Core.CellType _ NIL,
p: Ports.Port _ NIL,
eval: PROC [memory: BOOL _ TRUE] _ NIL,
nDReqs, nDGrants, nBDHis, nBDLongs, nArbReqs,
DBus, DPriorities, ArbNos, Rsts, nDStops, SlotNos, DHybridSels, DBdSels,
nDynaBusBusy, nHolding, Ck: NAT _ 0,
arbs: ARRAY Arbiters OF REF _ ALL[NIL],
devs: ARRAY Arbiters OF ARRAY Devices OF REF _ ALL[ALL[NIL]]
];

lastState: State _ NIL;

GetAllState: PROC [cellType: Core.CellType, p: Ports.Port, eval: PROC [memory: BOOL _ TRUE]] RETURNS [ st: State ] = {

GetState: PROC [ instName: IO.ROPE ] RETURNS [ ref: REF ] = {
ref _ Rosemary.GetState[
st.tester.display.simulation,
NEW[CoreFlat.FlatCellTypeRec _
CoreFlat.ParseCellTypePath[st.cellType, instName]]
];
};

lastState _ st _ NEW[StateRec _ [
tester: NARROW[CoreProperties.GetProp[cellType.properties, $Tester]]
]];

st.simulation _ st.tester.display.simulation;
st.cellType _ st.tester.display.cellType;
st.p _ p;
TRUSTED { st.eval _ eval };

[st.nDReqs, st.nDGrants, st.nBDHis, st.nBDLongs, st.nArbReqs] _
Ports.PortIndexes[st.cellType.public, "nDReqs", "nDGrants", "nBDHis", "nBDLongs", "nArbReqs"];
[st.DBus, st.DPriorities, st.ArbNos, st.Rsts] _ Ports.PortIndexes[st.cellType.public, "DBus", "DPriorities", "ArbNos", "Rsts"];
[st.nDStops, st.SlotNos, st.DHybridSels, st.DBdSels] _
Ports.PortIndexes[st.cellType.public, "nDStops", "SlotNos", "DHybridSels", "DBdSels"];
[st.nDynaBusBusy, st.nHolding, st.Ck] _
Ports.PortIndexes[st.cellType.public, "nDynaBusBusy", "nHolding", "Ck"];


FOR a: Arbiters IN Arbiters DO
FOR d: Devices IN Devices DO
st.devs[a][d] _ GetState[IO.PutFR["/Arb%dReq%d", IO.int[a], IO.int[d]]];
ENDLOOP;
ENDLOOP;
};


WhoAmI: PROC [ ref: REF ] RETURNS [ name: IO.ROPE ] = {
FOR a: Arbiters IN Arbiters DO
IF ref = lastState.arbs[a] THEN RETURN[IO.PutFR["Arbiter %d", IO.int[a]]];
FOR d: Devices IN Devices DO
IF ref = lastState.devs[a][d] THEN RETURN[IO.PutFR["Device %d of arbiter %d", IO.int[d], IO.int[a]]];
ENDLOOP;
ENDLOOP;
name _ "Darned if I know!"
};


RunTest: PROC [ st: State, initializeAll: BOOL _ FALSE ] = {

Eval: PROC = {
st.eval[];
};

EvalIgnoreX: PROC = {
Eval[ ! Rosemary.Stop => IF reason = $BoolWireHasX THEN RESUME ELSE REJECT ];
};


ReallyRunTest: PROC = {

DoClk: PROC [ cycles: INT _ 1 ] = {
FOR i: INT IN [0..cycles) DO
st.p[st.Ck].b _ FALSE;
Eval[];
st.p[st.Ck].b _ TRUE;
Eval[];
ENDLOOP;
};


DoClkIgnoreX: PROC [ cycles: INT _ 1 ] = {
FOR i: INT IN [0..cycles) DO
st.p[st.Ck].b _ FALSE;
EvalIgnoreX[];
st.p[st.Ck].b _ TRUE;
EvalIgnoreX[];
ENDLOOP;
};

DAShift: PROC [ val: BitOps.BitWord ] = {
st.p[st.DBus][DAddress].b _ TRUE;
EvalIgnoreX[];
DDShift[16, val];
st.p[st.DBus][DAddress].b _ FALSE;
EvalIgnoreX[];
};

DDShift: PROC [ size: [1..16], val: BitOps.BitWord ] = {
FOR i: NAT IN [0..size) DO
st.p[st.DBus][DSerialIn].b _ BitOps.EBFW[val, i, size];
st.p[st.DBus][DShiftCK].b _ FALSE;
EvalIgnoreX[];
st.p[st.DBus][DShiftCK].b _ TRUE;
EvalIgnoreX[];
ENDLOOP;
};

DDShiftCheck: PROC [ size: [1..16], valIn: BitOps.BitWord, valOut: BitOps.BitWord ] = {
FOR i: NAT IN [0..size) DO
st.p[st.DBus][DSerialIn].b _ BitOps.EBFW[valIn, i, size];
st.p[st.DBus][DShiftCK].b _ FALSE;
st.p[st.DBus][DSerialOut].b _ BitOps.EBFW[valOut, i, size];
st.p[st.DBus][DSerialOut].d _ expect;
EvalIgnoreX[];
st.p[st.DBus][DSerialOut].d _ none;
st.p[st.DBus][DShiftCK].b _ TRUE;
EvalIgnoreX[];
ENDLOOP;
};

useDBus: BOOL _ NARROW[CoreProperties.GetProp[st.cellType.properties, $UseDBus], REF BOOL]^;

FOR i: NAT IN (DSerialOut..DShiftCK] DO
st.p[st.DBus][i].d _ drive;
ENDLOOP;
st.p[st.DBus][DSerialOut].d _ none;
FOR a: Arbiters IN Arbiters DO
st.p[st.SlotNos][a].c _ 8H+a;
ENDLOOP;
st.p[st.DBus][DExecute].b _ FALSE;
st.p[st.DBus][nDFreeze].b _ TRUE;
st.p[st.DBus][nDReset].b _ FALSE;
st.p[st.DBus][DSerialIn].b _ FALSE;
st.p[st.DBus][DShiftCK].b _ FALSE;
st.p[st.DBus][DAddress].b _ FALSE;
st.p[st.DBus][DSerialOut].b _ TRUE;
st.p[st.DBus][DSerialOut].d _ force; -- very weak
st.p[st.nDStops][0][0].b _ NOT TRUE; -- assert Stop
st.p[st.nDStops][0][0].d _ drive;
IF NOT useDBus THEN
FOR a: Arbiters IN Arbiters DO
st.p[st.Rsts][a].b _ TRUE;
st.p[st.Rsts][a].d _ drive;
ENDLOOP;
DoClkIgnoreX[6]; -- allow some X's to relax out
st.p[st.nDStops][0][0].d _ none; -- release Stop while holding Reset
st.p[st.DBus][DShiftCK].b _ TRUE;
DoClkIgnoreX[6]; -- allow more X's to relax out

IF useDBus THEN {
FOR a: Arbiters IN Arbiters DO
IF a=0 OR initializeAll THEN {
DAShift[08000H+1000H*a]; -- check arbiter signature
DDShiftCheck[16, 0, 5041H];
};
DAShift[08000H+1000H*a+2]; -- load arbiter number
DDShift[3, a];
IF a=0 OR initializeAll THEN {
DDShiftCheck[3, a, a];
DAShift[08000H+1000H*a+1];
FOR d: Devices IN Devices DO
DDShift[9, (IF d MOD 2 = 0 THEN 71H ELSE 22H)];
ENDLOOP;

DAShift[08000H+1000H*a+100H]; -- select a non-arbiter device
DDShift[1, 0]; -- load BdVersion shadow
DAShift[08000H+1000H*a+3H]; -- read the board version
DDShiftCheck[2, 0, 2];
};
ENDLOOP;
}
ELSE {
FOR a: Arbiters IN Arbiters DO
st.p[st.ArbNos][a].c _ a;
st.p[st.ArbNos][a].d _ drive;
FOR d: Devices IN Devices DO
st.p[st.DPriorities][a][d].c _ (IF d MOD 2 = 0 THEN 71H ELSE 22H);
st.p[st.DPriorities][a][d].d _ drive;
ENDLOOP;
FOR i: INT IN [0..15) DO
st.p[st.DHybridSels][a][i].b _ FALSE;
st.p[st.DHybridSels][a][i].d _ drive;
ENDLOOP;
st.p[st.DBdSels][a].b _ FALSE;
st.p[st.DBdSels][a].d _ drive;
ENDLOOP;
};

DoClkIgnoreX[6]; -- allow final X's to relax out
DoClk[1]; -- see if any X's left
st.p[st.nDStops][0][0].b _ NOT TRUE; -- assert Stop
st.p[st.nDStops][0][0].d _ drive;
st.p[st.nDynaBusBusy].b _ NOT TRUE; -- make sure no starvation errors are reported yet
st.p[st.nDynaBusBusy].d _ drive;
DoClk[5];
st.p[st.DBus][nDReset].b _ TRUE; -- release Reset
st.p[st.DBus][nDFreeze].b _ TRUE; -- release Freeze, whatever that means
DoClk[2];
IF NOT useDBus THEN
FOR a: Arbiters IN Arbiters DO
st.p[st.Rsts][a].b _ FALSE;
ENDLOOP;
DoClk[3];
st.p[st.nDStops][0][0].d _ none; -- release Stop
DoClk[15];
st.p[st.nDynaBusBusy].d _ none; -- allow starvation errors
DoClk[100000];
};

CedarProcess.DoWithPriority[priority: background, action: ReallyRunTest];
};


simHighProb: REF ProbabilitiesRec _ NEW[ProbabilitiesRec _ []];
simMediumProb: REF ProbabilitiesRec _ NEW[ProbabilitiesRec _ []];
simLowProb: REF ProbabilitiesRec _ NEW[ProbabilitiesRec _ []];

normalProb: ProbabilitiesRec _ [request: ALL[400], hold: 1000];
zeroProb: ProbabilitiesRec _ [request: ALL[10000000], hold: 10000000];
higherProb: ProbabilitiesRec _ [request: ALL[30], hold: 100];
evenHigherProb: ProbabilitiesRec _ [request: ALL[10], hold: 100];
userProb: ProbabilitiesRec _ normalProb;


GeneralArbSysTest: PROC [cellType: Core.CellType, p: Ports.Port, Eval: PROC [memory: BOOL _ TRUE], high, med, low: ProbabilitiesRec] = {

st: State = GetAllState[cellType, p, Eval];

FOR a: Arbiters IN Arbiters DO
FOR d: Devices IN Devices DO
rs: REF RequesterStateRec = NARROW[st.devs[a][d]];
rs.probs _ (SELECT TRUE FROM
(a = 0) AND (d = 0) => simHighProb,
(a = 0) => simMediumProb,
ENDCASE => simLowProb);
ENDLOOP;
ENDLOOP;

simHighProb^ _ high;
simMediumProb^ _ med;
simLowProb^ _ low;
RunTest[st, TRUE];
};


FullArbSysTest: PROC [cellType: Core.CellType, p: Ports.Port, Eval: PROC [memory: BOOL _ TRUE]] -- RosemaryUser.TestProc --  = {
GeneralArbSysTest[cellType, p, Eval, normalProb, normalProb, normalProb];
};

SingleArbiterTest: PROC [cellType: Core.CellType, p: Ports.Port, Eval: PROC [memory: BOOL _ TRUE]] -- RosemaryUser.TestProc --  = {
GeneralArbSysTest[cellType, p, Eval, higherProb, higherProb, zeroProb];
};

SingleRequesterTest: PROC [cellType: Core.CellType, p: Ports.Port, Eval: PROC [memory: BOOL _ TRUE]] -- RosemaryUser.TestProc --  = {
GeneralArbSysTest[cellType, p, Eval, evenHigherProb, zeroProb, zeroProb];

};


RosemaryUser.RegisterTestProc["FullArbSysTest", FullArbSysTest];
RosemaryUser.RegisterTestProc["SingleArbiterTest", SingleArbiterTest];
RosemaryUser.RegisterTestProc["SingleRequesterTest", SingleRequesterTest];
END.




ArbSysTests.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
E. McCreight, May 15, 1987 4:28:01 pm PDT
..indexes in cellType.public
st.arbs[a] _ GetState[IO.PutFR["/Arb%d/ArbiterTop", IO.int[a]]];
-- until I figure out how to do this ....
�Ê
ᘚ
œ™Jš
œ<™<Jš
œ)™)J˜—š
Ïk	˜	Jšœ?�œ ˜aJ˜—šÏnœ�œ
�˜Jš�œ1�œ˜YJ˜
Jš�œ
�œ	˜J˜Jšœ�œ�œ�œ
˜!šœ
�œ�œ˜Jšœ�œ
˜"Jšœ"�œ
˜&Jšœ�œ
˜Jšœ�œ
˜Jš	œ�œ
�œ�œ�œ
˜'š
œ-˜-Jš
œH˜HJšœžœ�œ˜$Jš
œ™—Jšœ�œ
�œ
�œ�œ
�œ˜'Jšœ�œ
�œ
�œ	�œ
�œ�œ
�œ
�œ˜<J˜J˜—šœ�œ
˜J˜—Jšžœ�œ0�œ
�œ�œ�œ˜v˜šžœ�œ
�œ
�œ�œ�œ˜=˜J˜š�œ˜J˜2—J˜—J˜J˜—šœ�œ
˜!Jšœ�œ6˜DJ˜—J˜J˜-J˜)J˜	Jš�œ˜J˜š
œ?˜?Jš
œ^˜^—Jš
œ˜š
œ6˜6Jš
œV˜V—š
œ'˜'Jš
œH˜H—˜J˜—š�œ
�œ
�˜šœ�œ�œ
™@Jš
Ïc)™)—š�œ�œ	�˜Jšœ�œ�œ	�œ
˜HJš�œ
˜—Jš�œ
˜—J˜J˜J˜—šžœ�œ�œ�œ	�œ
�œ˜7š�œ
�œ
�˜Jš
�œ�œ
�œ
�œ�œ
˜Jš�œ�œ	�˜Jš�œ�œ
�œ
�œ"�œ	�œ
˜eJš�œ
˜—Jš�œ
˜—J˜J˜J˜J˜—šžœ�œ�œ�œ˜<J˜šžœ�œ˜Jš
œ
˜
Jš
œ˜—J˜šžœ�œ˜Jšœ�œ�œ
�œ
�œ
�œ˜MJš
œ˜J˜J˜—šž
œ�œ˜J˜šžœ�œ�œ
˜#š�œ�œ
�œ
�˜Jšœ�œ
˜Jš
œ˜Jšœ�œ
˜Jš
œ˜Jš�œ
˜—J˜J˜J˜—šžœ�œ�œ
˜*š�œ�œ
�œ
�˜Jšœ�œ
˜Jš
œ˜Jšœ�œ
˜Jš
œ˜Jš�œ
˜—J˜J˜—šžœ�œ˜)Jšœ�œ
˜!Jš
œ˜Jš
œ˜Jšœ�œ
˜"Jš
œ˜Jš
œ˜J˜—šžœ�œ+˜8š�œ�œ
�œ�˜Jšœ$�œ˜7Jšœ�œ
˜"Jš
œ˜Jšœ�œ
˜!Jš
œ˜Jš�œ
˜—J˜J˜—šžœ�œE˜Wš�œ�œ
�œ�˜Jšœ$�œ˜9Jšœ�œ
˜"Jšœ%�œ˜;Jš
œ%˜%Jš
œ˜Jš
œ#˜#Jšœ�œ
˜!Jš
œ˜Jš�œ
˜—J˜J˜—Jš	œ	�œ�œ;�œ
�œ˜\J˜š�œ�œ
�œ�˜'Jš
œ˜Jš�œ
˜—Jš
œ#˜#š�œ
�œ
�˜Jš
œ˜Jš�œ
˜—Jšœ�œ
˜"Jšœ�œ
˜!Jšœ�œ
˜!Jšœ�œ
˜#Jšœ�œ
˜"Jšœ�œ
˜"Jšœ�œ
˜#Jšœ%Ÿ˜1Jšœ�œ
�œŸ˜3Jš
œ!˜!š�œ
�œ	�˜š�œ
�œ
�˜Jšœ�œ
˜Jš
œ˜Jš�œ
˜——JšœŸ˜/Jšœ!Ÿ#˜DJšœ�œ
˜!JšœŸ˜/J˜š�œ	�œ˜š�œ
�œ
�˜š�œ�œ�œ˜JšœŸ˜3Jš
œ˜Jš
œ˜—JšœŸ˜1Jš
œ˜š�œ�œ�œ˜Jš
œ˜Jš
œ˜š�œ�œ	�˜Jš	œ�œ�œ�œ�œ˜/Jš�œ
˜—J˜JšœŸ˜<JšœŸ˜'JšœŸ˜5Jš
œ˜J˜—Jš�œ
˜—J˜
—š�œ˜š�œ
�œ
�˜Jš
œ˜Jš
œ˜š�œ�œ	�˜Jš	œ �œ�œ�œ�œ˜BJš
œ%˜%Jš�œ
˜—š�œ�œ
�œ	�˜Jšœ�œ
˜%Jš
œ%˜%Jš�œ
˜—Jšœ�œ
˜Jš
œ˜Jš�œ
˜—J˜—J˜JšœŸ˜0Jšœ
Ÿ˜ Jšœ�œ
�œŸ˜3Jš
œ!˜!Jšœ�œ
�œŸ2˜VJš
œ ˜ Jš
œ	˜	Jšœ�œŸ˜1Jšœ�œŸ&˜HJš
œ	˜	š�œ
�œ	�˜š�œ
�œ
�˜Jšœ�œ
˜Jš�œ
˜——Jš
œ	˜	Jšœ!Ÿ˜0J˜
Jšœ Ÿ˜:Jš
œ˜J˜J˜—J˜IJ˜J˜J˜—Jšœ
�œ�œ˜?Jšœ�œ�œ˜AJšœ�œ�œ˜>J˜Jšœ)�œ˜?Jšœ'�œ˜FJšœ)�œ˜=Jšœ-�œ˜AJš
œ(˜(J˜J˜šžœ�œ*žœ�œ
�œ�œ(˜ˆ
J˜Jš
œ+˜+J˜š�œ
�œ
�˜š�œ�œ	�˜Jšœ�œ�œ˜2šœ�œ
�œ
�˜Jšœ�œ˜#Jš
œ˜Jš�œ˜—Jš�œ
˜—Jš�œ
˜—J˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ˜J˜J˜J˜—šžœ�œ*žœ�œ
�œ�œŸœ˜€
Jš
œI˜IJ˜J˜—šžœ�œ*žœ�œ
�œ�œŸœ˜ƒ
Jš
œG˜GJ˜J˜—šžœ�œ*žœ�œ
�œ�œŸœ˜…
Jš
œI˜IJ˜J˜J˜—J˜J˜@J˜FJ˜JJš�œ
˜—J˜J˜J˜—…— z,a