/// <summary> /// Captures a snapshot of the program state. /// </summary> /// <param name="traceStep">Trace step</param> internal void CaptureState(TraceStep traceStep) { var fingerprint = PSharpRuntime.GetProgramState(); var enabledMachines = PSharpRuntime.BugFinder.GetEnabledMachines(); var state = new State(fingerprint, enabledMachines, PSharpRuntime.LivenessChecker.GetMonitorStatus()); if (traceStep.Type == TraceStepType.SchedulingChoice) { Output.Debug("<LivenessDebug> Captured program state '{0}' at " + "scheduling choice.", fingerprint.GetHashCode()); } else if (traceStep.Type == TraceStepType.NondeterministicChoice) { Output.Debug("<LivenessDebug> Captured program state '{0}' at nondeterministic " + "choice '{1}'.", fingerprint.GetHashCode(), traceStep.Choice); } else if (traceStep.Type == TraceStepType.FairNondeterministicChoice) { Output.Debug("<LivenessDebug> Captured program state '{0}' at fair nondeterministic choice " + "'{1}-{2}'.", fingerprint.GetHashCode(), traceStep.NondetId, traceStep.Choice); } var stateExists = this.StateMap.Values.Any(val => val.Fingerprint.Equals(fingerprint)); this.StateMap.Add(traceStep, state); if (stateExists && PSharpRuntime.Configuration.CheckLiveness) { Output.Debug("<LivenessDebug> Detected potential infinite execution."); PSharpRuntime.LivenessChecker.CheckLivenessAtTraceCycle(state.Fingerprint, this.StateMap); } }
internal void AfterTableClientState(TableClientState triggerState, Action action) { OnTableClientState(triggerState, () => { PSharpRuntime.SendEvent(machineId, new GenericDispatchableEvent(), new ActionDispatchable(action)); return(Task.CompletedTask); }); }
protected async Task RunAsync(Func <IMachineRuntime, Task> test, Configuration configuration = null) { configuration = configuration ?? GetConfiguration(); ILogger logger; if (configuration.IsVerbose) { logger = new TestOutputLogger(this.TestOutput, true); } else { logger = new NulLogger(); } try { var runtime = PSharpRuntime.Create(configuration); runtime.SetLogger(logger); await test(runtime); } catch (Exception ex) { Assert.False(true, ex.Message + "\n" + ex.StackTrace); } finally { logger.Dispose(); } }
static void Main(string[] args) { var runtime = PSharpRuntime.Create(); Test.Execute(runtime); Console.ReadLine(); }
internal override async Task HandleLinearizationPoint(IList <TableResult> successfulBatchResult) { PSharpRuntime.Assert(currentReferenceOutcome == null, "The call already reported a linearization point."); this.successfulBatchResult = successfulBatchResult; currentReferenceOutcome = await Catching <StorageException> .Task( annotationProxy.AnnotateLastBackendCallAsync(currentReferenceCall, null)); }
public void TestCreateWithId5() { var r = PSharpRuntime.Create(); var failed = false; var tcs = new TaskCompletionSource <bool>(); r.OnFailure += delegate { failed = true; tcs.SetResult(false); }; try { var m1 = r.CreateMachineIdFromName(typeof(M2), "M2"); r.CreateMachine(m1, typeof(M2)); r.CreateMachine(m1, typeof(M2)); } catch (Exception) { failed = true; tcs.SetResult(false); } tcs.Task.Wait(); Assert.True(failed); }
async Task RunCallAsync(TableCall originalCall, MirrorTableCall referenceCall) { // TODO: All assertions should show what the call was. // XXX: We currently have no way to detect incorrect interleaving of // backend calls and AnnotateLastOutgoingCall here. Most incorrect // interleavings will cause an error on the TablesMachine, but some // may go undetected. // For now, we're not doing streaming queries at all, so we don't have // to worry about how to handle them. currentReferenceCall = referenceCall; object actualOutcome = await Catching <StorageException> .Task(originalCall(migratingTable)); // Verify that successfulBatchResult was correct if specified. // (Ideally, we'd also catch if it isn't specified when it should // be, but that's less of a risk as it will likely cause ETag // mismatches anyway.) if (successfulBatchResult != null) { var successfulBatchOutcome = new Outcome <object, StorageException>(successfulBatchResult); PSharpRuntime.Assert(BetterComparer.Instance.Equals(successfulBatchOutcome, actualOutcome), "{0} incorrect successfulBatchResult:\n{1}\nExpected:\n{2}\n", machineId, BetterComparer.ToString(successfulBatchOutcome), BetterComparer.ToString(actualOutcome)); } PSharpRuntime.Assert(currentReferenceOutcome != null, "The call completed without reporting a linearization point."); PSharpRuntime.Assert(BetterComparer.Instance.Equals(actualOutcome, currentReferenceOutcome), "{0} call outcome:\n{1}\nExpected:\n{2}\n", machineId, BetterComparer.ToString(actualOutcome), BetterComparer.ToString(currentReferenceOutcome)); // Reset fields currentReferenceCall = null; successfulBatchResult = null; currentReferenceOutcome = null; }
public void Monitor_should_notify_safety_bug_if_it_is_existing() { // Arrange var configuration = Configuration.Create().WithMonitorsInProductionEnabled(); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); var safetyMonitor = runtimeHost.New(MonitorInterface.Sender <ISafetyMonitorSender>().Bundler <ISafetyMonitorBundler>().Receiver <SafetyMonitorReceiver>()); // Act var messages = new MessageCollection(); safetyMonitor.Configure(new ConfigureSafetyMonitor(messages)); var storageNodeId = runtime.NewMachine(typeof(StorageNode)); var storageNodeMock = new Mock <IStorageNodeSender>(); storageNodeMock.SetupGet(_ => _.Id).Returns(storageNodeId); safetyMonitor.Handshake(new HandshakeSafetyMonitor(new[] { storageNodeMock.Object })); // Assert var expectedExType = typeof(PSharpRuntime).Assembly.GetTypes().First(_ => _.FullName == "Microsoft.PSharp.AssertionFailureException"); Assert.Throws(expectedExType, () => safetyMonitor.Ack(new Ack())); }
static void Main(string[] args) { // Optional: increases verbosity level to see the P# runtime log. var configuration = Configuration.Create().WithVerbosityEnabled(2); // Creates a new P# runtime instance, and passes an optional configuration. var runtime = PSharpRuntime.Create(configuration); // Creates and installs a custom logger. ILogger myLogger = new MyLogger(); runtime.SetLogger(myLogger); // Executes the P# program. Program.Execute(runtime); // Disposes the logger and removes it from the runtime. myLogger.Dispose(); runtime.RemoveLogger(); // The P# runtime executes asynchronously, so we wait // to not terminate the process. Console.WriteLine("Press Enter to terminate..."); Console.ReadLine(); }
public void TestProcessedOrDropped() { var config = Configuration.Create(); config.EnableMonitorsInProduction = true; var runtime = PSharpRuntime.Create(config); var tcs = new TaskCompletionSource <bool>(); runtime.RegisterMonitor(typeof(Monitor3)); runtime.InvokeMonitor(typeof(Monitor3), new E(tcs)); runtime.OnFailure += delegate { Assert.True(false); tcs.SetResult(false); }; runtime.OnEventDropped += delegate(Event e, MachineId target) { runtime.InvokeMonitor(typeof(Monitor3), new EventDropped()); }; var m = runtime.CreateMachine(typeof(M3c)); runtime.CreateMachine(typeof(M3a), new E(m)); runtime.CreateMachine(typeof(M3b), new E(m)); tcs.Task.Wait(5000); }
public static void Main(String[] args) { var runtime = PSharpRuntime.Create(); Program.Execute(runtime); Console.ReadLine(); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(LivenessMonitor)); runtime.CreateMachine(typeof(Environment)); runtime.Wait(); Console.WriteLine("Done!"); }
/// <summary> /// Initializes the network provider. /// </summary> /// <param name="runtime">PSharpRuntime</param> /// <param name="applicationAssembly">ApplicationAssembly</param> public void Initialize(PSharpRuntime runtime, Assembly applicationAssembly) { this.Runtime = runtime; this.ApplicationAssembly = applicationAssembly; //var channels = new Dictionary<string, IRemoteCommunication>(); if (runtime.Configuration.ContainerId == 0) { Uri address = new Uri("http://" + this.IpAddress + ":" + this.Port + "/request/" + 1 + "/"); WSHttpBinding binding = new WSHttpBinding(); EndpointAddress endpoint = new EndpointAddress(address); this.Channel = ChannelFactory <IRemoteCommunication> .CreateChannel(binding, endpoint); } else { Uri address = new Uri("http://" + this.IpAddress + ":" + this.Port + "/request/" + 0 + "/"); WSHttpBinding binding = new WSHttpBinding(); EndpointAddress endpoint = new EndpointAddress(address); this.Channel = ChannelFactory <IRemoteCommunication> .CreateChannel(binding, endpoint); } }
/// <summary> /// Creates a new machine of the given type with an optional payload. /// </summary> /// <param name="type">Type of the machine</param> /// <param name="payload">Optional payload</param> /// <returns>Machine id</returns> MachineId IRemoteCommunication.CreateMachine(string type, params Object[] payload) { Output.PrintLine("Received request to create machine of type {0}", type); var resolvedType = PSharpRuntime.AppAssembly.GetType(type); return(PSharpRuntime.CreateMachine(resolvedType, payload)); }
public static void Execute(PSharpRuntime runtime) { var s = (StateImpl)PTesterCommandLine.main_s.Clone(); s.UserBooleanChoice = delegate() { return(runtime.Random()); }; s.CreateMachineCallback = delegate(PrtImplMachine machine) { PTesterCommandLine.coverage.DeclareMachine(machine); }; s.DequeueCallback = delegate(PrtImplMachine machine, string evName, string senderMachineName, string senderMachineStateName) { PTesterCommandLine.coverage.ReportDequeue(machine, evName, senderMachineName, senderMachineStateName); }; s.StateTransitionCallback = delegate(PrtImplMachine machine, PrtState from, PrtState to, string reason) { PTesterCommandLine.coverage.ReportStateTransition(machine, from, to, reason); }; PTesterCommandLine.currentImpl = s; runtime.CreateMachine(typeof(PSharpMachine), new MachineInitEvent(s)); }
public void Monitor_should_not_notify_safety_bug_if_it_is_not_existing() { // Arrange var configuration = Configuration.Create().WithMonitorsInProductionEnabled(); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); var safetyMonitor = runtimeHost.New(MonitorInterface.Sender <ISafetyMonitorSender>().Bundler <ISafetyMonitorBundler>().Receiver <SafetyMonitorReceiver>()); // Act var messages = new MessageCollection(); safetyMonitor.Configure(new ConfigureSafetyMonitor(messages)); var storageNodeId = runtime.NewMachine(typeof(StorageNode)); var storageNodeMock = new Mock <IStorageNodeSender>(); storageNodeMock.SetupGet(_ => _.Id).Returns(storageNodeId); safetyMonitor.Handshake(new HandshakeSafetyMonitor(new[] { storageNodeMock.Object })); safetyMonitor.LogUpdated(new LogUpdated(storageNodeMock.Object, 42)); // Assert Assert.DoesNotThrow(() => safetyMonitor.Ack(new Ack())); }
public void TestNoMemoryLeakInEventSending() { var runtime = PSharpRuntime.Create(); Program.Execute(runtime); runtime.Wait(); }
static string StartClients(string sctx, SynchronizedLogger logger, out DomainCommunicationProvider clientsNetworkProvider) { var configuration = Configuration.Create().WithMonitorsInProductionEnabled().WithVerbosityEnabled(2); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); clientsNetworkProvider = new DomainCommunicationProvider(runtimeHost, "clients"); runtimeHost.SetNetworkProvider(clientsNetworkProvider); runtimeHost.SetLogger(logger); var messages = new MessageCollection(); messages.CollectionChanged += (sender, e) => logger.WriteLine(e.NewItems[0].ToString()); var ctx = sctx.FromJson <DistributedStorageContext>(); var synchronizable = Synchronizable.Empty(); foreach (var storageNode in ctx.StorageNodes) { var waitIfHandledReplReq = logger.MachineActionHandledWait((machineId, _, actionName) => Equals(machineId, storageNode.Id) && actionName == "HandleReplReq"); synchronizable = synchronizable.Then(waitIfHandledReplReq.Delay(10)); } logger.ApplySynchronization(synchronizable); NewClients(runtimeHost, ctx, messages); logger.WaitForWriting(6000); return(ctx.ToJson()); }
public void TestNoMemoryLeakAfterHalt() { var runtime = PSharpRuntime.Create(); Program.Execute(runtime); runtime.Wait(); }
public void Context_should_return_same_Machine_if_it_is_in_local_and_single_application() { // Arrange var ctx = default(DistributedStorageContext); var expected = default(int); var actual = default(int); // Act { var configuration = Configuration.Create(); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); ctx = runtimeHost.New <DistributedStorageContext>(); ctx.Server = runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>()); expected = RuntimeHelpers.GetHashCode(ctx.Server); } { actual = RuntimeHelpers.GetHashCode(ctx.Server); } // Assert Assert.AreEqual(expected, actual); }
public void Context_should_return_same_Machine_if_it_is_in_remote_and_single_application() { // Arrange var expected = default(int); var actual = default(int); var parameter = default(string); // Act { var configuration = Configuration.Create(); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); var ctx = runtimeHost.New <DistributedStorageContext>(); ctx.Server = runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>()); expected = RuntimeHelpers.GetHashCode(ctx.Server); parameter = ctx.ToJson(); } GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); { var ctx = parameter.FromJson <DistributedStorageContext>(); actual = RuntimeHelpers.GetHashCode(ctx.Server); } // Assert Assert.AreEqual(expected, actual); }
public void Machine_can_be_created_faster_than_the_first_time() { AppDomain.CurrentDomain.RunAtIsolatedDomain(() => { // Arrange var configuration = Configuration.Create(); var runtime = PSharpRuntime.Create(configuration); var runtimeHost = HostInfo.NewRuntimeHost(runtime); // Act var sw1 = Stopwatch.StartNew(); runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>()); var elapsed1 = sw1.ElapsedTicks; var sw10 = Stopwatch.StartNew(); for (var i = 0; i < 10; i++) { runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>()); } var elapsed10 = sw10.ElapsedTicks; // Assert Assert.Less(elapsed10, elapsed1 / 10); }); }
public void TestAssertFailureEventHandler() { var tcsFail = new TaskCompletionSource <bool>(); int count = 0; PSharpRuntime runtime = PSharpRuntime.Create(); runtime.OnFailure += delegate(Exception exception) { if (!(exception is MachineActionExceptionFilterException)) { count++; tcsFail.SetException(exception); } }; var tcs = new TaskCompletionSource <bool>(); runtime.CreateMachine(typeof(M), new Configure(tcs)); tcs.Task.Wait(); Task.Delay(10).Wait(); // give it some time AggregateException ex = Assert.Throws <AggregateException>(() => tcsFail.Task.Wait()); Assert.IsType <AssertionFailureException>(ex.InnerException); Assert.Equal(1, count); }
public void TestUnhandledExceptionEventHandler() { var tcsFail = new TaskCompletionSource <bool>(); int count = 0; bool sawFilterException = false; PSharpRuntime runtime = PSharpRuntime.Create(); runtime.OnFailure += delegate(Exception exception) { // This test throws an exception that we should receive a filter call for if (exception is MachineActionExceptionFilterException) { sawFilterException = true; return; } count++; tcsFail.SetException(exception); }; var tcs = new TaskCompletionSource <bool>(); runtime.CreateMachine(typeof(N), new Configure(tcs)); tcs.Task.Wait(); Task.Delay(10).Wait(); // give it some time AggregateException ex = Assert.Throws <AggregateException>(() => tcsFail.Task.Wait()); Assert.IsType <AssertionFailureException>(ex.InnerException); Assert.IsType <InvalidOperationException>(ex.InnerException.InnerException); Assert.Equal(1, count); Assert.True(sawFilterException); }
public void TestNullCustomLoggerFail() { PSharpRuntime runtime = PSharpRuntime.Create(); InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() => runtime.SetLogger(null)); Assert.Equal("Cannot install a null logger.", ex.Message); }
static void Main(string[] args) { var configuration = Configuration.Create().WithVerbosityEnabled(1); var runtime = PSharpRuntime.Create(configuration); Execute(runtime); Console.ReadLine(); }
void DispatchTableCall() { numTableCalls++; // Crude liveness check, since a monitor did not work (see below). PSharpRuntime.Assert(numTableCalls <= MigrationModel.TABLE_CALL_LIMIT, "A service machine may be in an infinite loop."); DispatchPayload(); }
public void TestAssertFailureNoEventHandler() { PSharpRuntime runtime = PSharpRuntime.Create(); var tcs = new TaskCompletionSource <bool>(); runtime.CreateMachine(typeof(M), new Configure(tcs)); tcs.Task.Wait(); }
public void TestCreateWithId9() { var r = PSharpRuntime.Create(); var m1 = r.CreateMachineIdFromName(typeof(M4), "M4"); var m2 = r.CreateMachineIdFromName(typeof(M4), "M4"); Assert.True(m1.Equals(m2)); }
public static void Execute(PSharpRuntime runtime) { // Monitors must be registered before the first P# machine // gets created (which will kickstart the runtime). runtime.RegisterMonitor(typeof(Safety)); runtime.RegisterMonitor(typeof(Liveness)); runtime.CreateMachine(typeof(Driver), new Driver.Config(2)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Server), "TheUltimateServerMachine"); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(WatchDog)); runtime.CreateMachine(typeof(EventHandler)); }
/// <summary> /// Constructor. /// </summary> /// <param name="type">Type</param> /// <param name="runtime">PSharpRuntime</param> internal MachineId(Type type, PSharpRuntime runtime) { this.Runtime = runtime; lock (MachineId.TypeIdCounter) { if (!MachineId.TypeIdCounter.ContainsKey(type)) { MachineId.TypeIdCounter.Add(type, 0); } this.Value = MachineId.IdCounter++; this.Type = type.Name; this.MVal = MachineId.TypeIdCounter[type]++; this.IpAddress = ""; this.Port = ""; } }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Environment)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Environment), new Environment.Config(Test.NumOfNodes)); }
/// <summary> /// Constructor. /// </summary> /// <param name="runtime">PSharpRuntime</param> public DefaultNetworkProvider(PSharpRuntime runtime) { this.Runtime = runtime; this.LocalEndPoint = ""; }
public static void Execute(PSharpRuntime runtime) { // The type "A" is visible to IntelliSense // (after building once) runtime.CreateMachine(typeof(A)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Broker), new Broker.Config(10)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(EventHandler)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(ClusterManager)); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(InvariantMonitor)); runtime.RegisterMonitor(typeof(ServerResponseSeqMonitor)); runtime.CreateMachine(typeof(Environment)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(TwoPhaseCommit)); }
/// <summary> /// Constructor. /// </summary> /// <param name="type">Machine type</param> /// <param name="friendlyName">Friendly machine name</param> /// <param name="runtime">PSharpRuntime</param> internal MachineId(Type type, string friendlyName, PSharpRuntime runtime) { this.FriendlyName = friendlyName; this.Runtime = runtime; this.Type = type.FullName; this.EndPoint = this.Runtime.NetworkProvider.GetLocalEndPoint(); this.Value = Interlocked.Increment(ref IdCounter); if (this.FriendlyName != null && this.FriendlyName.Length > 0) { this.Name = string.Format("{0}({1})", this.FriendlyName, this.Value); } else { this.Name = string.Format("{0}({1})", this.Type, this.Value); } }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Receiver)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(TaskCreator)); }
public static void Send(PSharpRuntime runtime, MachineId target) { runtime.SendEvent(target, new E1(2)); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(SafetyMonitor)); runtime.CreateMachine(typeof(ClusterManager)); }
/// <summary> /// Initializes the network provider. /// </summary> /// <param name="runtime">PSharpRuntime</param> /// <param name="applicationAssembly">ApplicationAssembly</param> public void Initialize(PSharpRuntime runtime, Assembly applicationAssembly) { this.Runtime = runtime; this.ApplicationAssembly = applicationAssembly; //var channels = new Dictionary<string, IRemoteCommunication>(); if (runtime.Configuration.ContainerId == 0) { Uri address = new Uri("http://" + this.IpAddress + ":" + this.Port + "/request/" + 1 + "/"); WSHttpBinding binding = new WSHttpBinding(); EndpointAddress endpoint = new EndpointAddress(address); this.Channel = ChannelFactory<IRemoteCommunication>.CreateChannel(binding, endpoint); } else { Uri address = new Uri("http://" + this.IpAddress + ":" + this.Port + "/request/" + 0 + "/"); WSHttpBinding binding = new WSHttpBinding(); EndpointAddress endpoint = new EndpointAddress(address); this.Channel = ChannelFactory<IRemoteCommunication>.CreateChannel(binding, endpoint); } }
/// <summary> /// Constructor. /// </summary> /// <param name="runtime">PSharpRuntime</param> /// <param name="machineTasks">Machine tasks</param> internal TaskWrapperScheduler(PSharpRuntime runtime, ConcurrentBag<Task> machineTasks) { this.Runtime = runtime; this.MachineTasks = machineTasks; this.WrappedTasks = new ConcurrentBag<Task>(); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Employee)); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(M)); runtime.CreateMachine(typeof(Environment)); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(ValMachineCheck)); runtime.CreateMachine(typeof(GodMachine)); }
/// <summary> /// Constructor. /// </summary> /// <param name="runtime">PSharpRuntime</param> /// <param name="machineTasks">Machine tasks</param> internal TaskWrapperScheduler(PSharpRuntime runtime, List<Task> machineTasks) { this.Runtime = runtime; this.MachineTasks = machineTasks; this.WrappedTasks = new List<Task>(); }
/// <summary> /// Initializes the P# runtime. /// </summary> private static void InitializePSharpRuntime() { Container.PSharpRuntime = PSharpRuntime.Create(Container.Configuration, Container.NetworkProvider); Container.NetworkProvider.Initialize(Container.PSharpRuntime, Container.RemoteApplicationAssembly); Container.NotifyManagerInitialization(); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Driver), new Driver.Config(30)); }
public static void Execute(PSharpRuntime runtime) { runtime.RegisterMonitor(typeof(LivenessMonitor)); runtime.CreateMachine(typeof(M)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Simulation), new Simulation.Config(Test.NumOfBodies, Test.NumOfSteps)); }
public static void Execute(PSharpRuntime runtime) { runtime.CreateMachine(typeof(Program)); }
/// <summary> /// Sets the id of this machine. /// </summary> /// <param name="mid">MachineId</param> internal void SetMachineId(MachineId mid) { this.Id = mid; this.Runtime = mid.Runtime; }