Queueing system with n parallel servers

queue.r

PriorityQueue <- function() {
    keys <<- values <<- NULL
    insert <- function(key, value) {
    temp <- c(keys, key)
    ord <- order(temp)
    keys <<- temp[ord]
    values <<- c(values, list(value))[ord]
  }
  pop <- function() {
    key <- keys[[1]]
    head <- values[[1]]
    values <<- values[-1]
    keys <<- keys[-1]
    return(list(key=key, value=head))
  }
  empty <- function() length(keys) == 0
  list(insert = insert, pop = pop, empty = empty)
}

lambda <- function(t) {
  if (t < 1) return(10)
  else if (t < 2) return(5)
  else if (t < 3) return(8)
  else if (t < 4) return(5)
  else return (6)
}

nextarrival <- function(ta, lambda, lambdamax) {
  t <- ta
  while (TRUE)
  {
    t <- t + rexp(1,rate=lambdamax)
    u <- runif(1)
    if (u * lambdamax < lambda(t))
      return(t)
  }
}

queue <- function(lambda, lambdamax, alpha, T, n_queues=1) {
  t <- 0
  queue <- PriorityQueue()
  add_arrival <- function() {
    queue$insert(nextarrival(t, lambda, lambdamax), "arrival")
  }
  add_departure <- function() {
    queue$insert(t + rexp(1,rate=alpha), "departure")
  }
  add_arrival()
  arrivals <- NULL
  departures <- NULL
  n <- 0
  occupied <- 0  
  idle_since <- 0
  idle_time <- 0
  while(!queue$empty()) {
    event <- queue$pop()
    t <- event$key
    event_type <- event$value
    if (event_type == "arrival") {
      if (t < T) {
        if (!is.null(idle_since)) {
          print(c(idle_since, t))
          idle_time <- idle_time + (t - idle_since);
          idle_since <- NULL
        }
        arrivals <- c(arrivals, t)
        add_arrival()
        if (occupied < n_queues) {
      add_departure()
      occupied <- occupied + 1
        }
        n <- n + 1
      }
    } else if (event_type == "departure") {
      departures <- c(departures, t)
      if (n - occupied > 0) {
        add_departure()
      } else {
        occupied <- occupied - 1
      }
      n <- n - 1
      if (n == 0) idle_since <- t
    }
  }
  last = tail(departures, n=1)
  if (last < T) {
  extra_time <- 0
  idle_time <- idle_time + (T - last)
  } else {
  extra_time <- last - T
  }
  list(arrivals=arrivals, departures=departures, extra_time=extra_time, idle_time=idle_time)
}

queue(lambda, 10, 100, 1, n_queues=10)