public void ShouldExecuteDelayedActionAddedLaterInNearestSyncedState()
{
var time = TimeInterval.Empty;
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0, (sts, th, ti) =>
{
if (sts.NumberOfRounds == 10)
{
timeSlave.ExecuteInNearestSyncedState(ts =>
{
time = ts.TimeElapsed;
});
}
return(true);
});
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// the first round does not increment the time - it just triggers a sync point
master.Run(10 + 1);
Assert.AreEqual(100, time.Ticks);
}
}
public void ShouldHandleSlaveTimeSourceWithDifferentQuantum()
{
const int roundsCount = 3;
using (var timeSource = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(100), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0);
timeSource.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// the first round does not increment the time - it just triggers a sync point
timeSource.Run(roundsCount + 1);
Assert.AreEqual(roundsCount + 1, timeSource.NumberOfSyncPoints);
Assert.AreEqual(10 * roundsCount + 1, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(10 * roundsCount, timeSink.NumberOfRounds);
Assert.AreEqual(roundsCount * timeSource.Quantum.Ticks, timeSource.ElapsedVirtualTime.Ticks);
Assert.AreEqual(roundsCount * timeSource.Quantum.Ticks, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(roundsCount * timeSource.Quantum.Ticks, timeSink.ElapsedVirtualTime.Ticks);
}
}
public void ShouldHandleSlaveTimeSourceWithNotAlignedQuantum()
{
using (var timeSource = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(3), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0);
timeSource.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// the first round does not increment the time - it just triggers a sync point
timeSource.Run(1);
Assert.AreEqual(1, timeSource.NumberOfSyncPoints);
Assert.AreEqual(0, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(0, timeSink.NumberOfRounds);
Assert.AreEqual(0, timeSource.ElapsedVirtualTime.Ticks);
Assert.AreEqual(0, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(0, timeSink.ElapsedVirtualTime.Ticks);
timeSource.Run(1);
Assert.AreEqual(2, timeSource.NumberOfSyncPoints);
Assert.AreEqual(4, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(3, timeSink.NumberOfRounds);
Assert.AreEqual(10, timeSource.ElapsedVirtualTime.Ticks);
Assert.AreEqual(9, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(9, timeSink.ElapsedVirtualTime.Ticks);
timeSource.Run(1);
Assert.AreEqual(3, timeSource.NumberOfSyncPoints);
Assert.AreEqual(7, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(6, timeSink.NumberOfRounds);
Assert.AreEqual(20, timeSource.ElapsedVirtualTime.Ticks);
Assert.AreEqual(18, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(18, timeSink.ElapsedVirtualTime.Ticks);
timeSource.Run(1);
Assert.AreEqual(4, timeSource.NumberOfSyncPoints);
Assert.AreEqual(11, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(10, timeSink.NumberOfRounds);
Assert.AreEqual(30, timeSource.ElapsedVirtualTime.Ticks);
Assert.AreEqual(30, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(30, timeSink.ElapsedVirtualTime.Ticks);
}
}
public void ShouldExecuteDelayedActionInNearestSyncedStateExactlyOnce()
{
var time = TimeInterval.Empty;
var alreadyDone = false;
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0, (sts, th, ti) =>
{
if (alreadyDone)
{
return(true);
}
timeSlave.ExecuteInNearestSyncedState(ts =>
{
time = ts.TimeElapsed;
});
alreadyDone = true;
return(true);
});
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
master.Run(1);
Assert.AreEqual(0, time.Ticks);
Assert.AreEqual(false, alreadyDone);
// here we must run 2 rounds as delayed actions are executed at the beginning of each round
master.Run(1);
Assert.AreEqual(true, alreadyDone);
Assert.AreEqual(10, time.Ticks);
master.Run(1);
Assert.AreEqual(10, time.Ticks);
}
}
public Machine()
{
LocalTimeSource = new SlaveTimeSource(this);
LocalTimeSource.TimePassed += HandleTimeProgress;
collectionSync = new object();
pausingSync = new object();
disposedSync = new object();
clockSource = new BaseClockSource();
localNames = new Dictionary <IPeripheral, string>();
PeripheralsGroups = new PeripheralsGroupsManager(this);
ownLifes = new HashSet <IHasOwnLife>();
pausedState = new PausedState(this);
SystemBus = new SystemBus(this);
registeredPeripherals = new MultiTree <IPeripheral, IRegistrationPoint>(SystemBus);
userStateHook = delegate
{
};
userState = string.Empty;
SetLocalName(SystemBus, SystemBusName);
}
public void ShouldNotTickDisconnectedSlaveTimeSource()
{
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0);
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// the first round does not increment the time - it just triggers a sync point
master.Run(1 + 1);
Assert.AreEqual(2, master.NumberOfSyncPoints);
Assert.AreEqual(2, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(1, timeSink.NumberOfRounds);
Assert.AreEqual(10, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSink.ElapsedVirtualTime.Ticks);
timeSlave.TimeHandle.Dispose();
master.Run(1);
Assert.AreEqual(3, master.NumberOfSyncPoints);
Assert.AreEqual(2, timeSlave.NumberOfSyncPoints);
Assert.AreEqual(1, timeSink.NumberOfRounds);
Assert.AreEqual(20, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSink.ElapsedVirtualTime.Ticks);
}
}
public void ShouldExecuteNonAlignedDelayedActionInSyncedStateExactlyOnce()
{
var time = TimeInterval.Empty;
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0, (sts, th, ti) =>
{
if (sts.NumberOfRounds != 1)
{
return(true);
}
timeSlave.ExecuteInSyncedState(ts =>
{
time = timeSlave.ElapsedVirtualTime;
}, new TimeStamp(TimeInterval.FromTicks(31), master.Domain));
return(true);
});
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
master.Run(4);
Assert.AreEqual(0, time.Ticks);
master.Run(1);
Assert.AreEqual(40, time.Ticks);
master.Run(1);
Assert.AreEqual(40, time.Ticks);
}
}
public void ShouldHandleBlockingAtTheEndOfGrantedInterval()
{
var indicator = false;
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSink = new MoreComplicatedTimeSink("A"))
{
// tester thread
new Thread(() =>
{
this.Trace();
timeSink.ExecuteOnDispatcherThread((ts, ti) =>
{
this.Trace();
Assert.AreEqual(10, ti.Ticks);
ts.TimeHandle.ReportBackAndBreak(TimeInterval.Empty);
});
this.Trace();
// here we sleep to make sure that master won't go further
Thread.Sleep(5000);
this.Trace();
Assert.AreEqual(10, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
indicator = true;
this.Trace();
timeSink.ExecuteOnDispatcherThread((ts, ti) =>
{
this.Trace();
Assert.AreEqual(0, ti.Ticks);
ts.TimeHandle.ReportBackAndContinue(TimeInterval.Empty);
});
timeSink.ExecuteOnDispatcherThread((ts, ti) =>
{
this.Trace();
Assert.AreEqual(10, ti.Ticks);
ts.TimeHandle.ReportBackAndContinue(TimeInterval.Empty);
});
})
{
Name = "tester thread"
}.Start();
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// just to pass the first syncpoint
master.Run(1);
this.Trace();
master.Run(1);
this.Trace();
Assert.IsTrue(indicator);
Assert.AreEqual(10, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
master.Run(1);
Assert.AreEqual(20, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(20, timeSlave.ElapsedVirtualTime.Ticks);
}
}
public void ShouldHandleTwoBlockingSinks()
{
var indicator = false;
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSinkA2 = new MoreComplicatedTimeSink("A"))
using (var timeSinkB2 = new MoreComplicatedTimeSink("B"))
{
var ttt = new Thread(() =>
{
Parallel(
() =>
{
timeSinkA2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(10, ti.Ticks);
var timeUsed = TimeInterval.FromTicks(4);
var timeLeft = ti - timeUsed;
sts.TimeHandle.ReportBackAndBreak(timeLeft);
});
},
() =>
{
timeSinkB2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(10, ti.Ticks);
var timeUsed = TimeInterval.FromTicks(6);
var timeLeft = ti - timeUsed;
sts.TimeHandle.ReportBackAndBreak(timeLeft);
});
}
);
// here we sleep to make sure that master won't go further
this.Trace();
Thread.Sleep(5000);
this.Trace();
Assert.AreEqual(4, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(4, timeSlave.ElapsedVirtualTime.Ticks);
Parallel(
() =>
{
timeSinkA2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(6, ti.Ticks);
var timeUsed = TimeInterval.FromTicks(4);
var timeLeft = ti - timeUsed;
sts.TimeHandle.ReportBackAndBreak(timeLeft);
});
},
() =>
{
timeSinkB2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(4, ti.Ticks);
sts.TimeHandle.ReportBackAndBreak(ti);
});
}
);
// here we sleep to make sure that master won't go further
this.Trace();
Thread.Sleep(5000);
this.Trace();
Assert.AreEqual(6, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(6, timeSlave.ElapsedVirtualTime.Ticks);
Parallel(
() =>
{
timeSinkA2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(2, ti.Ticks);
sts.TimeHandle.ReportBackAndBreak(ti);
});
},
() =>
{
timeSinkB2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(4, ti.Ticks);
sts.TimeHandle.ReportBackAndContinue(TimeInterval.Empty);
});
}
);
// here we sleep to make sure that master won't go further
this.Trace();
Thread.Sleep(5000);
this.Trace();
Assert.AreEqual(8, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(8, timeSlave.ElapsedVirtualTime.Ticks);
Parallel(
() =>
{
timeSinkA2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.AreEqual(2, ti.Ticks);
indicator = true;
sts.TimeHandle.ReportBackAndContinue(TimeInterval.Empty);
});
},
() =>
{
timeSinkB2.ExecuteOnDispatcherThread((sts, ti) =>
{
this.Trace();
Assert.Fail();
}, false); // do not wait for finish
Thread.Sleep(10000); // wait for 10s and check if Fail() is called
}
);
})
{
Name = "tester thread"
};
ttt.Start();
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSinkA2);
timeSlave.RegisterSink(timeSinkB2);
// just to pass the first syncpoint
master.Run(1);
master.Run(1);
Assert.IsTrue(indicator);
this.Trace();
Assert.AreEqual(10, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
ttt.Join();
}
}
public void ShouldUpdateExecutedTimeAfterBlocking()
{
var indicator = false;
var firstTime = true;
var threadToSinkSync = new ManualResetEvent(false);
var sinkToThreadSync = new ManualResetEvent(false);
using (var master = new MasterTimeSource {
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
using (var timeSlave = new SlaveTimeSource(null)
{
Quantum = TimeInterval.FromTicks(10), AdvanceImmediately = true
})
{
var timeSink = new SimpleTimeSink(1.0, (sts, th, ti) =>
{
if (firstTime)
{
Assert.AreEqual(10, ti.Ticks);
firstTime = false;
var timeUsed = TimeInterval.FromTicks(ti.Ticks / 2);
var timeLeft = ti - timeUsed;
sts.ElapsedVirtualTime += timeUsed;
th.ReportBackAndBreak(timeLeft);
sinkToThreadSync.Set();
threadToSinkSync.WaitOne();
}
else
{
Assert.AreEqual(5, ti.Ticks);
sts.ElapsedVirtualTime += ti;
th.ReportBackAndContinue(TimeInterval.Empty);
}
return(false);
});
// tester thread
new Thread(() =>
{
// wait for the pause
sinkToThreadSync.WaitOne();
// here we sleep to make sure that master won't go further
Thread.Sleep(5000);
Assert.AreEqual(5, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(5, timeSlave.ElapsedVirtualTime.Ticks);
indicator = true;
threadToSinkSync.Set();
}).Start();
master.RegisterSink(timeSlave);
timeSlave.RegisterSink(timeSink);
// just to pass the first syncpoint
master.Run(1);
master.Run(1);
Assert.IsTrue(indicator);
Assert.AreEqual(10, master.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSlave.ElapsedVirtualTime.Ticks);
Assert.AreEqual(10, timeSink.ElapsedVirtualTime.Ticks);
}
}
