878 lines
33 KiB
Plaintext
878 lines
33 KiB
Plaintext
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Microsoft Research Singularity
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
// File: Services\Tests\BenchmarkProxy\BenchmarkJournalet.sg
|
||
|
|
//
|
||
|
|
// Note:
|
||
|
|
//
|
||
|
|
#define VERSION_2
|
||
|
|
using System;
|
||
|
|
using System.Threading;
|
||
|
|
using System.Collections;
|
||
|
|
using Microsoft.SingSharp;
|
||
|
|
using Microsoft.Singularity;
|
||
|
|
using Microsoft.Singularity.Channels;
|
||
|
|
using Microsoft.Singularity.Directory;
|
||
|
|
using Microsoft.Singularity.Resiliency;
|
||
|
|
|
||
|
|
namespace Microsoft.Singularity.Services.Benchmark
|
||
|
|
{
|
||
|
|
internal enum MessageType : uint
|
||
|
|
{
|
||
|
|
Unknown,
|
||
|
|
GetCycleCount,
|
||
|
|
CycleCount,
|
||
|
|
Null,
|
||
|
|
One,
|
||
|
|
Two,
|
||
|
|
Three,
|
||
|
|
Four,
|
||
|
|
Five,
|
||
|
|
Six,
|
||
|
|
Seven,
|
||
|
|
Eight,
|
||
|
|
Nine,
|
||
|
|
EndOfBenchmark,
|
||
|
|
AckNull,
|
||
|
|
AckOne,
|
||
|
|
AckTwo,
|
||
|
|
AckThree,
|
||
|
|
AckFour,
|
||
|
|
AckFive,
|
||
|
|
AckSix,
|
||
|
|
AckSeven,
|
||
|
|
AckEight,
|
||
|
|
AckNine,
|
||
|
|
AckEnd,
|
||
|
|
}
|
||
|
|
|
||
|
|
#if VERSION_2
|
||
|
|
internal class BenchmarkJournalet : Journalet2
|
||
|
|
#else
|
||
|
|
internal class BenchmarkJournalet : Journalet
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
private Log! incoming;
|
||
|
|
private Log! outgoing;
|
||
|
|
private Object! initMonitor;
|
||
|
|
private Object! benchmarkMonitor;
|
||
|
|
private TRef<BenchmarkContract.Imp:Start> initImp;
|
||
|
|
private TRef<BenchmarkContract.Imp:Ready> benchmarkImp;
|
||
|
|
private TRef<BenchmarkContract.Exp:Ready> benchmarkExp;
|
||
|
|
#if VERSION_2
|
||
|
|
private TRef<BenchmarkContract.Exp:Start>! initExp;
|
||
|
|
|
||
|
|
internal BenchmarkJournalet([Claims]ServiceContract.Exp:Start! ep)
|
||
|
|
: base()
|
||
|
|
{
|
||
|
|
BenchmarkContract.Exp:Start exp;
|
||
|
|
exp = ep as BenchmarkContract.Exp:Start;
|
||
|
|
if (exp == null) {
|
||
|
|
throw new ArgumentException();
|
||
|
|
}
|
||
|
|
|
||
|
|
incoming = new Log();
|
||
|
|
outgoing = new Log();
|
||
|
|
initMonitor = new Object();
|
||
|
|
benchmarkMonitor = new Object();
|
||
|
|
initExp = new TRef<BenchmarkContract.Exp:Start>(exp);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
internal BenchmarkJournalet(JournalProducer! producer,
|
||
|
|
[Claims]ServiceContract.Exp:Start! ep)
|
||
|
|
{
|
||
|
|
base(producer, ep);
|
||
|
|
incoming = new Log();
|
||
|
|
outgoing = new Log();
|
||
|
|
initMonitor = new Object();
|
||
|
|
benchmarkMonitor = new Object();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if VERSION_2
|
||
|
|
public override void CreateEndpoint(out ServiceContract.Exp! ep)
|
||
|
|
#else
|
||
|
|
public override void CreateServerEndpoint(out ServiceContract.Exp:Start! ep)
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
BenchmarkContract.Imp! imp;
|
||
|
|
BenchmarkContract.Exp! exp;
|
||
|
|
BenchmarkContract.NewChannel(out imp, out exp);
|
||
|
|
|
||
|
|
//DebugStub.Print("BJ: Enter CreateServerEndpoint\n");
|
||
|
|
try {
|
||
|
|
Monitor.Enter(initMonitor);
|
||
|
|
initImp = new TRef<BenchmarkContract.Imp:Start>(imp);
|
||
|
|
Monitor.Pulse(initMonitor);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
Monitor.Exit(initMonitor);
|
||
|
|
}
|
||
|
|
ep = exp;
|
||
|
|
//DebugStub.Print("BJ: Exit CreateServerEndpoint\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
#if VERSION_2
|
||
|
|
public override void Flush() {}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if VERSION_2
|
||
|
|
public override void Run()
|
||
|
|
#else
|
||
|
|
protected override void ProxyThread()
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
bool success = false;
|
||
|
|
ulong time1, time2;
|
||
|
|
|
||
|
|
if (!Initialize()) {
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
for (;;) {
|
||
|
|
if (!HandleMessages()) {
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
time1 = Processor.GetCycleCount();
|
||
|
|
success = Recover();
|
||
|
|
time2 = Processor.GetCycleCount();
|
||
|
|
DebugStub.Print("BJ: ==== Recovery Result ====\n");
|
||
|
|
DebugStub.Print("outgoing incoming start end\n");
|
||
|
|
DebugStub.Print("{0},{1},{2},{3}\n",
|
||
|
|
__arglist(incoming.Count, outgoing.Count,
|
||
|
|
time1, time2));
|
||
|
|
if (!success) {
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
exit:
|
||
|
|
#if !VERSION_2
|
||
|
|
producer.DeregisterJournalet(this);
|
||
|
|
#endif
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override bool Initialize()
|
||
|
|
{
|
||
|
|
bool success = false;
|
||
|
|
BenchmarkContract.Exp:Start clientEp;
|
||
|
|
BenchmarkContract.Imp:Start serverEp;
|
||
|
|
|
||
|
|
#if VERSION_2
|
||
|
|
clientEp = initExp.Acquire();
|
||
|
|
#else
|
||
|
|
ServiceContract.Exp:Start! ep = clientRef.Acquire();
|
||
|
|
clientEp = ep as BenchmarkContract.Exp:Start;
|
||
|
|
if (clientEp == null) {
|
||
|
|
clientRef.Release(ep);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
assert initImp != null;
|
||
|
|
serverEp = initImp.Acquire();
|
||
|
|
switch receive {
|
||
|
|
case serverEp.Success():
|
||
|
|
clientEp.SendSuccess();
|
||
|
|
success = true;
|
||
|
|
break;
|
||
|
|
case serverEp.ChannelClosed():
|
||
|
|
success = false;
|
||
|
|
break;
|
||
|
|
case unsatisfiable:
|
||
|
|
DebugStub.Break();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
initImp = null;
|
||
|
|
|
||
|
|
if (success) {
|
||
|
|
benchmarkExp = new TRef<BenchmarkContract.Exp:Ready>(clientEp);
|
||
|
|
benchmarkImp = new TRef<BenchmarkContract.Imp:Ready>(serverEp);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
delete clientEp;
|
||
|
|
delete serverEp;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override bool HandleMessages()
|
||
|
|
{
|
||
|
|
bool success = true;
|
||
|
|
ArrayList al;
|
||
|
|
BenchmarkContract.Exp:Ready! clientEp;
|
||
|
|
BenchmarkContract.Imp:Ready! serverEp;
|
||
|
|
|
||
|
|
assert benchmarkExp != null;
|
||
|
|
assert benchmarkImp != null;
|
||
|
|
clientEp = benchmarkExp.Acquire();
|
||
|
|
serverEp = benchmarkImp.Acquire();
|
||
|
|
|
||
|
|
for (;;) {
|
||
|
|
switch receive {
|
||
|
|
case clientEp.GetCycleCount():
|
||
|
|
{
|
||
|
|
serverEp.SendGetCycleCount();
|
||
|
|
incoming.Record((uint)MessageType.GetCycleCount, null);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Null():
|
||
|
|
{
|
||
|
|
serverEp.SendNull();
|
||
|
|
incoming.Record((uint)MessageType.Null, null);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.One(arg):
|
||
|
|
{
|
||
|
|
serverEp.SendOne(arg);
|
||
|
|
al = new ArrayList(1);
|
||
|
|
al.Add(arg);
|
||
|
|
incoming.Record((uint)MessageType.One, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Two(arg1, arg2):
|
||
|
|
{
|
||
|
|
serverEp.SendTwo(arg1, arg2);
|
||
|
|
al = new ArrayList(2);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
incoming.Record((uint)MessageType.Two, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Three(arg1, arg2, arg3):
|
||
|
|
{
|
||
|
|
serverEp.SendThree(arg1, arg2, arg3);
|
||
|
|
al = new ArrayList(3);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
incoming.Record((uint)MessageType.Three, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Four(arg1, arg2, arg3, arg4):
|
||
|
|
{
|
||
|
|
serverEp.SendFour(arg1, arg2, arg3, arg4);
|
||
|
|
al = new ArrayList(4);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
incoming.Record((uint)MessageType.Four, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Five(arg1, arg2, arg3, arg4, arg5):
|
||
|
|
{
|
||
|
|
serverEp.SendFive(arg1, arg2, arg3, arg4, arg5);
|
||
|
|
al = new ArrayList(5);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
incoming.Record((uint)MessageType.Five, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Six(arg1, arg2, arg3, arg4, arg5, arg6):
|
||
|
|
{
|
||
|
|
serverEp.SendSix(arg1, arg2, arg3, arg4, arg5, arg6);
|
||
|
|
al = new ArrayList(6);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
incoming.Record((uint)MessageType.Six, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Seven(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7):
|
||
|
|
{
|
||
|
|
serverEp.SendSeven(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7);
|
||
|
|
al = new ArrayList(7);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
incoming.Record((uint)MessageType.Seven, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Eight(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8):
|
||
|
|
{
|
||
|
|
serverEp.SendEight(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8);
|
||
|
|
al = new ArrayList(8);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
al.Add(arg8);
|
||
|
|
incoming.Record((uint)MessageType.Eight, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.Nine(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8, arg9):
|
||
|
|
{
|
||
|
|
serverEp.SendNine(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8, arg9);
|
||
|
|
al = new ArrayList(9);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
al.Add(arg8);
|
||
|
|
al.Add(arg9);
|
||
|
|
incoming.Record((uint)MessageType.Nine, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.EndOfBenchmark():
|
||
|
|
{
|
||
|
|
serverEp.SendEndOfBenchmark();
|
||
|
|
incoming.Record((uint)MessageType.EndOfBenchmark,
|
||
|
|
null);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case clientEp.ChannelClosed():
|
||
|
|
{
|
||
|
|
success = false;
|
||
|
|
goto exit;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case serverEp.CycleCount(cycle):
|
||
|
|
{
|
||
|
|
clientEp.SendCycleCount(cycle);
|
||
|
|
al = new ArrayList(1);
|
||
|
|
al.Add(cycle);
|
||
|
|
outgoing.Record((uint)MessageType.CycleCount, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckNull():
|
||
|
|
{
|
||
|
|
clientEp.SendAckNull();
|
||
|
|
outgoing.Record((uint)MessageType.AckNull, null);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckOne(arg):
|
||
|
|
{
|
||
|
|
clientEp.SendAckOne(arg);
|
||
|
|
al = new ArrayList(1);
|
||
|
|
al.Add(arg);
|
||
|
|
outgoing.Record((uint)MessageType.AckOne, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckTwo(arg1, arg2):
|
||
|
|
{
|
||
|
|
clientEp.SendAckTwo(arg1, arg2);
|
||
|
|
al = new ArrayList(2);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
outgoing.Record((uint)MessageType.AckTwo, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckThree(arg1, arg2, arg3):
|
||
|
|
{
|
||
|
|
clientEp.SendAckThree(arg1, arg2, arg3);
|
||
|
|
al = new ArrayList(3);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
outgoing.Record((uint)MessageType.AckThree, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckFour(arg1, arg2, arg3, arg4):
|
||
|
|
{
|
||
|
|
clientEp.SendAckFour(arg1, arg2, arg3, arg4);
|
||
|
|
al = new ArrayList(4);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
outgoing.Record((uint)MessageType.AckFour, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckFive(arg1, arg2, arg3, arg4, arg5):
|
||
|
|
{
|
||
|
|
clientEp.SendAckFive(arg1, arg2, arg3, arg4, arg5);
|
||
|
|
al = new ArrayList(5);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
outgoing.Record((uint)MessageType.AckFive, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckSix(arg1, arg2, arg3, arg4, arg5, arg6):
|
||
|
|
{
|
||
|
|
clientEp.SendAckSix(arg1, arg2, arg3, arg4, arg5,
|
||
|
|
arg6);
|
||
|
|
al = new ArrayList(6);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
outgoing.Record((uint)MessageType.AckSix, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckSeven(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7):
|
||
|
|
{
|
||
|
|
clientEp.SendAckSeven(arg1, arg2, arg3, arg4, arg5,
|
||
|
|
arg6, arg7);
|
||
|
|
al = new ArrayList(7);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
outgoing.Record((uint)MessageType.AckSeven, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckEight(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8):
|
||
|
|
{
|
||
|
|
clientEp.SendAckEight(arg1, arg2, arg3, arg4, arg5,
|
||
|
|
arg6, arg7, arg8);
|
||
|
|
al = new ArrayList(8);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
al.Add(arg8);
|
||
|
|
outgoing.Record((uint)MessageType.AckEight, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckNine(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8, arg9):
|
||
|
|
{
|
||
|
|
clientEp.SendAckNine(arg1, arg2, arg3, arg4, arg5,
|
||
|
|
arg6, arg7, arg8, arg9);
|
||
|
|
al = new ArrayList(9);
|
||
|
|
al.Add(arg1);
|
||
|
|
al.Add(arg2);
|
||
|
|
al.Add(arg3);
|
||
|
|
al.Add(arg4);
|
||
|
|
al.Add(arg5);
|
||
|
|
al.Add(arg6);
|
||
|
|
al.Add(arg7);
|
||
|
|
al.Add(arg8);
|
||
|
|
al.Add(arg9);
|
||
|
|
outgoing.Record((uint)MessageType.AckNine, al);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckEnd():
|
||
|
|
{
|
||
|
|
clientEp.SendAckEnd();
|
||
|
|
outgoing.Record((uint)MessageType.AckEnd, null);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.ChannelClosed():
|
||
|
|
{
|
||
|
|
// Recovery
|
||
|
|
success = true;
|
||
|
|
goto exit;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case unsatisfiable:
|
||
|
|
{
|
||
|
|
DebugStub.Break();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
exit:
|
||
|
|
benchmarkExp.Release(clientEp);
|
||
|
|
if (success) {
|
||
|
|
//2006-9-13 hi:
|
||
|
|
//benchmarkImp.Release(serverEp);
|
||
|
|
//hi: an alternative way to solve 2006-9-13
|
||
|
|
delete serverEp;
|
||
|
|
try {
|
||
|
|
Monitor.Enter(benchmarkMonitor);
|
||
|
|
benchmarkImp = null;
|
||
|
|
Monitor.Pulse(benchmarkMonitor);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
Monitor.Exit(benchmarkMonitor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
delete serverEp;
|
||
|
|
//benchmarkImp = null;
|
||
|
|
}
|
||
|
|
return success;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override bool Recover()
|
||
|
|
{
|
||
|
|
bool success = false;
|
||
|
|
int[] arg = new int[9];
|
||
|
|
uint msg;
|
||
|
|
MessageType op;
|
||
|
|
IList args;
|
||
|
|
Object tmp;
|
||
|
|
BenchmarkContract.Imp:Start serverEp;
|
||
|
|
|
||
|
|
try {
|
||
|
|
Monitor.Enter(initMonitor);
|
||
|
|
if (initImp == null) {
|
||
|
|
Monitor.Wait(initMonitor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
Monitor.Exit(initMonitor);
|
||
|
|
}
|
||
|
|
|
||
|
|
assert initImp != null;
|
||
|
|
serverEp = initImp.Acquire();
|
||
|
|
|
||
|
|
switch receive {
|
||
|
|
case serverEp.Success():
|
||
|
|
break;
|
||
|
|
case serverEp.ChannelClosed():
|
||
|
|
delete serverEp;
|
||
|
|
throw new Exception("Channel was closed" +
|
||
|
|
" during recovery.\n");
|
||
|
|
break;
|
||
|
|
case unsatisfiable:
|
||
|
|
DebugStub.Break();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
initImp = null;
|
||
|
|
|
||
|
|
while (incoming.Playback(out msg, out args)) {
|
||
|
|
op = (MessageType)msg;
|
||
|
|
switch (op) {
|
||
|
|
case MessageType.GetCycleCount:
|
||
|
|
{
|
||
|
|
serverEp.SendGetCycleCount();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Null:
|
||
|
|
{
|
||
|
|
serverEp.SendNull();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.One:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
tmp = args[0];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[0] = (int)tmp;
|
||
|
|
}
|
||
|
|
serverEp.SendOne(arg[0]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Two:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 2; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendTwo(arg[0], arg[1]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Three:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 3; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendThree(arg[0], arg[1], arg[2]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Four:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 4; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendFour(arg[0], arg[1], arg[2], arg[3]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Five:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 5; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendFive(arg[0], arg[1], arg[2], arg[3],
|
||
|
|
arg[4]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Six:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 6; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendSix(arg[0], arg[1], arg[2], arg[3],
|
||
|
|
arg[4], arg[5]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Seven:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 7; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendSeven(arg[0], arg[1], arg[2], arg[3],
|
||
|
|
arg[4], arg[5], arg[6]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Eight:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendEight(arg[0], arg[1], arg[2], arg[3],
|
||
|
|
arg[4], arg[5], arg[6], arg[7]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.Nine:
|
||
|
|
{
|
||
|
|
if (args != null) {
|
||
|
|
for (int i = 0; i < 9; i++) {
|
||
|
|
tmp = args[i];
|
||
|
|
if (tmp != null) {
|
||
|
|
arg[i] = (int)tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serverEp.SendNine(arg[0], arg[1], arg[2], arg[3],
|
||
|
|
arg[4], arg[5], arg[6], arg[7],
|
||
|
|
arg[8]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case MessageType.EndOfBenchmark:
|
||
|
|
{
|
||
|
|
serverEp.SendEndOfBenchmark();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool result = true;
|
||
|
|
result = outgoing.Playback(out msg, out args);
|
||
|
|
op = (MessageType)msg;
|
||
|
|
|
||
|
|
if (!result) {
|
||
|
|
/*
|
||
|
|
DebugStub.Print("Playback: End of log.\n");
|
||
|
|
DebugStub.Print("Playback: {0} incoming messages\n",
|
||
|
|
__arglist(incoming.Count));
|
||
|
|
DebugStub.Print("Playback: {0} outgoing messages\n",
|
||
|
|
__arglist(outgoing.Count));
|
||
|
|
*/
|
||
|
|
success = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch receive {
|
||
|
|
case serverEp.CycleCount(cycle):
|
||
|
|
{
|
||
|
|
if (op != MessageType.CycleCount) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckNull():
|
||
|
|
{
|
||
|
|
if (op != MessageType.Null) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckOne(arg1):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckOne) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckTwo(arg1, arg2):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckTwo) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckThree(arg1, arg2, arg3):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckThree) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckFour(arg1, arg2, arg3, arg4):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckFour) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckFive(arg1, arg2, arg3, arg4, arg5):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckFive) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckSix(arg1, arg2, arg3, arg4, arg5, arg6):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckSix) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckSeven(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckSeven) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckEight(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckEight) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckNine(arg1, arg2, arg3, arg4, arg5, arg6,
|
||
|
|
arg7, arg8, arg9):
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckNine) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.AckEnd():
|
||
|
|
{
|
||
|
|
if (op != MessageType.AckEnd) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
success = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case serverEp.ChannelClosed():
|
||
|
|
throw new Exception("Server-side channel closed" +
|
||
|
|
" during recovery\n");
|
||
|
|
break;
|
||
|
|
case unsatisfiable:
|
||
|
|
DebugStub.Break();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} // loop
|
||
|
|
|
||
|
|
//2006-9-13 hi: This may cause an access violation with the
|
||
|
|
// fully hoisted style server.
|
||
|
|
//delete benchmarkImp.Acquire();
|
||
|
|
//DebugStub.Print("BJ: (2)\n");
|
||
|
|
//benchmarkImp.Release(serverEp);
|
||
|
|
|
||
|
|
//hi: an alternative way to above.
|
||
|
|
try {
|
||
|
|
Monitor.Enter(benchmarkMonitor);
|
||
|
|
if (benchmarkImp != null) {
|
||
|
|
Monitor.Wait(benchmarkMonitor);
|
||
|
|
}
|
||
|
|
benchmarkImp = new TRef<BenchmarkContract.Imp:Ready>(serverEp);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
Monitor.Exit(benchmarkMonitor);
|
||
|
|
}
|
||
|
|
|
||
|
|
return success;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|