R: Single-Server Queue Simulation

ssq {simEd}

R Documentation

Single-Server Queue Simulation

Description

A next-event simulation of a single-server queue, with extensible arrival and service processes.

Usage

ssq(
  maxArrivals = Inf,
  seed = NA,
  interarrivalFcn = NULL,
  serviceFcn = NULL,
  interarrivalType = "M",
  serviceType = "M",
  maxTime = Inf,
  maxDepartures = Inf,
  maxInSystem = Inf,
  maxEventsPerSkyline = 15,
  saveAllStats = FALSE,
  saveInterarrivalTimes = FALSE,
  saveServiceTimes = FALSE,
  saveWaitTimes = FALSE,
  saveSojournTimes = FALSE,
  saveNumInQueue = FALSE,
  saveNumInSystem = FALSE,
  saveServerStatus = FALSE,
  showOutput = TRUE,
  animate = FALSE,
  showQueue = NULL,
  showSkyline = NULL,
  showSkylineSystem = FALSE,
  showSkylineQueue = FALSE,
  showSkylineServer = FALSE,
  showTitle = TRUE,
  showProgress = TRUE,
  plotQueueFcn = defaultPlotSSQ,
  plotSkylineFcn = defaultPlotSkyline,
  jobImage = NA,
  plotDelay = NA,
  respectLayout = FALSE
)

Arguments

`maxArrivals`	maximum number of customer arrivals allowed to enter the system
`seed`	initial seed to the random number generator (NA uses current state of random number generator; NULL seeds using system clock)
`interarrivalFcn`	function for generating interarrival times for queue simulation. Default value (`NA`) will result in use of default interarrival function based on `interarrivalType`. See examples.
`serviceFcn`	function for generating service times for queue simulation. Default value (`NA`) will result in use of default service function based on `serviceType`. See examples.
`interarrivalType`	string representation of desired interarrival process. Options are "M" – exponential with rate 1; "G" – uniform(0,2), having mean 1; and "D" – deterministic with constant value 1. Default is "M".
`serviceType`	string representation of desired service process . Options are "M" – exponential with rate 10/9; "G" – uniform(0, 1.8), having mean 9/10; and "D" – deterministic with constant value 9/10. Default is "M".
`maxTime`	maximum time to simulate
`maxDepartures`	maximum number of customer departures to process
`maxInSystem`	maximum number of customers that the system can hold (server(s) plus queue). Infinite by default.
`maxEventsPerSkyline`	maximum number of events viewable at a time in the skyline plot. A large value for this parameter may result in plotting delays. This parameter does not impact the final plotting, which will show all end-of-simulation results.
`saveAllStats`	if `TRUE`, returns all vectors of statistics (see below) collected by the simulation
`saveInterarrivalTimes`	if `TRUE`, returns a vector of all interarrival times generated
`saveServiceTimes`	if `TRUE`, returns a vector of all service times generated
`saveWaitTimes`	if `TRUE`, returns a vector of all wait times (in the queue) generated
`saveSojournTimes`	if `TRUE`, returns a vector of all sojourn times (time spent in the system) generated
`saveNumInQueue`	if `TRUE`, returns a vector of times and a vector of counts for whenever the number in the queue changes
`saveNumInSystem`	if `TRUE`, returns a vector of times and a vector of counts for whenever the number in the system changes
`saveServerStatus`	if `TRUE`, returns a vector of times and a vector of server status (0:idle, 1:busy) for whenever the status changes
`showOutput`	if `TRUE`, displays summary statistics upon completion
`animate`	logical; if `FALSE`, no animation plots will be shown.
`showQueue`	logical; if `TRUE`, displays a visualization of the queue
`showSkyline`	If `NULL` (default), defers to each individual showSkyline... parameter below; otherwise, supersedes individual showSkyline... parameter values. If `TRUE`, displays full skyline plot; `FALSE` suppresses skyline plot. Can alternatively be specified using chmod-like octal component specification: use 1, 2, 4 for system, queue, and server respectively, summing to indicate desired combination (e.g., 7 for all). Can also be specified as a binary vector (e.g., c(1,1,1) for all).
`showSkylineSystem`	logical; if `TRUE`, includes number in system as part of skyline plot. Value for `showSkyline` supersedes this parameter's value.
`showSkylineQueue`	logical; if `TRUE`, includes number in queue as part of skyline plot. Value for `showSkyline` supersedes this parameter's value.
`showSkylineServer`	logical; if `TRUE`, includes number in server as part of skyline plot. Value for `showSkyline` supersedes this parameter's value.
`showTitle`	if `TRUE`, display title at the top of the main plot
`showProgress`	if TRUE, displays a progress bar on screen during no-animation execution
`plotQueueFcn`	plotting function to display queue visualization. By default, this is provided by `defaultPlotSSQ`. Please refer to that associated help for more details about required arguments.
`plotSkylineFcn`	plotting function to display Skyline visualization. By default, this is provided by `defaultPlotSkyline`. Please refer to that associated help for more details about required arguments.
`jobImage`	a vector of URLs/local addresses of images to use as jobs. Requires package `'magick'`.
`plotDelay`	a positive numeric value indicating seconds between plots. A value of -1 enters 'interactive' mode, where the state will pause for user input at each step. A value of 0 will display only the final end-of-simulation plot.
`respectLayout`	logical; if `TRUE`, plot layout (i.e. par, device, etc.) settings will be respected.

