Esempio n. 1
0
 public void ShouldGuardPeripheralReads([Range(1, 4)] int cpuCount)
 {
     using (var emulation = new Emulation())
         using (var machine = new Machine())
         {
             emulation.AddMachine(machine);
             var sysbus = machine.SystemBus;
             cpuCount.Times(() => sysbus.Register(new ActivelyAskingCPU(machine, 0), new CPURegistrationPoint()));
             var peripheral = new ActivelyAskedPeripheral();
             sysbus.Register(peripheral, 0.To(1000));
             machine.Start();
             Thread.Sleep(1000);
             machine.Pause();
             Assert.IsFalse(peripheral.Failed, "Peripheral was concurrently accessed from multiple CPUs.");
         }
 }
Esempio n. 2
0
 public void ShouldPauseAndResumeOnlyOnce()
 {
     using (var emulation = new Emulation())
         using (var machine = new Machine())
         {
             emulation.AddMachine(machine);
             var sb   = machine.SystemBus;
             var mock = new Mock <IHasOwnLife>();
             sb.Register(mock.As <IDoubleWordPeripheral>().Object, 0.To(100));
             sb.Register(new Mock <ICPU>().Object, new CPURegistrationPoint());
             machine.Start();
             PauseResumeRetries.Times(machine.Pause);
             mock.Verify(x => x.Pause(), Times.Once());
             PauseResumeRetries.Times(machine.Start);
             mock.Verify(x => x.Resume(), Times.Once());
         }
 }
        public void ShouldHandleManagedThreads()
        {
            var counter = 0;
            var a       = (Action)(() => counter++);

            using (var emulation = new Emulation())
            {
                var machine = new Machine();

                emulation.MasterTimeSource.Quantum            = Time.TimeInterval.FromMilliseconds(1000);
                emulation.MasterTimeSource.AdvanceImmediately = true;
                machine.LocalTimeSource.Quantum            = Time.TimeInterval.FromMilliseconds(1000);
                machine.LocalTimeSource.AdvanceImmediately = true;

                emulation.AddMachine(machine);

                var mt = machine.ObtainManagedThread(a, 1);

                emulation.RunToNearestSyncPoint();
                emulation.RunToNearestSyncPoint();
                emulation.RunToNearestSyncPoint();
                Assert.AreEqual(0, counter);

                mt.Start();

                emulation.RunToNearestSyncPoint();
                Assert.AreEqual(1, counter);

                emulation.RunToNearestSyncPoint();
                Assert.AreEqual(2, counter);

                emulation.RunToNearestSyncPoint();
                Assert.AreEqual(3, counter);

                mt.Stop();

                emulation.RunToNearestSyncPoint();
                emulation.RunToNearestSyncPoint();
                emulation.RunToNearestSyncPoint();
                Assert.AreEqual(3, counter);
            }
        }