-- Copyright (C) 1984, 1985 by Xerox Corporation. All rights reserved.
-- EchoTool.mesa, HGM, 5-Sep-85 18:23:20
-- Please don't forget to update the herald...
DIRECTORY
AddressTranslation USING [Error, PrintError, StringToNetworkAddress],
Buffer USING [NSBuffer],
Driver USING [GetDeviceChain, Network],
EthernetDriverFriends USING [EtherStatsInfo],
Format USING [HostNumber, NetworkAddress, NetworkNumber, StringProc],
FormSW USING [
AllocateItemDescriptor, BooleanItem, ClientItemsProcType, CommandItem,
ItemHandle, newLine, NumberItem, ProcType,
StringItem],
Heap USING [systemZone],
Inline USING [BITAND, BITNOT],
NSConstants USING [echoerSocket],
NSTypes USING [maxIDPDataWords],
PhoneNetFriends USING [PhoneNetInfo, StatsPtrToStats],
PhoneNetExtras USING [
leafBytesSend, leafDupsFiltered, leafPktsSend,
nsBytesSend, nsCongestion, nsDupsFiltered, nsTooGreedy,
pupBytesSend, pupCongestion, pupDupsFiltered, pupTooGreedy],
Protocol1 USING [GetContext],
PupRouterDefs USING [NetworkContext],
Process USING [Detach, Pause, Yield],
Put USING [Char, CR, Line, LongDecimal, Text],
RoutingTable USING [NetworkContext],
Socket USING [
ChannelHandle, Create, Delete,
GetPacket, GetPacketBytes, GetSendBuffer, GetSource, PutPacket,
ReturnBuffer, SetDestination, SetPacketWords, SetWaitTime, TimeOut],
String USING [AppendNumber, AppendLongNumber, AppendString],
SpecialSystem USING [GetProcessorID],
System USING [
GetClockPulses, GetGreenwichMeanTime, GreenwichMeanTime, HostNumber, localHostNumber,
NetworkAddress, NetworkNumber, nullHostNumber, nullSocketNumber,
Pulses, PulsesToMicroseconds, SocketNumber],
Time USING [AppendCurrent],
Tool USING [
Create, UnusedLogName, MakeFormSW, MakeFileSW, MakeSWsProc],
ToolWindow USING [TransitionProcType],
Unformat USING [Error, NetworkAddress],
UserInput USING [UserAbort],
Window USING [Handle];
EchoTool: PROGRAM
IMPORTS
Driver, Format, FormSW, Heap, Inline, PhoneNetFriends, Process, Protocol1, Put,
SpecialSystem, String, System, Time, Tool, UserInput, Unformat,
AddressTranslation, Socket
EXPORTS Buffer =
BEGIN
Network: PUBLIC TYPE = Driver.Network;
z: UNCOUNTED ZONE = Heap.systemZone;
-- global variable declarations
log, form: Window.Handle ← NIL;
thisMachineID, remoteAddress: LONG STRING ← NIL;
maxLength: CARDINAL ← NSTypes.maxIDPDataWords;
maxClumpSize: CARDINAL = 50;
clumpSize: CARDINAL ← 50;
running, pleaseStop: BOOLEAN ← FALSE;
fixedLength: BOOLEAN ← FALSE;
noBang, noLate, noLost: BOOLEAN ← FALSE;
checkIt: BOOLEAN ← TRUE;
timeout: CARDINAL ← 3000; -- ms
Init: PROCEDURE =
BEGIN
herald: STRING = "Echo Tool of 5-Sep-85 18:23:27"L;
[] ← Tool.Create[
name: herald, makeSWsProc: MakeThisTool, clientTransition: Transition];
END;
MakeThisTool: Tool.MakeSWsProc =
BEGIN
logFileName: STRING = [40];
form ← Tool.MakeFormSW[window: window, formProc: MakeItemArray];
Tool.UnusedLogName[logFileName, "EchoTool.log$"L];
log ← Tool.MakeFileSW[window: window, name: logFileName, allowTypeIn: FALSE];
END;
MakeItemArray: FormSW.ClientItemsProcType =
BEGIN
nItems: CARDINAL = 15;
i: INTEGER ← -1;
items ← FormSW.AllocateItemDescriptor[nItems];
items[i ← i + 1] ← FormSW.CommandItem[tag: "Stop"L, proc: Stop, place: FormSW.newLine];
items[i ← i + 1] ← FormSW.CommandItem[tag: "PokeOnce"L, proc: PokeOnce];
items[i ← i + 1] ← FormSW.CommandItem[tag: "Echo"L, proc: Echo];
items[i ← i + 1] ← FormSW.CommandItem[tag: "Clumps"L, proc: Clumps];
items[i ← i + 1] ← FormSW.BooleanItem[tag: "FixedLength"L, switch: @fixedLength];
items[i ← i + 1] ← FormSW.NumberItem[tag: "(Max)Length"L, value: @maxLength, boxWidth: 25];
items[i ← i + 1] ← FormSW.NumberItem[tag: "clumpSize"L, value: @clumpSize];
items[i ← i + 1] ← FormSW.CommandItem[tag: "Stats"L, proc: Stats, place: FormSW.newLine];
items[i ← i + 1] ← FormSW.StringItem[
tag: "ThisMachineID"L, string: @thisMachineID, readOnly: TRUE, boxWidth: 100];
items[i ← i + 1] ← FormSW.StringItem[
tag: "RemoteAddress"L, string: @remoteAddress, inHeap: TRUE, boxWidth: 150];
items[i ← i + 1] ← FormSW.BooleanItem[
tag: "CheckIt"L, switch: @checkIt, place: FormSW.newLine];
items[i ← i + 1] ← FormSW.BooleanItem[tag: "!-Off"L, switch: @noBang];
items[i ← i + 1] ← FormSW.BooleanItem[tag: "#-Off"L, switch: @noLate];
items[i ← i + 1] ← FormSW.BooleanItem[tag: "?-Off"L, switch: @noLost];
items[i ← i + 1] ← FormSW.NumberItem[tag: "Timeout(ms)"L, value: @timeout];
IF (i + 1) # nItems THEN ERROR;
RETURN[items, TRUE];
END;
Transition: ToolWindow.TransitionProcType =
BEGIN
SELECT TRUE FROM
old = inactive =>
BEGIN
AppendMe: PROCEDURE [s: LONG STRING, clientData: LONG POINTER] =
BEGIN String.AppendString[thisMachineID, s]; END;
checkIt ← TRUE;
noBang ← noLate ← noLost ← FALSE;
thisMachineID ← z.NEW[StringBody[50]];
Format.HostNumber[AppendMe, LOOPHOLE[SpecialSystem.GetProcessorID[]], productSoftware];
remoteAddress ← z.NEW[StringBody[50]];
END;
new = inactive =>
BEGIN
z.FREE[@thisMachineID];
z.FREE[@remoteAddress];
END;
ENDCASE;
END;
Stop: FormSW.ProcType =
BEGIN StopIt[]; END;
StopIt: PROCEDURE =
BEGIN pleaseStop ← TRUE; WHILE running DO Process.Pause[1]; ENDLOOP; END;
Stats: FormSW.ProcType =
BEGIN
firstNetwork: Driver.Network ← Driver.GetDeviceChain[];
FOR network: Driver.Network ← firstNetwork, network.next UNTIL network = NIL DO
IF UserInput.UserAbort[log] THEN EXIT;
SELECT network.device FROM
ethernet, ethernetOne =>
BEGIN
pup: PupRouterDefs.NetworkContext ← Protocol1.GetContext[network, pup];
ns: RoutingTable.NetworkContext ← Protocol1.GetContext[network, ns];
stats: LONG POINTER TO EthernetDriverFriends.EtherStatsInfo ← network.stats;
Put.Text[log, "Ethernet"L];
IF network.device = ethernetOne THEN Put.Text[log, "One"L];
Put.Text[log, " Statistics for "L];
IF pup # NIL THEN {
Put.Text[log, " Pup "L];
WriteNumber[pup.pupNetNumber, 8, 0];
Put.Text[log, "#"L];
WriteNumber[pup.pupHostNumber, 8, 0];
Put.Text[log, "#, NS net "L]; };
IF ns # NIL THEN WriteNetNumbers[ns.netNumber];
Put.Line[log, "."L];
IF stats = NIL THEN
BEGIN
Put.Line[log, "*** NO DRIVER STATS ***"L];
LOOP;
END;
Put.Text[log, " Rcv: pkts "L];
Put.LongDecimal[log, stats.packetsRecv];
Put.Text[log, ", words "L];
Put.LongDecimal[log, stats.wordsRecv];
Put.Text[log, ", bad "L];
Put.LongDecimal[log, stats.badRecvStatus];
Put.Text[log, ", missed "L];
Put.LongDecimal[log, stats.packetsMissed];
IF stats.idleInput # 0 THEN
BEGIN
Put.Text[log, ", idle "L];
Put.LongDecimal[log, stats.idleInput];
END;
Put.CR[log ];
IF stats.badRecvStatus # 0 OR stats.okButDribble # 0 THEN
BEGIN
Put.Text[log, " crc "L];
Put.LongDecimal[log, stats.badCrc];
Put.Text[log, ", bad alignment but ok crc "L];
Put.LongDecimal[log, stats.badAlignmentButOkCrc];
Put.Text[log, ", crc and bad alignment "L];
Put.LongDecimal[log, stats.crcAndBadAlignment];
Put.CR[log ];
Put.Text[log, " ok but dribble "L];
Put.LongDecimal[log, stats.okButDribble];
Put.Text[log, ", too long "L];
Put.LongDecimal[log, stats.packetTooLong];
Put.Text[log, ", overrun "L];
Put.LongDecimal[log, stats.overrun];
Put.CR[log ];
END;
Put.Text[log, " Xmit: pkts "L];
Put.LongDecimal[log, stats.packetsSent];
Put.Text[log, ", words "L];
Put.LongDecimal[log, stats.wordsSent];
Put.Text[log, ", bad "L];
Put.LongDecimal[log, stats.badSendStatus];
Put.CR[log ];
IF stats.stuckOutput # 0 OR stats.badSendStatus # 0
OR stats.tooManyCollisions # 0 THEN
BEGIN
Put.Text[log, " underrun "L];
Put.LongDecimal[log, stats.underrun];
Put.Text[log, ", stuck "L];
Put.LongDecimal[log, stats.stuckOutput];
Put.Text[log, ", too many collisions "L];
Put.LongDecimal[log, stats.tooManyCollisions];
Put.CR[log ];
END;
Put.Text[log, " Lds:"L];
FOR i: CARDINAL IN [0..16) DO
Put.Char[log, ' ]; Put.LongDecimal[log, stats.loadTable[i]]; ENDLOOP;
Put.CR[log ];
END;
phonenet =>
BEGIN
pup: PupRouterDefs.NetworkContext ← Protocol1.GetContext[network, pup];
ns: RoutingTable.NetworkContext ← Protocol1.GetContext[network, ns];
stats: PhoneNetFriends.PhoneNetInfo = PhoneNetFriends.StatsPtrToStats[network.stats];
Put.Text[log, "PhoneNet Statistics for "L];
IF pup # NIL THEN {
Put.Text[log, "Pup "L];
WriteNumber[pup.pupNetNumber, 8, 0];
Put.Text[log, "#"L];
WriteNumber[pup.pupHostNumber, 8, 0]; };
IF ns # NIL THEN {
Put.Text[log, "#, NS net "L];
WriteNetNumbers[ns.netNumber]; };
Put.Text[log, ", Line "L];
Put.LongDecimal[log, stats.lineNumber];
Put.Text[log, ", "L];
Put.LongDecimal[log, stats.speed];
Put.Text[log, "KB"L];
SELECT stats.remoteHostNumber FROM
System.nullHostNumber =>
Put.Text[log, ", Down"L];
System.localHostNumber =>
Put.Text[log, ", Looped"L];
ENDCASE => {
Put.CR[log ];
Put.Text[log, " Up to "L];
WriteHostNumbers[stats.remoteHostNumber]; };
Put.CR[log ];
Put.Text[log, " Recv: pkts "L];
Put.LongDecimal[log, stats.stats[pktsReceived]];
Put.Text[log, ", bytes "L];
Put.LongDecimal[log, stats.stats[bytesReceived]];
Put.Text[log, ", rejected "L];
Put.LongDecimal[log, stats.stats[pktsRejected]];
Put.Text[log, ", missed "L];
Put.LongDecimal[log, stats.stats[rcvErrorNoGet]];
Put.Text[log, ", idle "L];
Put.LongDecimal[log, stats.stats[tooLongSinceLastReceive]];
Put.CR[log ];
Put.Text[log, " Bad crc "L];
Put.LongDecimal[log, stats.stats[rcvErrorCRC]];
Put.Text[log, ", data lost "L];
Put.LongDecimal[log, stats.stats[rcvErrorDataLost]];
Put.Text[log, ", device error "L];
Put.LongDecimal[log, stats.stats[rcvDeviceError]];
Put.Text[log, ", timeout "L];
Put.LongDecimal[log, stats.stats[rcvErrorFrameTimeout]];
Put.Text[log, ", other error "L];
Put.LongDecimal[log, stats.stats[rcvErrorUnknown]];
Put.CR[log ];
Put.Text[log, " Send: pkts "L];
Put.LongDecimal[log, stats.stats[pktsSent]];
Put.Text[log, ", bytes "L];
Put.LongDecimal[log, stats.stats[bytesSent]];
Put.CR[log ];
Put.Text[log, " NS "L];
Put.LongDecimal[log, stats.stats[nsSent]];
Put.Text[log, " "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.nsBytesSend]];
Put.Text[log, ", Pups "L];
Put.LongDecimal[log, stats.stats[pupSent]];
Put.Text[log, " "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.pupBytesSend]];
Put.Text[log, ", Leaf "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.leafPktsSend]];
Put.Text[log, " "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.leafBytesSend]];
Put.CR[log ];
IF stats.stats[sendErrorBadStatus] # 0 OR stats.stats[queueTooOld] # 0 THEN {
Put.Text[log, " Bad "L];
Put.LongDecimal[log, stats.stats[sendErrorBadStatus]];
Put.Text[log, ", stuck "L];
Put.LongDecimal[log, stats.stats[queueTooOld]];
Put.CR[log ]; };
Put.Text[log, " Queue too long "L];
Put.LongDecimal[log, stats.stats[congestion]];
Put.Text[log, ", NS "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.nsCongestion]];
Put.Text[log, ", Pup "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.pupCongestion]];
Put.CR[log ];
Put.Text[log, " Conn too greedy "L];
Put.LongDecimal[log, stats.stats[connTooGreedy]];
Put.Text[log, ", NS "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.nsTooGreedy]];
Put.Text[log, ", Pup "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.pupTooGreedy]];
Put.CR[log ];
IF stats.stats[PhoneNetExtras.nsDupsFiltered] # 0 THEN {
Put.Text[log, " NS duplicates discarded: "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.nsDupsFiltered]];
Put.CR[log ]; };
IF stats.stats[PhoneNetExtras.pupDupsFiltered] # 0 THEN {
Put.Text[log, " BSP probes/duplicates discarded: "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.pupDupsFiltered]];
Put.CR[log ]; };
IF stats.stats[PhoneNetExtras.leafDupsFiltered] # 0 THEN {
Put.Text[log, " Leaf duplicates discarded: "L];
Put.LongDecimal[log, stats.stats[PhoneNetExtras.leafDupsFiltered]];
Put.CR[log ]; };
END;
ENDCASE => NULL;
ENDLOOP;
END;
WriteHostNumbers: PROCEDURE [net: System.HostNumber] =
BEGIN
Push: PROCEDURE [s: LONG STRING, clientData: LONG POINTER] =
BEGIN Put.Text[log, s]; END;
Format.HostNumber[Push, net, productSoftware];
Put.Text[log, "="L];
Format.HostNumber[Push, net, octal];
END;
WriteNetNumbers: PROCEDURE [net: System.NetworkNumber] =
BEGIN
Push: PROCEDURE [s: LONG STRING, clientData: LONG POINTER] =
BEGIN Put.Text[log, s]; END;
Format.NetworkNumber[Push, net, productSoftware];
Put.Text[log, "="L];
Format.NetworkNumber[Push, net, octal];
END;
Echo: FormSW.ProcType =
BEGIN
fixed: BOOLEAN;
size: CARDINAL;
errFlag: BOOLEAN ← FALSE;
remoteAddr: System.NetworkAddress;
StopIt[];
IF fixed AND maxLength < 1 THEN
BEGIN
WriteLine["Need at least 2 words."L];
RETURN;
END;
IF maxLength > NSTypes.maxIDPDataWords THEN
BEGIN
WriteLine["(max)Length is too big."L];
RETURN;
END;
fixed ← fixedLength;
size ← maxLength;
WriteCR[];
WriteString["Echoing to "L];
WriteString[remoteAddress];
WriteString[" = "L];
remoteAddr ← GetAddress[remoteAddress, NSConstants.echoerSocket !
Trouble =>
BEGIN
WriteLine[reason];
errFlag ← TRUE;
CONTINUE;
END];
IF errFlag THEN RETURN;
WriteNetworkAddressVerbose[remoteAddr];
WriteLine["."L];
pleaseStop ← FALSE;
running ← TRUE;
Process.Detach[FORK Worker[remoteAddr, fixed, size, 1]];
END;
DelayRange: TYPE = {
d1, d1a, d2, d2a, d3, d3a, d4, d4a,
d5, d5a, d6, d6a, d7, d7a, d8, d8a, d9, d9a,
d10, d14, d20, d28, d50, d70,
d100, d140, d200, d280, d500, d700,
d1000, d1400, d2000, d2800, d5000, d7000,
d10000, d14000, d20000, d28000, more};
delayTime: ARRAY DelayRange OF LONG CARDINAL = [
d1: 1000, d1a: 1500, d2: 2000, d2a: 2500,
d3: 3000, d3a: 3500, d4: 4000, d4a: 4500,
d5: 5000, d5a: 5500, d6: 6000, d6a: 6500,
d7: 7000, d7a: 7500, d8: 8000, d8a: 8500,
d9: 9000, d9a: 9500,
d10: 10000, d14: 14000, d20: 20000, d28: 28000, d50: 50000, d70: 70000,
d100: 100000, d140: 140000, d200: 200000, d280: 280000, d500: 500000, d700: 700000,
d1000: 1000000, d1400: 1400000, d2000: 2000000, d2800: 2800000, d5000: 5000000, d7000: 7000000,
d10000: 10000000, d14000: 14000000, d20000: 20000000, d28000: 28000000, more: LAST[LONG CARDINAL]];
Worker: PROCEDURE [
remoteAddr: System.NetworkAddress, fixed: BOOLEAN,
wordsPerPacket, packetsPerClump: CARDINAL] =
BEGIN
length: CARDINAL = MAX[2, MIN[NSTypes.maxIDPDataWords, wordsPerPacket]];
delay: ARRAY DelayRange OF LONG CARDINAL ← ALL[0];
minDelay: LONG CARDINAL ← LAST[LONG CARDINAL];
maxDelay: LONG CARDINAL ← FIRST[LONG CARDINAL];
picks: ARRAY [0..16] OF CARDINAL ← ALL[0];
drops: ARRAY [0..16] OF CARDINAL ← ALL[0];
sent, good, missed, late, bad, horrible, trash, words: LONG CARDINAL ← 0;
start, stop: System.Pulses;
micro: LONG CARDINAL;
startSec, stopSec: System.GreenwichMeanTime;
AddToDelayHist: PROCEDURE [micro: LONG CARDINAL] =
BEGIN
FOR d: DelayRange IN DelayRange DO -- Slow but clean
IF delayTime[d] < micro THEN LOOP;
delay[d] ← delay[d] + 1;
EXIT;
REPEAT FINISHED => ERROR;
ENDLOOP;
minDelay ← MIN[minDelay, micro];
maxDelay ← MAX[maxDelay, micro];
END;
PrintDelayHist: PROCEDURE =
BEGIN
total: LONG CARDINAL ← 0;
IF good = 0 THEN RETURN;
FOR d: DelayRange IN DelayRange DO
IF delay[d] = 0 THEN LOOP;
total ← total + delay[d];
WriteLongNumber[delay[d], 10, 8];
WriteLongNumber[delay[d]*100/good, 10, 4];
WriteString["%"L];
WriteLongNumber[total, 10, 8];
WriteLongNumber[total*100/good, 10, 4];
WriteString["% packets with delay less than "L];
WriteLongDecimal[delayTime[d]];
WriteLine[" microseconds."L];
ENDLOOP;
WriteString["The min delay was "L];
WriteLongDecimal[minDelay];
WriteLine[" microseconds."L];
WriteString["The max delay was "L];
WriteLongDecimal[maxDelay];
WriteLine[" microseconds."L];
END;
AddToErrorHist: PROCEDURE [
hist: POINTER TO ARRAY [0..16] OF CARDINAL, bits: WORD] =
BEGIN
i: CARDINAL;
IF bits = 0 THEN RETURN;
SELECT bits FROM
1 => i ← 15;
2 => i ← 14;
4 => i ← 13;
10B => i ← 12;
20B => i ← 11;
40B => i ← 10;
100B => i ← 9;
200B => i ← 8;
400B => i ← 7;
1000B => i ← 6;
2000B => i ← 5;
4000B => i ← 4;
10000B => i ← 3;
20000B => i ← 2;
40000B => i ← 1;
100000B => i ← 0;
ENDCASE => i ← 16;
hist[i] ← hist[i] + 1;
END;
PrintSummary: PROCEDURE [howLong: LONG CARDINAL] =
BEGIN
IF howLong # 0 THEN
BEGIN
WriteLongNumber[sent/howLong, 10, 8];
WriteLine[" packets per second."L];
WriteLongNumber[16*words/howLong, 10, 8];
WriteLine[" data bits per second."L];
END;
END;
PrintErrorHist: PROCEDURE =
BEGIN
ShowPercent[good, sent, "good packets received."L];
ShowPercent[missed, sent, "packets missed."L];
ShowPercent[late, sent, "late (or??) packets received."L];
ShowPercent[bad, sent, "bad packets received."L];
ShowPercent[horrible, sent, "packets received with more than 10 words wrong."L];
ShowPercent[trash, sent, "trashy packets received."L];
IF bad # 0 THEN
BEGIN
x: WORD ← 100000B;
WriteCR[];
WriteLine[" Bit Picked Dropped"L];
FOR i: CARDINAL IN [0..16] DO
IF picks[i] # 0 OR drops[i] # 0 THEN
BEGIN
IF i = 16 THEN WriteString[" Other"L] ELSE O6[x];
D8[picks[i]];
D8[drops[i]];
WriteCR[];
END;
x ← x/2;
ENDLOOP;
END;
END;
soc: Socket.ChannelHandle;
sendSequenceNumber, recvSequenceNumber: CARDINAL ← 0;
buffers: ARRAY [0..maxClumpSize) OF Buffer.NSBuffer;
b: Buffer.NSBuffer;
pktBody: LONG POINTER TO ARRAY [0..0) OF WORD;
soc ← Socket.Create[
socket: System.nullSocketNumber, send: packetsPerClump, receive: packetsPerClump];
Socket.SetWaitTime[soc, timeout];
startSec ← System.GetGreenwichMeanTime[];
UNTIL pleaseStop OR UserInput.UserAbort[log] DO
FOR i: CARDINAL IN [0..packetsPerClump) DO
cycle: CARDINAL;
IF (((sendSequenceNumber ← sendSequenceNumber + 1) MOD 5) = 0) THEN Process.Yield[];
IF (sendSequenceNumber MOD NSTypes.maxIDPDataWords) = 0 THEN
BEGIN
IF ~noBang THEN WriteLine[""L] ELSE WriteChar['.];
END;
cycle ← IF fixed THEN wordsPerPacket - 1 ELSE sendSequenceNumber MOD length;
IF cycle = 0 THEN cycle ← 1;
b ← Socket.GetSendBuffer[soc];
Socket.SetDestination[b, remoteAddr];
Socket.SetPacketWords[b, cycle + 1]; -- 1 for echoType
words ← words + cycle + 1;
b.ns.packetType ← echo;
b.ns.echoType ← echoRequest;
pktBody ← @b.ns.echoWords;
FOR k: CARDINAL IN [0..cycle) DO
pktBody[k] ← (k*400B + sendSequenceNumber); ENDLOOP;
buffers[i] ← b;
ENDLOOP;
start ← System.GetClockPulses[];
FOR i: CARDINAL IN [0..packetsPerClump) DO
Socket.PutPacket[soc, buffers[i]];
sent ← sent + 1;
ENDLOOP;
-- now receive the echo or any back logged echos
DO
cycle: CARDINAL;
diff: INTEGER;
b ← Socket.GetPacket[
soc !
Socket.TimeOut =>
BEGIN
UNTIL sendSequenceNumber = recvSequenceNumber DO
missed ← missed + 1;
IF ~noLost THEN WriteChar['?];
recvSequenceNumber ← recvSequenceNumber + 1;
ENDLOOP;
EXIT;
END];
pktBody ← @b.ns.echoWords;
IF b.ns.packetType # echo OR b.ns.echoType # echoResponse THEN
BEGIN
trash ← trash + 1;
WriteChar['%];
Socket.ReturnBuffer[b];
LOOP;
END;
recvSequenceNumber ← recvSequenceNumber + 1;
cycle ← IF fixed THEN length - 1 ELSE recvSequenceNumber MOD length;
IF cycle = 0 THEN cycle ← 1;
diff ← pktBody[0] - recvSequenceNumber;
IF diff < 0 THEN
BEGIN
late ← late + 1;
IF ~noLate THEN WriteChar['#];
Socket.ReturnBuffer[b];
recvSequenceNumber ← recvSequenceNumber - 1;
LOOP;
END;
WHILE diff > 0 DO
missed ← missed + 1;
IF ~noLost THEN WriteChar['?];
recvSequenceNumber ← recvSequenceNumber + 1;
cycle ← IF fixed THEN length - 1 ELSE recvSequenceNumber MOD length;
IF cycle = 0 THEN cycle ← 1;
diff ← pktBody[0] - recvSequenceNumber;
ENDLOOP;
SELECT TRUE FROM
(Socket.GetPacketBytes[b] # 2*(cycle + 1))
OR (pktBody[0] # recvSequenceNumber) =>
BEGIN
trash ← trash + 1;
WriteChar['%];
Socket.ReturnBuffer[b];
LOOP;
END;
ENDCASE =>
BEGIN -- the echo we were looking for
hits: CARDINAL ← 0;
stop ← System.GetClockPulses[];
micro ← System.PulsesToMicroseconds[[stop - start]];
AddToDelayHist[micro];
IF checkIt THEN
FOR k: CARDINAL IN [0..cycle) DO
IF pktBody[k] # (k*400B + recvSequenceNumber) THEN
BEGIN OPEN Inline;
expected, found, picked, dropped: WORD;
IF hits = 0 THEN
BEGIN
WriteCR[];
WriteCurrentDateAndTime[];
WriteString[" Data compare error(s) on packet number "L];
WriteLongDecimal[sent];
WriteLine["."L];
WriteLine["Idx Expected Found Picked Dropped"L];
END;
expected ← k*400B + recvSequenceNumber;
found ← pktBody↑[k];
picked ← BITAND[found, BITNOT[expected]];
dropped ← BITAND[expected, BITNOT[found]];
AddToErrorHist[@picks, picked];
AddToErrorHist[@drops, dropped];
IF hits < 10 THEN
BEGIN
O3[k];
O9[expected];
O9[found];
O9[picked];
O9[dropped];
WriteCR[];
END;
hits ← hits + 1;
END;
ENDLOOP;
IF hits = 0 THEN good ← good + 1 ELSE bad ← bad + 1;
IF hits = 0 AND ~noBang THEN WriteChar['!];
IF hits > 10 THEN
BEGIN horrible ← horrible + 1; WriteLine["...."L]; END;
Socket.ReturnBuffer[b];
IF recvSequenceNumber = sendSequenceNumber THEN EXIT;
END;
ENDLOOP;
ENDLOOP;
stopSec ← System.GetGreenwichMeanTime[];
WriteCR[];
Socket.Delete[soc];
WriteLongNumber[sent, 10, 8];
WriteLine[" packets sent."L];
PrintSummary[stopSec-startSec];
PrintErrorHist[];
PrintDelayHist[];
running ← FALSE;
END;
PokeOnce: FormSW.ProcType =
BEGIN
sequenceNumber: CARDINAL ← 0;
b: Buffer.NSBuffer;
errFlag: BOOLEAN ← FALSE;
remoteAddr: System.NetworkAddress;
soc: Socket.ChannelHandle;
hit: CARDINAL ← 0;
WriteCR[];
WriteString["Poking "L];
WriteString[remoteAddress];
WriteString[" = "L];
remoteAddr ← GetAddress[remoteAddress, NSConstants.echoerSocket !
Trouble =>
BEGIN
WriteString["AddressTranslation troubles: "L];
WriteLine[reason];
errFlag ← TRUE;
CONTINUE;
END];
IF errFlag THEN RETURN;
WriteNetworkAddressVerbose[remoteAddr];
WriteLine["."L];
soc ← Socket.Create[socket: System.nullSocketNumber, receive: 20];
Socket.SetWaitTime[soc, timeout];
b ← Socket.GetSendBuffer[soc];
Socket.SetDestination[b, remoteAddr];
Socket.SetPacketWords[b, 1];
b.ns.packetType ← echo;
b.ns.echoType ← echoRequest;
Socket.PutPacket[soc, b];
DO
b ← Socket.GetPacket[soc ! Socket.TimeOut => EXIT];
SELECT TRUE FROM
(Socket.GetPacketBytes[b] # 2*1) OR (b.ns.echoType # echoResponse) =>
BEGIN
WriteChar['#];
Socket.ReturnBuffer[b];
LOOP;
END;
ENDCASE =>
BEGIN
hit ← hit + 1;
WriteString["Response number "L];
WriteNumber[hit, 10, 2];
WriteString[" from "L];
WriteNetworkAddressVerbose[Socket.GetSource[b]];
WriteLine["."L];
Socket.ReturnBuffer[b];
END;
ENDLOOP;
WriteCR[];
Socket.Delete[soc];
END;
Clumps: FormSW.ProcType =
BEGIN
fixed: BOOLEAN;
size, clumps: CARDINAL;
errFlag: BOOLEAN ← FALSE;
remoteAddr: System.NetworkAddress;
StopIt[];
IF fixed AND maxLength < 1 THEN
BEGIN
WriteLine["Need at least 2 word."L];
RETURN;
END;
IF maxLength > NSTypes.maxIDPDataWords THEN
BEGIN
WriteLine["(max)Length is too big."L];
RETURN;
END;
IF clumpSize > maxClumpSize THEN
BEGIN
WriteLine["ClumpSize is too big."L];
RETURN;
END;
IF clumpSize < 1 THEN
BEGIN
WriteLine["Need at least 1 packet per clump."L];
RETURN;
END;
fixed ← fixedLength;
size ← maxLength;
clumps ← clumpSize;
WriteCR[];
WriteString["Echoing Clumps to "L];
WriteString[remoteAddress];
WriteString[" = "L];
remoteAddr ← GetAddress[remoteAddress, NSConstants.echoerSocket !
Trouble =>
BEGIN
WriteString["AddressTranslation troubles: "L];
WriteLine[reason];
errFlag ← TRUE;
CONTINUE;
END];
IF errFlag THEN RETURN;
WriteNetworkAddressVerbose[remoteAddr];
WriteLine["."L];
pleaseStop ← FALSE;
running ← TRUE;
Process.Detach[FORK Worker[remoteAddr, fixed, size, clumps]];
END;
ShowPercent: PROCEDURE [n, sent: LONG CARDINAL, s: LONG STRING] =
BEGIN
IF n = 0 THEN RETURN;
WriteLongNumber[n, 10, 8];
WriteLongNumber[n*100/sent, 10, 4];
WriteString["% "L];
WriteLine[s];
END;
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;
WriteLongNumber: PROCEDURE [n: LONG CARDINAL, radix, width: CARDINAL] = INLINE
BEGIN
temp: STRING = [25];
String.AppendLongNumber[temp, n, radix];
THROUGH [temp.length..width) DO Put.Char[log, ' ]; ENDLOOP;
Put.Text[log, temp];
END;
WriteNumber: PROCEDURE [n, radix, width: CARDINAL] = INLINE
BEGIN
temp: STRING = [25];
String.AppendNumber[temp, n, radix];
THROUGH [temp.length..width) DO Put.Char[log, ' ]; ENDLOOP;
Put.Text[log, temp];
END;
WriteLongDecimal: PROCEDURE [n: LONG UNSPECIFIED] =
BEGIN
temp: STRING = [32];
String.AppendLongNumber[temp, n, 10];
Put.Text[log, temp];
END;
D8: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 10, 8]; END;
O3: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 3]; END;
O6: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 3]; END;
O9: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 9]; END;
WriteCurrentDateAndTime: PROCEDURE =
BEGIN
temp: STRING = [32];
Time.AppendCurrent[temp];
Put.Text[log, temp];
END;
WriteNetworkAddressVerbose: PROCEDURE [address: System.NetworkAddress] =
BEGIN
temp: STRING = [100];
Append: PROCEDURE [s: LONG STRING, clientData: LONG POINTER] =
BEGIN String.AppendString[temp, s]; END;
Format.NetworkAddress[Append, address, octal];
String.AppendString[temp, " = "L];
Format.NetworkAddress[Append, address, productSoftware];
Put.Text[log, temp];
END;
Trouble: ERROR [reason: LONG STRING] = CODE;
GetAddress: PROCEDURE [host: LONG STRING, socket: System.SocketNumber]
RETURNS [addr: System.NetworkAddress] =
BEGIN
localFailed: BOOLEAN ← FALSE;
IF host = NIL THEN ERROR Trouble["NIL => Address Fault"L];
addr ← Unformat.NetworkAddress[host, octal !
Unformat.Error => BEGIN localFailed ← TRUE; CONTINUE; END ];
IF localFailed THEN
BEGIN
addr ← AddressTranslation.StringToNetworkAddress[host !
AddressTranslation.Error =>
BEGIN
temp: STRING = [200];
proc: Format.StringProc = {String.AppendString[temp, s]};
AddressTranslation.PrintError[errorRecord, proc];
ERROR Trouble[temp];
END].addr;
addr.socket ← socket; -- CH returns trash in socket
END;
IF addr.socket = System.nullSocketNumber THEN addr.socket ← socket;
END;
Init[]; -- this gets string out of global frame
END...