public static void Execute(PSharpRuntime runtime)
 {
     runtime.RegisterMonitor(typeof(ValMachineCheck));
     runtime.CreateMachine(typeof(GodMachine));
 }

 /// <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(Receiver));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.CreateMachine(typeof(Employee));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.RegisterMonitor(typeof(SafetyMonitor));
     runtime.CreateMachine(typeof(ClusterManager));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.RegisterMonitor(typeof(WatchDog));
     runtime.CreateMachine(typeof(EventHandler));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.CreateMachine(typeof(Environment),
         new Environment.Config(Test.NumOfNodes));
 }

        /// <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);
            }
        }

        /// <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>
 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));
 }

 /// <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(TaskCreator));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.RegisterMonitor(typeof(M));
     runtime.CreateMachine(typeof(Environment));
 }

 /// <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>();
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.RegisterMonitor(typeof(LivenessMonitor));
     runtime.CreateMachine(typeof(M));
 }

 public static void Send(PSharpRuntime runtime, MachineId target)
 {
     runtime.SendEvent(target, new E1(2));
 }

 public static void Execute(PSharpRuntime runtime)
 {
     runtime.CreateMachine(typeof(ClusterManager));
 }

        /// <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(EventHandler));
 }