Details

Implements a next-event implementation of a single-server queue simulation.

The seed parameter can take one of three valid argument types:

NA (default), which will use the current state of the random number generator without explicitly setting a new seed (see examples);
a positive integer, which will be used as the initial seed passed in an explicit call to set.seed; or
NULL, which will be passed in an explicit call to to set.seed, thereby setting the initial seed using the system clock.

Value

The function returns a list containing:

the number of arrivals to the system (customerArrivals),
the number of customers processed (customerDepartures),
the ending time of the simulation (simulationEndTime),
average wait time in the queue (avgWait),
average time in the system (avgSojourn),
average number in the system (avgNumInSystem),
average number in the queue (avgNumInQueue), and
server utilization (utilization).

of the queue as computed by the simulation. When requested via the “save...” parameters, the list may also contain:

a vector of interarrival times (interarrivalTimes),
a vector of wait times (waitTimes),
a vector of service times (serviceTimes),
a vector of sojourn times (sojournTimes),
two vectors (time and count) noting changes to number in the system (numInSystemT, numInSystemN),
two vectors (time and count) noting changes to number in the queue (numInQueueT, numInQueueN), and
two vectors (time and status) noting changes to server status (serverStatusT, serverStatusN).

Author(s)

Barry Lawson (blawson@bates.edu),
Larry Leemis (leemis@math.wm.edu),
Vadim Kudlay (vkudlay@nvidia.com)

