static Timeout <string> NewTarget(SimEnvironment env)
{
var delay = env.Random.DiscreteUniform(1, 20);
var target = env.Random.Choice(Targets);
return(env.Timeout(delay, target));
}
static IEnumerable <SimEvent> Worker(SimEnvironment env)
{
Console.WriteLine("{0}: Carico la macchina...", env.Now);
yield return(env.Timeout(LoadTime));
env.Exit(env.Random.Choice(Tasks));
}
/// <summary>
/// Customer arrives, is served and leaves.
/// </summary>
private static SimEvents Customer(SimEnvironment env, string name, Resource counter, double timeInBank)
{
var arrive = env.Now;
Console.WriteLine("{0:00.0000} {1}: Here I am", arrive, name);
using (var req = counter.Request())
{
var patience = env.Random.NextDouble(MinPatience, MaxPatience);
// Wait for the counter or abort at the end of our tether
yield return(req.Or(env.Timeout(patience)));
var wait = env.Now - arrive;
if (req.Succeeded)
{
// We got to the counter
Console.WriteLine("{0:00.0000} {1}: Waited {2:0.000}", env.Now, name, wait);
var tib = env.Random.Exponential(1.0 / timeInBank);
yield return(env.Timeout(tib));
Console.WriteLine("{0:00.0000} {1}: Finished", env.Now, name);
}
else
{
// We reneged
Console.WriteLine("{0:00.0000} {1}: RENEGED after {2:0.000}", env.Now, name, wait);
}
}
}
/// <summary>
/// A process which consumes messages.
/// </summary>
static IEvents MessageConsumer(string name, SimEnvironment env, Store <Message> inPipe)
{
while (true)
{
// Gets event for message pipe.
var getEv = inPipe.Get();
yield return(getEv);
var msg = getEv.Value;
if (msg.Timestamp < env.Now)
{
// If message was already put into pipe, then
// MessageConsumer was late getting to it.
// Depending on what is being modeled, this may, or may not,
// have some significance.
Console.WriteLine("LATE Getting Message: at time {0:.0}, \"{1}\" received message \"{2}\"", env.Now,
name, msg.Content);
}
else
{
// MessageConsumer is synchronized with MessageGenerator.
Console.WriteLine("At time {0:.0}, \"{1}\" received message \"{2}\"", env.Now, name, msg.Content);
}
// Process does some other work, which may result in missing messages.
yield return(env.Timeout(Rand.Next(4, 8)));
}
}
static IEnumerable <SimEvent> CondTester(SimEnvironment env)
{
var aProc = env.Process(AProcess(env));
var cond = env.AllOf(env.Timeout(5, "VAL_T"), aProc);
yield return(cond);
Console.WriteLine("ALL: {0}", cond.Value.Select(x => x.Value).Aggregate((s1, s2) => s1 + ", " + s2));
aProc = env.Process(AProcess(env));
cond = env.AnyOf(env.Timeout(5, "VAL_T"), aProc);
yield return(cond);
Console.WriteLine("ANY: {0}", cond.Value.Select(x => x.Value).Aggregate((s1, s2) => s1 + ", " + s2));
aProc = env.Process(AProcess(env));
var aTime = env.Timeout(5, "VAL_T");
ConditionEval <Timeout <string>, SimProcess> pred =
c => c.Ev1.Succeeded && c.Ev2.Succeeded && c.Ev1.Value.Equals("VAL_T") && c.Ev2.Value.Equals("VAL_P");
cond = env.Condition(aTime, aProc, pred);
yield return(cond);
Console.WriteLine("CUSTOM: {0}", cond.Value.Select(x => x.Value).Aggregate((s1, s2) => s1 + ", " + s2));
}
static SimEvents Go(SimEnvironment env, int id)
{
Console.WriteLine("{0} {1} Starting", env.Now, id);
yield return(env.Timeout(100));
Console.WriteLine("{0} {1} Arrived", env.Now, id);
}
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 SimEvents Fight(SimEnvironment env, Player target)
{
Console.WriteLine("Three {0} attempting to escape!", target.Name);
while (true)
{
if (_random.Next(0, 10) < 2)
{
// Checks for hit on player
target.Damage += 1; // Hit! Increment damage to player
if (target.Damage <= 5) // Target survives...
{
Console.WriteLine("Ha! {0} hit! Damage = {1}", target.Name, target.Damage);
}
else
{
target.LifeEvent.Succeed();
if (target.Lives - 1 == 0)
{
Console.WriteLine("No more {0} left!", target.Name);
}
else
{
Console.WriteLine("Now only {0} {1} left!", target.Lives - 1, target.Name);
}
}
}
yield return(env.Timeout(1));
}
}
static IEnumerable <SimEvent> Clock(SimEnvironment env, string name, double tick)
{
while (true)
{
Console.WriteLine("{0} {1:0.0}", name, env.Now);
yield return(env.Timeout(tick));
}
}
protected EscaperBase(SimEnvironment env, Binder binder)
{
_env = env;
_binder = binder;
_name = GetType().Name;
// Speed is set to its default value.
Speed = double.Parse(AppSettings.DefaultEscaperSpeed);
}
static SimEvents Person(SimEnvironment env, string name)
{
Console.WriteLine("Hi, I'm {0} and I will wait for {1} minutes!", name, WaitTime);
// The process will stop its execution for WaitTime time units.
yield return(env.Timeout(WaitTime));
Console.WriteLine("Ok, {0}'s wait has finished at {1}. Bye :)", name, env.Now);
}
internal FilterStore(SimEnvironment env, int capacity, WaitPolicy getPolicy, WaitPolicy putPolicy,
WaitPolicy itemPolicy) : base(env)
{
_capacity = capacity;
_getQueue = WaitQueue.New <GetEvent>(getPolicy, Env);
_putQueue = WaitQueue.New <PutEvent>(putPolicy, Env);
_itemQueue = WaitQueue.New <T>(itemPolicy, Env);
}
static IEnumerable <SimEvent> Producer(SimEnvironment env, Store <int> store, int n)
{
var call = env.Call(FibonacciFunc(env, n));
yield return(call);
store.Put((int)call.Value);
}
internal Container(SimEnvironment env, double capacity, double level, WaitPolicy getPolicy, WaitPolicy putPolicy)
: base(env)
{
_capacity = capacity;
Level = level;
_getQueue = WaitQueue.New <GetEvent>(getPolicy, Env);
_putQueue = WaitQueue.New <PutEvent>(putPolicy, Env);
}
static IEvents SayHello(SimEnvironment env)
{
while (true)
{
yield return(env.Timeout(2.1));
Console.WriteLine("Hello World at {0}!", env.Now);
}
}
/// <summary>
/// Generates new cars that arrive at the gas station.
/// </summary>
private static SimEvents CarGenerator(SimEnvironment env, Resource gasStation, Container fuelPump)
{
foreach (var i in Enumerable.Range(0, int.MaxValue))
{
yield return(env.Timeout(env.Random.Next(MinInter, MaxInter)));
env.Process(Car("Car " + i, env, gasStation, fuelPump));
}
}
static SimEvents Execute(SimEnvironment env, int finish)
{
while (env.Now < finish)
{
// Creates a new Customer and activates it (with default parameters).
env.Process(Customer.Buy(env, "Marta"));
Console.WriteLine("{0} {1}", env.Now, "Marta");
yield return(env.Timeout(10));
}
}
static IEnumerable <SimEvent> Spawner(SimEnvironment env, Tally rec)
{
var queue = Sim.Resource(env, 2);
while (true)
{
env.Process(Person(env, queue, rec));
yield return(env.Timeout(env.Random.Next(2, 5)));
}
}
private static IEvents SayHello(SimEnvironment env, char id)
{
while (true)
{
Console.WriteLine("{0} - Sleeping at {1}, real {2}...", id, env.Now, env.RealTime.WallClock.UtcNow);
yield return(env.Timeout(3));
Console.WriteLine("{0} - Awake at {1}, real {2}", id, env.Now, env.RealTime.WallClock.UtcNow);
}
}
static IEnumerable <SimEvent> Person(SimEnvironment env, Resource queue, Tally rec)
{
using (var req = queue.Request()) {
var startTime = env.Now;
yield return(req);
rec.Observe(env.Now - startTime);
var workTime = env.Random.Next(3, 10);
yield return(env.Timeout(workTime));
}
}
private const int MaxPatience = 3; // Max. customer patience
/// <summary>
/// Source generates customers randomly.
/// </summary>
private static SimEvents Source(SimEnvironment env, int number, double interval, Resource counter)
{
foreach (var i in Enumerable.Range(0, number))
{
var n = string.Format("Customer{0:00}", i);
var c = Customer(env, n, counter, timeInBank: 12.0);
env.Process(c);
var t = env.Random.Exponential(1.0 / interval);
yield return(env.Timeout(t));
}
}
static SimEvents PersonSpawner(SimEnvironment env, Resource postOffice)
{
while (true)
{
// We first start a new "Person" process...
env.Process(Person(env, postOffice, env.Random.Choice(Names)));
// And then we sleep for nearly SpawnFrequency minutes.
var waitTime = env.Random.Exponential(1.0 / SpawnFrequency);
yield return(env.Timeout(waitTime));
}
}
static IEnumerable <SimEvent> Machine(SimEnvironment env)
{
while (true)
{
var worker = env.Process(Worker(env));
yield return(worker);
Console.WriteLine("{0}: Eseguo il comando {1}", env.Now, worker.Value);
yield return(env.Timeout(WorkTime));
}
}
public Client(SimEnvironment env, G g, int id) : base(env, g)
{
_id = id;
for (var i = 1; i < G.MachineCount; ++i)
{
var index = (i + id) % G.MachineCount;
_peers[i - 1] = new ServerInfo(index);
}
_packetConstructed = env.Event();
}
/// <summary>
/// Arrives at the gas station after a certain delay and refuels it.
/// </summary>
private static SimEvents TankTruck(SimEnvironment env, Container fuelPump)
{
yield return(env.Timeout(TankTruckTime));
Console.WriteLine("Tank truck arriving at time {0}", env.Now);
var amount = fuelPump.Capacity - fuelPump.Level;
Console.WriteLine("Tank truck refueling {0:.0} liters.", amount);
yield return(fuelPump.Put(amount));
}
static IEnumerable <SimEvent> Person(SimEnvironment env, string gender, Resource toilet)
{
using (var req = toilet.Request()) {
yield return(req);
Console.WriteLine("{0:0.00}: {1} --> Bagno", env.Now, gender);
yield return(env.Timeout(env.Random.Exponential(1.0 / AvgTimeInToilet)));
Console.WriteLine("{0:0.00}: {1} <-- Bagno", env.Now, gender);
}
}
static IEnumerable <SimEvent> Process(SimEnvironment env)
{
var ev = env.Event <string>();
env.Process(EventFailer(ev));
yield return(ev);
if (ev.Failed)
{
Console.WriteLine(ev.Value);
}
}
public static SimEvents Buy(SimEnvironment env, string name, double budget = 40)
{
Console.WriteLine("Here I am at the shop {0}", name);
for (var i = 0; i < 4; ++i)
{
yield return(env.Timeout(5)); // Executed 4 times at intervals of 5 time units
Console.WriteLine("I just bought something {0}", name);
budget -= 10;
}
Console.WriteLine("All I have left is {0} I am going home {1}", budget, name);
}
static IEnumerable <SimEvent> PressureSensor(SimEnvironment env, char tag, IRecorder pressureRecorder)
{
while (true)
{
yield return(env.Timeout(MonitoringTime));
// Read the pressure value and record it.
var pressure = env.Random.Normal(1000, 50);
pressureRecorder.Observe(pressure);
Console.WriteLine($"Pressure sensor for machine {tag} has recorded a pressure of {pressure:.00} bar");
}
}
static IEnumerable <SimEvent> TemperatureSensor(SimEnvironment env, char tag, IRecorder temperatureRecorder)
{
while (true)
{
yield return(env.Timeout(MonitoringTime));
// Read the temperature value and record it.
var temperature = env.Random.Poisson(100);
temperatureRecorder.Observe(temperature);
Console.WriteLine($"Temperature sensor for machine {tag} has recorded a temperature of {temperature} °F");
}
}
/// <summary>
/// A process which randomly generates messages.
/// </summary>
static IEvents MessageGenerator(string name, SimEnvironment env, BroadcastPipe <Message> outPipe)
{
while (true)
{
// Waits for next transmission.
yield return(env.Timeout(Rand.Next(6, 10)));
// Messages are time stamped to later check
// if the consumer was late getting them.
var content = string.Format("{0} says hello at {1:.0}", name, env.Now);
yield return(outPipe.Put(new Message(env.Now, content)));
}
}
public Pledge(SimEnvironment env, Binder binder)
: base(env, binder)
{
}
public Trémaux(SimEnvironment env, Binder binder)
: base(env, binder)
{
}
public RandomMouse(SimEnvironment env, Binder binder)
: base(env, binder)
{
}
public WallFollower(SimEnvironment env, Binder binder)
: base(env, binder)
{
}
