public static void Run()
{
var env = Sim.Environment(21);
env.Process(PersonGenerator(env));
env.Run(SimTime);
}
public static void Main()
{
var env = Sim.Environment();
env.Process(Execute(env, 33));
env.Run(until: 100);
}
public static void Run()
{
// Sets up and starts simulation
Console.WriteLine("Movie renege");
_env = Sim.Environment(RandomSeed);
// Creates movie theater
var counter = Sim.Resource(_env, 1);
var titles = new[] { ".NET Unchained", "Kill Process", "Pulp Implementation" };
var movies = new List <MovieInfo>(titles.Length);
movies.AddRange(titles.Select(t => new MovieInfo(t, _env.Event())));
_theater = new Theater(counter, movies);
// Starts process and simulates
_env.Process(CustomerArrivals());
_env.Run(until: SimTime);
// Analysis and results
foreach (var movie in movies.Where(m => m.SoldOut.Succeeded))
{
Console.WriteLine("Movie \"{0}\" sold out {1:.0} minutes after ticket counter opening.", movie.Title,
movie.WhenSoldOut);
Console.WriteLine(" Number of people leaving queue when film sold out: {0}", movie.RenegerCount);
}
}
public static void Run()
{
var env = Sim.Environment(21);
env.Process(Machine(env));
env.Run(SimTime);
}
public virtual void SetUp()
{
Env = Sim.Environment();
Assert.IsNotNull(Env);
Assert.IsInstanceOf(typeof(SimEnvironment), Env);
Assert.AreEqual(0, Env.Now);
}
public static void Run()
{
var env = Sim.Environment();
env.Process(Process(env));
env.Run();
}
public static void Run()
{
var env = Sim.Environment(21);
env.Process(PastaCook(env));
env.Run(SimTime);
}
public static void Run()
{
// Sets up and starts the simulation.
Console.WriteLine("Process communication");
var env = Sim.Environment();
// For one-to-one or many-to-one type pipes, use Resources.Store.
var pipe = Sim.Store <Message>(env);
env.Process(MessageGenerator("Generator A", env, pipe));
env.Process(MessageConsumer("Consumer A", env, pipe));
Console.WriteLine();
Console.WriteLine("One-to-one pipe communication");
Console.WriteLine();
env.Run(until: SimTime);
// For one-to many, instead, use BroadcastPipe.
// (Note: it could also be used for one-to-one, many-to-one or many-to-many)
env = Sim.Environment();
var bcPipe = new BroadcastPipe <Message>(env);
env.Process(MessageGenerator("Generator A", env, bcPipe));
env.Process(MessageConsumer("Consumer A", env, bcPipe.OutputConn()));
env.Process(MessageConsumer("Consumer B", env, bcPipe.OutputConn()));
Console.WriteLine();
Console.WriteLine("One-to-many pipe communication");
Console.WriteLine();
env.Run(until: SimTime);
}
public void Environment_ShouldNotChangeDefaultRealTimeOptionsAfterCreation_WithSeed_WallClock()
{
var env = Sim.Environment(21);
Assert.That(env.RealTime.Enabled, Is.False);
Assert.That(env.RealTime.Locked, Is.True);
env.RealTime.WallClock = new MockClock();
}
public void Environment_ShouldNotChangeDefaultRealTimeOptionsAfterCreation_WithSeed_ScalingFactor()
{
var env = Sim.Environment(21);
Assert.That(env.RealTime.Enabled, Is.False);
Assert.That(env.RealTime.Locked, Is.True);
env.RealTime.ScalingFactor = 3.0;
}
public static void Run()
{
var sim = Sim.Environment();
var car = new Car(sim);
sim.Process(Driver(sim, car));
sim.Run(until: 15);
}
public static void Run()
{
var env = Sim.Environment();
env.DelayedProcess(Process(env, 'A'), 7);
env.Process(Process(env, 'B'));
env.Run();
}
public static void Run()
{
var env = Sim.Environment(21);
var train = env.Process(Train(env));
env.Process(EmergencyBrake(env, train));
env.Run();
}
// Expected output:
// Hello World simulation :)
// Hello World at 2.1!
// Hello World at 4.2!
// Hello World at 6.3!
// Hello World at 8.4!
public static void Run()
{
Console.WriteLine("Hello World simulation :)");
var env = Sim.Environment();
env.Process(SayHello(env));
env.Run(10);
}
public static void Run()
{
var env = Sim.Environment();
env.Process(Clock(env, "fast", 0.5));
env.Process(Clock(env, "slow", 1.0));
env.Run(until: 2);
}
// Expected output:
// Starting simulation
// Here I am at the shop Marta
// I just bought something Marta
// I just bought something Marta
// I just bought something Marta
// I just bought something Marta
// All I have left is 60 I am going home Marta
// Current time is 30
public static void Main()
{
var env = Sim.Environment();
env.DelayedProcess(Buy(env, "Marta", 100), delay: 10);
Console.WriteLine("Starting simulation");
env.Run(until: 100);
Console.WriteLine("Current time is {0}", env.Now);
}
// Expected output:
// Breakdown Bus at 300
// Bus repaired at 320
// Breakdown Bus at 620
// Bus repaired at 640
// Breakdown Bus at 940
// Bus repaired at 960
// Bus has arrived at 1060
// Dessert: No more events at time 1260
public static void Main()
{
var env = Sim.Environment();
var bus = env.Process(OperateBus(env, repairDuration: 20, tripLength: 1000));
_breakBus = env.Process(BreakBus(env, bus, interval: 300));
env.Run(until: 4000);
Console.WriteLine("Dessert: No more events at time {0}", env.Now);
}
public static void Run()
{
var env = Sim.Environment(seed: 42);
var rec = Sim.Tally(env);
env.Process(Spawner(env, rec));
env.Run(2 * 60);
Console.WriteLine("Total clients: {0}", rec.Total());
Console.WriteLine("Average wait: {0:.0}", rec.Mean());
}
// Expected output:
// Starting simulation
// 0 1 Starting
// 6 2 Starting
// 100 1 Arrived
// 106 2 Arrived
// Current time is 106
public static void Run()
{
var env = Sim.Environment();
env.Process(Go(env, 1));
env.DelayedProcess(Go(env, 2), delay: 6);
Console.WriteLine("Starting simulation");
env.Run(until: 200);
Console.WriteLine("Current time is {0}", env.Now);
}
public static void Run()
{
// Setup and start the simulation
Console.WriteLine("Bank renege");
var env = Sim.Environment(RandomSeed);
// Start processes and simulate
var counter = Sim.Resource(env, capacity: 1);
env.Process(Source(env, NewCustomers, IntervalCustomers, counter));
env.Run();
}
public static void Run()
{
const int count = 10;
var env = Sim.Environment();
var store = Sim.Store <int>(env);
for (var i = 0; i < count; ++i)
{
env.Process(Producer(env, store, i));
env.Process(Consumer(store));
}
env.Run();
}
/// <summary>
/// Sets up and starts the simulation.
/// </summary>
public static void Run()
{
Console.WriteLine("Gas Station refueling");
// Creates the environment and starts processes.
var env = Sim.Environment(RandomSeed);
var gasStation = Sim.Resource(env, 2);
var fuelPump = Sim.Container(env, GasStationSize, level: GasStationSize);
env.Process(GasStationControl(env, fuelPump));
env.Process(CarGenerator(env, gasStation, fuelPump));
// Run!
env.Run(until: SimTime);
}
public static void Main()
{
var sim = Sim.Environment();
const int gameOver = 100;
// Creates a Player object named "Romulans"
var target = new Player(lives: 3, name: "Romulans");
sim.Process(target.Life(sim));
// Creates a Federation object
var shooter = new Federation();
sim.Process(shooter.Fight(sim, target));
sim.Run(until: gameOver);
Console.WriteLine(target.Message);
}
public static void Run()
{
var env = Sim.Environment(seed: 21);
const int capacity = 10;
var store = Sim.Store <int>(env, capacity, WaitPolicy.FIFO, WaitPolicy.FIFO, WaitPolicy.Random);
for (var i = 0; i < capacity; ++i)
{
store.Put(i);
}
for (var i = 0; i < capacity; ++i)
{
env.Process(Getter(store, (char)('A' + i)));
}
env.Run();
}
public static void Run()
{
// We create the environment into which
// our first simulation will run.
var env = Sim.Environment(RandomSeed);
// We start two "Person" processes,
// which will have a random name picked from Names.
env.Process(Person(env, env.Random.Choice(Names)));
env.DelayedProcess(Person(env, env.Random.Choice(Names)), delay: 3);
// After that, we finally start our simulation.
// We expect an output similar to the following:
// Hi, I'm Pino and I will wait for 5 minutes!
// Hi, I'm Dino and I will wait for 5 minutes!
// Ok, Pino's wait has finished at 5. Bye :)
// Ok, Dino's wait has finished at 8. Bye :)
env.Run();
}
static void RunSimulation(int simId, int h)
{
var seed = (simId + 1) * (h + 1) + Environment.TickCount;
var env = Sim.Environment(seed);
var g = new G();
// Processes creation (and activation)
// 1. The switch
g.Switch = new Switch(env, g);
env.Process(g.Switch.Run());
g.Switch.SetLogger("SWITCH");
for (var i = 0; i < G.MachineCount; ++i)
{
// 2. The server operative systems
var svOS = new ServerOS(env, g, i);
env.Process(svOS.Run());
svOS.SetLogger("SERVER_OS_" + i);
g.ServerOSes[i] = svOS;
// 3. The server processes
var sv = new Server(env, g, i);
env.Process(sv.Run());
sv.SetLogger("SERVER_" + i);
g.Servers[i] = sv;
// 4. The client operative systems
var clOS = new ClientOS(env, g, i);
env.Process(clOS.Run());
clOS.SetLogger("CLIENT_OS_" + i);
g.ClientOSes[i] = clOS;
// 5. The client processes
var cl = new Client(env, g, i);
env.Process(cl.Run());
cl.SetLogger("CLIENT_" + i);
g.Clients[i] = cl;
}
// 6. The memory recorder
env.Process(MemoryRecorder.Run(env, g.Stats));
Console.WriteLine("Starting simulation {0} (h = {1})", simId, h);
StorePackets(g.Servers);
env.Run(until: G.MaxSimTime);
Debug.Assert(env.Now >= G.MaxSimTime, "Ended prematurely!");
PrintStats(g.Stats, simId, h);
}
public static void Run()
{
// We specify the seed in order to have fixed results in all examples; however, in a
// production environment, it should be different among all simulations, so that each
// simulations produces unique results.
const int seed = 21;
var env = Sim.Environment(seed);
// Here we record values using a "tally", which keeps tracks only of results (median,
// mode, mean, ...) and not of the data itself. Tallies have a very low memory footprint.
var aPressureRecorder = Sim.Tally(env);
var aTemperatureRecorder = Sim.Tally(env);
env.Process(Machine(env, 'A', aPressureRecorder, aTemperatureRecorder));
// Here we record values using a "monitor", which keeps tracks of results (median, mode,
// mean, ...) and also of the observed data. Of course, monitors use more memory than tallies.
var bPressureRecorder = Sim.Monitor(env);
var bTemperatureRecorder = Sim.Monitor(env);
env.Process(Machine(env, 'B', bPressureRecorder, bTemperatureRecorder));
// Run the simulation.
env.Run(SimTime);
Console.WriteLine();
Console.WriteLine($"Machine A average pressure: {aPressureRecorder.Mean():.00} bar");
Console.WriteLine($"Machine A average temperature: {aTemperatureRecorder.Mean():.00} °F");
Console.WriteLine();
Console.WriteLine($"Machine B average pressure: {bPressureRecorder.Mean():.00} bar");
Console.WriteLine($"Machine B average temperature: {bTemperatureRecorder.Mean():.00} °F");
// Since we used two monitors for machine B, we can also print the recorded data.
var pressureValues = string.Join(", ", bPressureRecorder.Samples.Select(s => s.Sample.ToString(".00")));
var temperatureValues = string.Join(", ", bTemperatureRecorder.Samples.Select(s => s.Sample.ToString()));
Console.WriteLine();
Console.WriteLine($"Machine B pressure values: {pressureValues}");
Console.WriteLine($"Machine B temperature values: {temperatureValues}");
}
public static void Run()
{
// We create the environment into which
// our first simulation will run.
var env = Sim.Environment(RandomSeed);
// The postOffice can be represented as a resource,
// whose "capacity" is given by the number of employees
// the simulated post office has.
var postOffice = Sim.Resource(env, EmployeeCount);
// We start the "PersonSpawner" processes,
// which will start new "Person" processes at random intervals.
env.Process(PersonSpawner(env, postOffice));
// After that, we finally start our simulation.
// We expect an output similar to the following:
// Hi, I'm Pino and I entered the office at 0,00
// Finally it's Pino's turn! I waited 0,00 minutes
// Pino's job will take 1,43 minutes
// Ok, Pino leaves the office at 1,43. Bye :)
// Hi, I'm Pino and I entered the office at 2,86
// Finally it's Pino's turn! I waited 0,00 minutes
// Pino's job will take 1,60 minutes
// Hi, I'm Bobb and I entered the office at 3,50
// Finally it's Bobb's turn! I waited 0,00 minutes
// Bobb's job will take 1,28 minutes
// Ok, Pino leaves the office at 4,46. Bye :)
// Ok, Bobb leaves the office at 4,78. Bye :)
// Hi, I'm Pino and I entered the office at 9,49
// Finally it's Pino's turn! I waited 0,00 minutes
// Pino's job will take 5,48 minutes
// Hi, I'm Dino and I entered the office at 9,67
// Finally it's Dino's turn! I waited 0,00 minutes
// Dino's job will take 0,64 minutes
// Ok, Dino leaves the office at 10,31. Bye :)
env.Run(until: 20);
}