Examples

 # process 100 arrivals, R-provided seed (via NULL seed)
 ssq(100, NULL)

 ssq(maxArrivals = 100, seed = 54321)
 ssq(maxDepartures = 100, seed = 54321)
 ssq(maxTime = 100, seed = 54321)

 ############################################################################
 # example to show use of seed = NA (default) to rely on current state of generator
 output1 <- ssq(200, 8675309, showOutput = FALSE, saveAllStats = TRUE)
 output2 <- ssq(300,          showOutput = FALSE, saveAllStats = TRUE)
 set.seed(8675309)
 output3 <- ssq(200,          showOutput = FALSE, saveAllStats = TRUE)
 output4 <- ssq(300,          showOutput = FALSE, saveAllStats = TRUE)
 sum(output1$sojournTimes != output3$sojournTimes) # should be zero
 sum(output2$sojournTimes != output4$sojournTimes) # should be zero

 myArrFcn <- function() { vexp(1, rate = 1/4, stream = 1)  }  # mean is 4
 mySvcFcn <- function() { vgamma(1, shape = 1, rate = 0.3) }  # mean is 3.3

 output <- ssq(maxArrivals = 100, interarrivalFcn = myArrFcn, serviceFcn = mySvcFcn,
              saveAllStats = TRUE)
 mean(output$interarrivalTimes)
 mean(output$serviceTimes)
 meanTPS(output$numInQueueT, output$numInQueueN) # compute time-averaged num in queue
 meanTPS(output$serverStatusT, output$serverStatusN) # compute server utilization

 ############################################################################
 # example to show use of (simple) trace data for arrivals and service times;
 # ssq() will need one more interarrival (arrival) time than jobs processed
 #
 arrivalTimes      <- NULL
 interarrivalTimes <- NULL
 serviceTimes      <- NULL

 initTimes <- function() {
     arrivalTimes      <<- c(15, 47, 71, 111, 123, 152, 232, 245, 99999)
     interarrivalTimes <<- c(arrivalTimes[1], diff(arrivalTimes))
     serviceTimes      <<- c(43, 36, 34, 30, 38, 30, 31, 29)
 }

 getInterarr <- function() {
     nextInterarr <- interarrivalTimes[1]
     interarrivalTimes <<- interarrivalTimes[-1]  # remove 1st element globally
     return(nextInterarr)
 }

 getService <- function() {
     nextService <- serviceTimes[1]
     serviceTimes <<- serviceTimes[-1]  # remove 1st element globally
     return(nextService)
 }

 initTimes()
 numJobs <- length(serviceTimes)
 output <- ssq(maxArrivals = numJobs, interarrivalFcn = getInterarr,
               serviceFcn = getService, saveAllStats = TRUE)
 mean(output$interarrivalTimes)
 mean(output$serviceTimes)


 ############################################################################
 # example to show use of (simple) trace data for arrivals and service times,
 # allowing for reuse (recycling) of trace data times
 arrivalTimes      <- NULL
 interarrivalTimes <- NULL
 serviceTimes      <- NULL

 initArrivalTimes <- function() {
   arrivalTimes      <<- c(15, 47, 71, 111, 123, 152, 232, 245)
   interarrivalTimes <<- c(arrivalTimes[1], diff(arrivalTimes))
 }

 initServiceTimes <- function() {
     serviceTimes    <<- c(43, 36, 34, 30, 38, 30, 31, 29)
 }

 getInterarr <- function() {
     if (length(interarrivalTimes) == 0)  initArrivalTimes()

     nextInterarr <- interarrivalTimes[1]
     interarrivalTimes <<- interarrivalTimes[-1] # remove 1st element globally
     return(nextInterarr)
 }

 getService <- function() {
     if (length(serviceTimes) == 0)  initServiceTimes()

     nextService <- serviceTimes[1]
     serviceTimes <<- serviceTimes[-1]  # remove 1st element globally
     return(nextService)
 }

 initArrivalTimes()
 initServiceTimes()
 output <- ssq(maxArrivals = 100, interarrivalFcn = getInterarr,
               serviceFcn = getService, saveAllStats = TRUE)
 mean(output$interarrivalTimes)
 mean(output$serviceTimes)

 ############################################################################
 # Testing with visualization

 # Visualizing ssq with a set seed, infinite queue capacity, 20 arrivals,
 # interactive mode (default), showing skyline for all 3 attributes (default)
 if (interactive()) {
   ssq(seed = 1234, maxArrivals = 20, animate = TRUE)
 }

 # Same as above, but jump to final queue visualization using plotDelay 0
 ssq(seed = 1234, maxArrivals = 20, animate = TRUE, plotDelay = 0)

 # Perform simulation again with finite queue of low capacity. Note same
 # variate generation but different outcomes due to rejection pathway
 ssq(seed = 1234, maxArrivals = 25, animate = TRUE, maxInSystem = 5, plotDelay = 0)

 # Using default distributions to simulate a default M/G/1 Queue
 ssq(seed = 1234, maxDepartures = 10, interarrivalType = "M", serviceType = "G", 
     animate = TRUE, plotDelay = 0)

[Package simEd version 2.0.1 Index]