-- Copyright (C) 1983, 1985 by Xerox Corporation. All rights reserved.
-- BSPTestTool.mesa, HGM, 25-Jun-85 3:14:48
-- Please don't forget to update the herald....
DIRECTORY
FormSW USING [
ClientItemsProcType, ProcType, AllocateItemDescriptor, newLine, Display,
FindItem, CommandItem, BooleanItem, StringItem, NumberItem],
Heap USING [systemZone],
MsgSW USING [Post],
Process USING [Detach, Yield],
Put USING [Char, CR, Text, Line, LongDecimal],
String USING [AppendString],
System USING [Pulses, GetClockPulses, PulsesToMicroseconds],
Time USING [AppendCurrent, Current],
Tool USING [Create, MakeSWsProc, MakeMsgSW, MakeFormSW, MakeFileSW],
ToolWindow USING [TransitionProcType],
Window USING [Handle],
Stream USING [Handle, PutWord, PutBlock, SendNow, Delete],
PupDefs USING [
AppendPupAddress, GetPupAddress, PupNameTrouble, PupPackageMake,
PupPackageDestroy, SecondsToTocks],
PupStream USING [PupByteStreamCreate, StreamClosing, CloseReason],
PupTypes USING [PupAddress, bspTestSoc];
BSPTestTool: PROGRAM
IMPORTS
FormSW, Heap, MsgSW, Process, Put, String, System, Time, Tool, Stream,
PupDefs, PupStream =
BEGIN OPEN PupStream, PupTypes;
z: UNCOUNTED ZONE = Heap.systemZone;
defualtClumpLength: CARDINAL = 1000; -- words
defualtNumberOfClumps: CARDINAL = 1000; -- 1 mega word
msg, form, log: Window.Handle;
-- Be sure to initialize it when it is allocated!!!!
data: LONG POINTER TO Data ← NIL; -- NIL when we are inactive
Data: TYPE = RECORD [
where: PupAddress ← [[0], [0], PupTypes.bspTestSoc],
clumpLength: CARDINAL ← defualtClumpLength,
numberOfClumps: CARDINAL ← defualtNumberOfClumps,
pleaseStop: BOOLEAN ← FALSE,
alignTheFink0: WORD ← NULL,
running: BOOLEAN ← FALSE,
alignTheFink1: WORD ← NULL,
verbose: BOOLEAN ← FALSE,
alignTheFink2: WORD ← NULL,
sendForever: BOOLEAN ← FALSE,
alignTheFink3: WORD ← NULL,
forceOutClumps: BOOLEAN ← FALSE,
alignTheFink4: WORD ← NULL,
sendFirstWord: BOOLEAN ← FALSE,
target: LONG STRING ← NULL];
Init: PROCEDURE =
BEGIN
herald: STRING = "BSP Tester of 25-Jun-85 3:14:43"L;
[] ← Tool.Create[
name: herald, makeSWsProc: MakeSWs, clientTransition: ClientTransition];
END;
BSPTestOn: PROCEDURE =
BEGIN
WriteCR[];
IF data.clumpLength ~IN [2..10000) THEN
BEGIN
MsgSW.Post[msg, "ClumpLength should be between 2 and 10000."L];
RETURN;
END;
WriteCurrentDateAndTime[];
WriteString[" Sending to "L];
IF ~FindPath[] THEN RETURN;
data.running ← TRUE;
UpdatePicture[];
Process.Detach[FORK Push[]];
END;
BSPTestOff: PROCEDURE =
BEGIN
data.pleaseStop ← TRUE;
WHILE data.running DO Process.Yield[]; ENDLOOP;
data.pleaseStop ← FALSE;
UpdatePicture[];
END;
Finished: PROCEDURE =
BEGIN data.running ← FALSE; IF ~data.pleaseStop THEN UpdatePicture[]; END;
UpdatePicture: PROCEDURE =
BEGIN
FormSW.FindItem[form, startIX].flags.invisible ← data.running;
FormSW.FindItem[form, stopIX].flags.invisible ← ~data.running;
FormSW.FindItem[form, clumpIX].flags.readOnly ← data.running;
FormSW.Display[form];
END;
FindPath: PROCEDURE RETURNS [BOOLEAN] =
BEGIN OPEN data;
WriteString[target];
WriteChar['=];
PupDefs.GetPupAddress[
@where, target !
PupDefs.PupNameTrouble =>
BEGIN MsgSW.Post[msg, e]; WriteLine[e]; GOTO Trouble; END];
PrintPupAddress[where];
WriteLine["."L];
RETURN[TRUE];
EXITS Trouble => RETURN[FALSE];
END;
Push: PROCEDURE =
BEGIN OPEN data;
sh: Stream.Handle;
start, stop: LONG CARDINAL;
words: LONG CARDINAL ← 0;
recent: System.Pulses;
startOpen, endOpen, startFirstSend, endFirstSend, startClose, endClose:
System.Pulses;
Buffer: TYPE = RECORD [SEQUENCE COMPUTED CARDINAL OF CARDINAL];
buffer: LONG POINTER;
hits: CARDINAL ← 0;
info: ARRAY CloseReason OF STRING = [
localClose: "Closed locally"L, localAbort: "Local Abort"L,
remoteClose: "Remote close"L, noRouteToNetwork: "No route to that network"L,
transmissionTimeout: "Transmission timeout"L,
remoteReject: "Remote reject"L];
WriteString["Clump size is "L];
WriteLongDecimal[clumpLength];
WriteLine[" words."L];
start ← Time.Current[];
startOpen ← System.GetClockPulses[];
sh ← PupByteStreamCreate[
where, PupDefs.SecondsToTocks[10] !
StreamClosing =>
BEGIN
WriteString["Connection failed: "L];
IF text # NIL THEN
BEGIN WriteChar['(]; WriteString[text]; WriteString[") "L]; END;
WriteLine[info[why]];
GOTO Failed;
END];
endOpen ← System.GetClockPulses[];
IF sendFirstWord THEN
BEGIN
ENABLE StreamClosing => CONTINUE;
startFirstSend ← System.GetClockPulses[];
Stream.PutWord[sh, 0];
words ← words + 1;
endFirstSend ← System.GetClockPulses[];
END;
recent ← System.GetClockPulses[];
buffer ← z.NEW[Buffer[clumpLength]];
FOR clumps: CARDINAL ← 0, clumps + 1 UNTIL pleaseStop
OR (~sendForever AND clumps >= data.numberOfClumps) DO
Stream.PutBlock[
sh, [buffer, 0, 2*clumpLength], forceOutClumps !
StreamClosing =>
BEGIN
WriteString["Push Stream closed: "L];
IF text # NIL THEN
BEGIN WriteChar['(]; WriteString[text]; WriteString[") "L]; END;
WriteLine[info[why]];
GOTO Closed;
END];
words ← words + clumpLength;
IF verbose THEN
BEGIN
WriteChar['!];
IF ((hits ← hits + 1) MOD 50) = 0 THEN
BEGIN
ms: LONG CARDINAL;
-- Oh shit. This overflows at a clumpLength of 20000 wrods.
fudge: LONG CARDINAL = 100*LONG[16*50];
ms ←
System.PulsesToMicroseconds[[System.GetClockPulses[] - recent]]/10000;
WriteString[" "L];
WriteLongDecimal[(fudge*clumpLength)/ms];
WriteLine[" bits/sec"L];
recent ← System.GetClockPulses[];
END;
END;
REPEAT Closed => NULL;
ENDLOOP;
startClose ← System.GetClockPulses[];
Stream.SendNow[sh ! StreamClosing => CONTINUE];
Stream.Delete[sh];
endClose ← System.GetClockPulses[];
stop ← Time.Current[];
z.FREE[@buffer];
WriteCR[];
WriteLongDecimal[words];
WriteLine[" words sent."L];
IF stop - start > 100 OR words > 100000 THEN
BEGIN WriteLongDecimal[16*words/(stop - start)]; END
ELSE
BEGIN
t: System.Pulses ← [endClose - startOpen];
WriteLongDecimal[16*words*1000/(System.PulsesToMicroseconds[t]/1000)];
END;
WriteLine[" data bits per second."L];
PrintTiming["Open"L, endOpen, startOpen];
IF sendFirstWord THEN PrintTiming["First Ack"L, endFirstSend, startFirstSend];
PrintTiming["Close"L, endClose, startClose];
IF words < 5000000 THEN PrintTiming["Total"L, endClose, startOpen];
WriteCR[];
Finished[];
EXITS Failed => Finished[];
END;
-- IO things
WriteChar: PROCEDURE [c: CHARACTER] = BEGIN Put.Char[log, c]; END;
WriteCR: PROCEDURE = BEGIN Put.CR[log]; END;
WriteString: PROCEDURE [s: LONG STRING] = BEGIN Put.Text[log, s]; END;
WriteLine: PROCEDURE [s: LONG STRING] = BEGIN Put.Line[log, s]; END;
WriteLongDecimal: PROCEDURE [n: LONG CARDINAL] =
BEGIN Put.LongDecimal[log, n]; END;
WriteCurrentDateAndTime: PROCEDURE =
BEGIN time: STRING = [20]; Time.AppendCurrent[time]; WriteString[time]; END;
PrintPupAddress: PROCEDURE [a: PupAddress] =
BEGIN
temp: STRING = [40];
PupDefs.AppendPupAddress[temp, a];
WriteString[temp];
END;
PrintTiming: PROCEDURE [s: LONG STRING, end, start: System.Pulses] =
BEGIN
t: System.Pulses ← [end - start];
WriteString[s];
WriteString[" took "L];
WriteLongDecimal[System.PulsesToMicroseconds[t]/1000];
WriteLine[" ms."L];
END;
Start: FormSW.ProcType = BEGIN BSPTestOn[]; END;
Stop: FormSW.ProcType = BEGIN BSPTestOff[]; END;
MakeSWs: Tool.MakeSWsProc =
BEGIN
msg ← Tool.MakeMsgSW[window: window, lines: 5];
form ← Tool.MakeFormSW[window: window, formProc: MakeForm];
log ← Tool.MakeFileSW[window: window, name: "BSPTest.log$"L, allowTypeIn: FALSE];
END;
startIX: CARDINAL = 0;
stopIX: CARDINAL = 1;
clumpIX: CARDINAL = 4;
MakeForm: FormSW.ClientItemsProcType =
BEGIN
nParams: CARDINAL = 10;
items ← FormSW.AllocateItemDescriptor[nParams];
items[0] ← FormSW.CommandItem[
tag: "Start"L, proc: Start, place: FormSW.newLine];
items[1] ← FormSW.CommandItem[
tag: "Stop"L, proc: Stop, place: FormSW.newLine, invisible: TRUE];
items[2] ← FormSW.BooleanItem[
tag: "Running"L, switch: @data.running, readOnly: TRUE];
items[3] ← FormSW.BooleanItem[tag: "Verbose"L, switch: @data.verbose];
items[4] ← FormSW.BooleanItem[tag: "SendForever"L, switch: @data.sendForever];
items[5] ← FormSW.BooleanItem[
tag: "SendFirstWord"L, switch: @data.sendFirstWord];
items[6] ← FormSW.BooleanItem[
tag: "ForceOutClumps"L, switch: @data.forceOutClumps];
items[7] ← FormSW.NumberItem[
tag: "ClumpLength"L, value: @data.clumpLength, place: FormSW.newLine];
items[8] ← FormSW.NumberItem[
tag: "NumberOfClumps"L, value: @data.numberOfClumps, place: FormSW.newLine];
items[9] ← FormSW.StringItem[
tag: "Target"L, string: @data.target, place: FormSW.newLine, inHeap: TRUE];
RETURN[items, TRUE];
END;
AlreadyActive: ERROR = CODE;
NotActive: ERROR = CODE;
ClientTransition: ToolWindow.TransitionProcType =
BEGIN
SELECT TRUE FROM
old = inactive =>
BEGIN
IF data # NIL THEN ERROR AlreadyActive;
data ← z.NEW[Data];
data↑ ← [];
data.target ← z.NEW[StringBody[20]];
String.AppendString[data.target, "ME"L];
[] ← PupDefs.PupPackageMake[];
END;
new = inactive =>
BEGIN
IF data = NIL THEN ERROR NotActive;
IF data.running THEN BSPTestOff[];
PupDefs.PupPackageDestroy[];
z.FREE[@data.target];
z.FREE[@data];
END;
ENDCASE;
END;
-- Main Body
Init[];
END.