4 Simulation Control (Basic)
The 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 procedural 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.
(schedule #:now (function . arguments) #:priority (priority 0))
(schedule #:at time (function . arguments) #:priority (priority 0))
(schedule #:in duration (function . arguments) #:priority (priority 0))
(schedule #:when event (function . arguments) #:priority (priority 0))
(schedule time (function . arguments) #:priority (priority 0))
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 delta 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.
There is also a legacy format for specifying the timing for an event using the following forms:
now—
equivalent to #:now. (at time)—
equivalent to #:at time. (in duration)—
equivalent to #:in duration. (when event)—
equivalent to #:when event.
Use of the legacy forms is deprecated and may be removed in a future release.
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—
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 continuous 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
(stop-simulation return-value) → any return-value : any/c (stop-simulation) → any
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.