4 Simulation Control (Basic)
The PLT Scheme Simulation Collection provides functionality for basic simulation control. Basic simulation control includes the simulation main loop for controlling the execution of event and processes, scheduling event and processes, and simulating the passing of time (i.e. waiting and working).
4.1 Scheduling Events and Processes
One of the main characteristics of discete simulation models is the ability to schedule procedureal simulation elements (e.g., events and processes) to occur at specified (sumulated) times. Typically, an event list is maintained that contains entries for each of the schedule events.
In the simulation collection, each simulation environment has three such lists: the now event list, the future event list, and the continuous event list. The now event list contains entries for elements that are to be executed before the simulation clock is advanced, i.e. now. The future event list contains entries for elements that are to be executed in the (simulated) future, i.e. after the simulation clock advances. The continuous event list is used for continuous simulation models and is described in Chapter 11 Continuous Simulation Models.
| ||
| ||
| ||
| ||
|
| function : procedure? |
| arguments : (listof any/c) |
| time : (>=/c 0.0) |
| duration : (>=/c 0.0) |
| event : event? |
| priority : real? |
Schedules events or processes for execution, optionally with a specified priority. If function is the name of a process, then a process instance is created and scheduled for execution with the specified arguments. Otherwise, function must evaluate to a procedural object and the function is scheduled for execution with the specified arguments.
The timing of the event or process execution is specified using one of the following forms:
now – The event or process is scheduled to be executed now, i.e before the simulation clock is advanced. That is, it is added to the now event list.
(at time) – The event or process is scheduled at the specified time. An error is signaled if time is in the (simulated) past. That is, time must be greater than or equal to (current-simulation-time).
(in duration) – The event or process is scheduled to be executed after the specified duration has elapsed. This is equivalent to (at (+ duration (current-simulation-time))). An error is signaled if duration is negative.
(when event) – The event or process is scheduled to be executed at the same time as (i.e. when) the specified event is executed. This is called a linked event.
time – This is equivalent to (at time).
Note that there is a subtle difference between now and (in 0.0) (or, equivalently, (at (current-simulation-time)). The now specification will add the event or process to the now event list while the (in 0.0) specification will add the event to the future event list. In the simulation collection, advancing the simulation clock – even to the same time – allows simulation monitors to run and some other internal bookkeeping to occur. The simulation clock never advances between now events; while it will always advance between future events, even if they are scheduled to occur at the same (simulated) time. In essence, now event represent events that are causally linked to the current time; while future events schedules at the same time basically represent coindicidental timings.
4.2 Controlling the Simulation Main Loop
The simulation main loop implements the simulation control strategy by executing events and processes and maintaining the simulation clock.
The following pseudo code shows the processing for the simulation main loop, including continuous simulation models.
| simulation main loop: |
| save the exit continuation |
| loop: |
| save the next continuation |
| if the now event list is not empty |
| execute the next now (discrete) event |
| else if the future event list is not empty |
| if the continuous event list is not empty |
| execute the continuous events until |
| the time of the next future event |
| ;; this may terminate early and reenter |
| ;; the loop via the next continuation |
| ;; (e.g. if a continuous process's exit |
| ;; condition is met) |
| else |
| execute the next future (discrete) event |
| else |
| if the continuous event list is not empty |
| execute the contnuous events forever |
| ;; this may terminate early and reenter |
| ;; the loop via the next continuation |
| ;; otherwise, the loop would never end |
| else |
| exit |
| end loop |
| end simulation main loop |
| (start-simulation) → any |
Begins execution of the simulation main loop in the current simulation environment. It saves the loop-next and loop-exit continuations in the current simulation environment and then executes events and processes from the event list(s) until either there are no more to be executed or the simulation main loop is explicitly exited.
| (stop-simulation) → any |
Terminates execution of the simulation main loop running in the current simulation environment. It calls (current-simulation-loop-exit)
A convenient usage of stop-simulation is to schedule its execution at a point in time the execution is to run until. For example:
(schedule (at 1000.0) (stop-simulation))
will cause the simulation to end at (simulated) time 1000.0.
4.3 Simulating Waiting and Working
| (wait/work delay) → any |
| delay : (>=/c 0.0) |
| (wait delay) → any |
| delay : (>=/c 0.0) |
| (work delay) → any |
| delay : (>=/c 0.0) |
Simulates the passage of (simulated) time. The event or process calling one of these function will wait for the specified delay. Note that wait and work are aliases for the wait/work function.