
<<RPCBulk.mesa>>
<<Andrew Birrell  26-Feb-82 10:06:00>>

DIRECTORY
NameInfoSpecialDefs, Process, MesaRPC, RPCLupine, Runtime, SpyClient, System;

RPCBulk: MONITOR
IMPORTS NameInfoSpecialDefs, Process, MesaRPC, RPCLupine, Runtime, SpyClient, System =

BEGIN

-- ******** Test program ******** --

Finished: SIGNAL = CODE;
signalFinished: BOOLEAN _ TRUE;
tries:          CARDINAL _ 1000;
quit:           BOOLEAN _ FALSE;
gvExport:       BOOLEAN _ TRUE;
gvInstance:     STRING = "RPCRuntime.pa";
nongvInstance:  STRING = "Tokay";
callerName:     MesaRPC.Principal _ "Test.pa";
callerKey:      MesaRPC.EncryptionKey _ MesaRPC.MakeKey["Test"L];
exporterName:   MesaRPC.Principal _ "RPCRuntime.pa";
exporterKey:    MesaRPC.EncryptionKey _ MesaRPC.MakeKey["zzy"L];
userTest:       BOOLEAN _ TRUE;
spyWanted:      BOOLEAN _ FALSE;

import: RPCLupine.ImportHandle _ NIL;


-- Test version of stub code --

StartTransfer: PROC[conv: MesaRPC.Conversation] =
BEGIN
pktSpace: ARRAY[1..RPCLupine.pktOverhead+1] OF WORD;
pkt: RPCLupine.StubPkt = RPCLupine.GetStubPkt[@pktSpace];
[] _ RPCLupine.StartCall[pkt, import, conv];
BEGIN
length: RPCLupine.DataLength;
last: BOOLEAN;
pkt[0] _ 1;
[length, last] _ RPCLupine.Call[pkt, 1, 1, NIL];
IF NOT last THEN ERROR;
END;
END;

SendPage: PROC[conv: MesaRPC.Conversation, page: CARDINAL] =
BEGIN
pktSpace: ARRAY[1..RPCLupine.pktOverhead+RPCLupine.maxDataLength] OF WORD;
pkt: RPCLupine.StubPkt = RPCLupine.GetStubPkt[@pktSpace];
[] _ RPCLupine.StartCall[pkt, import, conv];
BEGIN
length: RPCLupine.DataLength;
last: BOOLEAN;
pkt[0] _ 0; pkt[1] _ page;
[length, last] _ RPCLupine.Call[pkt, RPCLupine.maxDataLength,
RPCLupine.maxDataLength, NIL];
IF NOT last THEN ERROR;
END;
END;

TestDispatcher: RPCLupine.Dispatcher =
BEGIN
-- Dummy dispatcher: consumes args and sends dummy result --
IF NOT lastPkt THEN ERROR;
SELECT pkt[0] FROM
0 => AcceptPage[localConversation, pkt[1] ];
1 => AcceptTransfer[localConversation];
ENDCASE => ERROR;
RETURN[0];
END;


-- Test version of client code --

-- Sender --

conversation: MesaRPC.Conversation;
senderPage: CARDINAL _ 0;

NextPage: ENTRY PROC RETURNS[p: CARDINAL] = INLINE
{ p _ senderPage; senderPage _ senderPage+1 };

Sender: PROC[limit: CARDINAL] =
BEGIN
DO p: CARDINAL = NextPage[];
IF p > limit THEN EXIT;
SendPage[conversation, p];
ENDLOOP;
END;

-- Receiver --

pageCond: CONDITION _ [timeout:0];
receiverPage: CARDINAL _ 0;

AcceptTransfer: ENTRY PROC[conv: MesaRPC.Conversation] =
BEGIN
receiverPage _ 0;
END;

AcceptPage: ENTRY PROC[conv: MesaRPC.Conversation, page: CARDINAL] =
BEGIN
UNTIL receiverPage = page DO WAIT pageCond ENDLOOP;
receiverPage _ page + 1;
BROADCAST pageCond;
END;

DoIt: PROC =
BEGIN
-- Export and import --

instance: STRING _ IF gvExport THEN gvInstance ELSE nongvInstance;

import _ RPCLupine.ImportInterface[["RPC-bulk-test"L, instance], [0,0] !
MesaRPC.ImportFailed =>
IF why = unbound OR why = communications
THEN BEGIN
[] _ RPCLupine.ExportInterface[exporterName, exporterKey,
["RPC-bulk-test"L, instance], TestDispatcher, [0,0]];
import _ RPCLupine.ImportInterface[["RPC-bulk-test"L,
instance],[0,0]];
CONTINUE
END ];
BEGIN
spyAvailable: BOOLEAN = Runtime.IsBound[SpyClient.StartCounting];
UNTIL quit
DO UNTIL userTest DO Process.Pause[Process.SecondsToTicks[5]] ENDLOOP;
conversation _ MesaRPC.StartConversation[callerName, callerKey, exporterName, authOnly];
senderPage _ 0; StartTransfer[conversation];
NameInfoSpecialDefs.CleanUp[];
IF spyWanted AND spyAvailable THEN SpyClient.StartCounting[];
BEGIN
start:   System.Pulses = System.GetClockPulses[];
end:     System.Pulses;
elapsed: System.Microseconds;
first:   PROCESS = FORK Sender[tries];  
second:  PROCESS = FORK Sender[tries];
third:   PROCESS = FORK Sender[tries];
fourth:  PROCESS = FORK Sender[tries];
<<fifth:   PROCESS = FORK Sender[tries];>>
<<sixth:   PROCESS = FORK Sender[tries];>>
<<seventh: PROCESS = FORK Sender[tries];>>
JOIN first; JOIN second; JOIN third; JOIN fourth;
<<JOIN fifth; JOIN sixth; JOIN seventh;>>
end _ System.GetClockPulses[];
IF spyWanted AND spyAvailable THEN SpyClient.StopCounting[];
elapsed _ System.PulsesToMicroseconds[[end-start]];
MesaRPC.EndConversation[conversation];
IF signalFinished THEN SIGNAL Finished[];
END;
ENDLOOP;

END;
END;

DoIt[];


END.