Single-server queue simulation

Search…
Overview of the single server queue simulation app.
This example demonstrates the use of Nextmv's discrete event simulator, Dash, for customers using Nextmv Enterprise.
In this example, we detail a single-server queue simulation.
Problem Definition
For a single-server queue problem, you have a line of customers waiting to be served and a single server to handle their requests. The server handles one request at a time in the order they arrive (e.g., a line at the bank or grocery store).
The key performance indicator is "wait time", defined as the time from entering the queue to the time entering service (or how long customers have to wait in line before being served).
Input Data
Assume you have historical information about customers, including their unique customer numbers, the number of minutes after opening our queue for business that they arrive, and the number of minutes it takes to service them.
Your input data can then be defined in JSON as a series of customers with the historical information detailed above as attributes.
JSON
1
[
2
  { "Number": 0, "Arrival":  0, "Service":  3 },
3
  { "Number": 1, "Arrival":  1, "Service": 10 },
4
  { "Number": 2, "Arrival":  1, "Service":  7 },
5
  { "Number": 3, "Arrival":  7, "Service":  2 },
6
  { "Number": 4, "Arrival":  9, "Service":  3 },
7
  { "Number": 5, "Arrival": 13, "Service":  4 },
8
  { "Number": 6, "Arrival": 14, "Service":  6 },
9
  { "Number": 7, "Arrival": 15, "Service":  8 },
10
  { "Number": 8, "Arrival": 15, "Service":  3 },
11
  { "Number": 9, "Arrival": 19, "Service":  2 }
12
]
Copied!
Customer 0 arrives exactly at the start of the operating period and takes 3 minutes to service. Customers 1 and 2 arrive a minute after customer 0, and will therefore have to wait in line.
Customer 0's wait time should be 0, since they are serviced immediately upon entering the queue. Customer 1 has to wait 2 minutes, while customer 2 will have to wait 12. The simulation takes care of all the bookkeeping required to compute these values.
Customers
Dash operates directly on JSON data using Go structures. Next, define a customer.go file containing a customer type. It has the same fields as the input JSON. The customer type also has access to the event and measure ledgers of the simulation, which it uses to publish and subscribe to events, and to record measurements of wait time. Finally, the customer has pointer fields called arrivalTime and serviceTime for maintaining its internal state.
Customer Types
Go
1
package main
2
​
3
import (
4
    "time"
5
​
6
    "github.com/nextmv-io/code/dash/sim/ledger"
7
)
8
​
9
type customer struct {
10
    Number  int
11
    Arrival int
12
    Service int
13
​
14
    events   ledger.Ledger
15
    measures ledger.Ledger
16
​
17
    arrivalTime *time.Time
18
    serviceTime *time.Time
19
}
Copied!
Actors in Dash communicate through events. These events are published and subscribed to using an event ledger. An event can be anything that can be stored and converted to JSON.
There are two events that pertain to customers: times they arrive and enter the queue and times they start being served. We call these events arrival and service. For expediency the customer type is simply aliased, however these could be defined as custom types instead.
Go
1
type arrival customer
2
type service customer
Copied!
Next, we define a measure type for recording the amount of time a customer waits in the queue. Measures are published to a ledger and follow the same rules as events. waitSeconds is defined as a simple integer to track how long customers wait (not who has to wait).
Go
1
type waitSeconds int
Copied!
Customer Run Method
Dash works by maintaining a set of active actors in its simulation. When constructing a new simulation, actors are added to it with an initial time to "run" them. Dash adds them to its pool of actors, and calls their Run methods at the specified times.
All actors must implement Run. This method takes in the current time, updates the actor's state, and returns the next time to run them along with a boolean indicator of whether not there is anything left for them to do.
The example Run method is shown below. It has three sections. In the first, the customer tests to see if they have entered service. If so, they publish a measurement of their wait time in the queue, and tell Dash that they don't have anything left to do.
The second section contains logic for a customer arrival. If a customer hasn't recorded its arrival time yet, it does so and publishes an arrival event. Finally, in the third section the customer waits in the queue.
Go
1
func (c *customer) Run(now time.Time) (time.Time, bool) {
2
    // 1. Customer has entered service.
3
    if c.serviceTime != nil {
4
        wait := c.serviceTime.Sub(*c.arrivalTime) / time.Second
5
        c.measures.Publish(waitSeconds(wait))
6
        return time.Time{}, false
7
    }
8
​
9
    // 2. Customer arrives.
10
    if c.arrivalTime == nil {
11
        c.arrivalTime = &now
12
        c.events.Publish(arrival(*c))
13
    }
14
​
15
    // 3. Customer waits in the queue.
16
    return now.Add(time.Minute), true
17
}
Copied!
Customer Events & Measures
Since the example customer type publishes measurements of its wait time, it must implement Dash's Measure interface. This means defining a method named MeasureTo so Dash can tell it where to publish measurements.
Go
1
func (c *customer) MeasureTo(measures ledger.Ledger) {
2
    c.measures = measures
3
}
Copied!
Similarly, the customer communicates its arrivals to other actors through events. To do so, it must implement the Publisher interface. This requires a PublishTo method.
Go
1
func (c *customer) PublishTo(events ledger.Ledger) {
2
    c.events = events
3
}
Copied!
The example customer publishes arrival events and responds to service events. In order to update its state based on events published by other actors in the simulation, the customer implements the Subscriber interface through SubscribeTo. Note that SubscribeTo receives a ledger.Subscriber type, which lets us associate a handler with an event type.
Go
1
func (c *customer) SubscribeTo(subscriber ledger.Subscriber) {
2
    subscriber.Subscribe(c.service)
3
}
4
​
5
func (c *customer) service(now time.Time, event service) {
6
    if event.Number == c.Number {
7
        c.serviceTime = &now
8
    }
9
}
Copied!
Any number of handlers can be created for a subscriber. These handlers are updated before each call to the actor's Run method. This means that when Dash selects a customer actor to run, it first processes all events published to the event ledger since the last time it ran. Thus our customer's state is kept up to date.
Server
The example server implementation has many of the same components as the customer. The server does not have any data in the input JSON, so define the server type in server.go as a queue of arrival events to process and an event ledger to publish to.
Go
1
package main
2
​
3
import (
4
    "time"
5
​
6
    "github.com/nextmv-io/code/dash/sim/ledger"
7
)
8
​
9
type server struct {
10
    queue  []arrival
11
    events ledger.Ledger
12
}
Copied!
The server's Run method is simple. If the server has a nonempty queue of customer arrivals to serve, it starts the first one and publishes their service time. The server is then busy until they are done servicing that customer. Otherwise, the server waits for something to do.
Go
1
func (s *server) Run(now time.Time) (time.Time, bool) {
2
    if len(s.queue) > 0 {
3
        c := s.queue[0]
4
        s.queue = s.queue[1:]
5
        s.events.Publish(service(c))
6
        return now.Add(time.Duration(c.Service) * time.Minute), true
7
    }
8
​
9
    return now.Add(time.Minute), true
10
}
Copied!
A server publishes service events just like a customer publishes arrival events.
Go
1
func (s *server) PublishTo(events ledger.Ledger) {
2
    s.events = events
3
}
Copied!
Finally, a server subscribes to arrival events. Whenever it encounters one, it adds that arrival to its queue.
Go
1
func (s *server) SubscribeTo(subscriber ledger.Subscriber) {
2
    subscriber.Subscribe(s.enqueue)
3
}
4
​
5
func (s *server) enqueue(now time.Time, event arrival) {
6
    s.queue = append(s.queue, event)
7
}
Copied!
Runner
A Dash runner is needed to read input data into the queue simulation, run that simulation, and aggregate its output. The CLI runner takes a handler with a variable to unmarshal the input into and options parsed from the environment and command line flags, and returns a simulator.
Go
1
package main
2
​
3
import (
4
    "time"
5
​
6
    "github.com/nextmv-io/code/dash/run/cli"
7
    "github.com/nextmv-io/code/dash/sim"
8
)
9
​
10
func main() {
11
    cli.Run(
12
        func(customers []*customer, opt sim.Options) (sim.Simulator, error) {
13
            simulator := sim.New(opt)
14
​
15
            now := time.Now()
16
            for _, c := range customers {
17
                arrival := now.Add(time.Duration(c.Arrival) * time.Minute)
18
                simulator.Add(arrival, c)
19
            }
20
​
21
            simulator.Add(now, &server{})
22
​
23
            return simulator, nil
24
        },
25
    )
26
}
Copied!
Next, build the simulation into an atomic binary and run it on the example input.
Note that the time is the amount of simulated time to run for and limits is the actual run time limits. Use time to set how much simulated time to run for and limits to set time limits. For example, setting a time of 10 hours will run 10 hours of simulated time, but pairing that with limits of 1 minute will ensure that the simulation stops after 1 real minute of time, regardless of whether those 10 simulated hours have completed. In our model, there is always a server actor lurking about, so we have to tell Dash when to quit.
Bash
1
go build
2
./queue -dash.simulator.time.duration 2h < input.json | jq
Copied!
or, with command-line file input/output flags
Bash
1
go build
2
./queue -dash.simulator.time.duration 2h \
3
        -dash.runner.input.path input.json \
4
        -dash.runner.output.path output.json
Copied!
By default, this doesn't give us much information beyond input options and time statistics.
JSON
1
{
2
  "dash":{
3
    "version":"v0.2.1"
4
  },
5
  "events":null,
6
  "measures":null,
7
  "options":{
8
    "time":{
9
      "duration":"2h0m0s"
10
    }
11
  },
12
  "statistics":{
13
    "time":{
14
      "elapsed":"281.891µs",
15
      "simulated":"2h1m0s",
16
      "start":"2020-09-03T08:38:38.090664-07:00"
17
    }
18
  }
19
}
Copied!
We can tell Dash to include its event log in the output. This adds an events field to the JSON.
Bash
1
./queue -dash.runner.output.events \
2
        -dash.simulator.time.duration 1m < input.json | jq
Copied!
or
Bash
1
./queue -dash.runner.input.path input.json \
2
        -dash.runner.output.path output.json \
3
        -dash.runner.output.events \
4
        -dash.simulator.time.duration 1m
Copied!
JSON
1
{
2
  "dash":{
3
    "version":"v0.2.1"
4
    },
5
    "events":[
6
      {
7
        "event":{
8
          "Number":0,
9
          "Arrival":0,
10
          "Service":3
11
        },
12
        "type":"arrival",
13
        "when":"2020-09-03T08:43:10.916384-07:00"
14
      },
15
      {
16
        "event":{
17
          "Number":0,
18
          "Arrival":0,
19
          "Service":3
20
        },
21
        "type":"service",
22
        "when":"2020-09-03T08:43:10.916384-07:00"
23
      },
24
      {
25
        "event":{
26
          "Number":1,
27
          "Arrival":1,
28
          "Service":10
29
        },
30
        "type":"arrival",
31
        "when":"2020-09-03T08:44:10.916384-07:00"
32
      },
33
      {
34
        "event":{
35
          "Number":2,
36
          "Arrival":1,
37
          "Service":7}
38
        ,
39
        "type":"arrival",
40
        "when":"2020-09-03T08:44:10.916384-07:00"
41
      }
42
    ],
43
    "measures":null,
44
    "options":{
45
      "time":{
46
        "duration":"1m0s"
47
        }
48
      },
49
      "statistics":{
50
        "time":{
51
          "elapsed":"84.777µs",
52
          "simulated":"2m0s",
53
          "start":"2020-09-03T08:43:10.91637-07:00"
54
        }
55
      }
56
    }
Copied!
In this example, customers publish arrival events, which the server subscribes to. The server publishes service events, which the customers subscribe to. The customers measure their time spent in the queue and publish those measurements to the measure ledger. This requires that the customers implement MeasureTo.
Requesting measurements from Dash is similar to requesting events.
Bash
1
./queue -dash.runner.output.measures \
2
        -dash.simulator.time.duration 30m < input.json | jq
Copied!
or alternatively
Bash
1
./queue -dash.runner.input.path input.json \
2
        -dash.runner.output.path output.json \
3
        -dash.runner.output.measures \
4
        -dash.simulator.time.duration 30m
Copied!
JSON
1
{
2
  "dash":{
3
    "version":"v0.2.1"
4
    },
5
    "events":null,
6
    "measures":[
7
      {
8
        "measure":0,
9
        "type":"waitSeconds",
10
        "when":"2020-09-03T08:53:03.882231-07:00"
11
      },
12
      {
13
        "measure":120,
14
        "type":"waitSeconds",
15
        "when":"2020-09-03T08:56:03.882231-07:00"
16
      },
17
      {
18
        "measure":720,
19
        "type":"waitSeconds",
20
        "when":"2020-09-03T09:06:03.882231-07:00"
21
      },
22
      {
23
        "measure":780,
24
        "type":"waitSeconds",
25
        "when":"2020-09-03T09:13:03.882231-07:00"
26
      },
27
      {
28
        "measure":780,
29
        "type":"waitSeconds",
30
        "when":"2020-09-03T09:15:03.882231-07:00"
31
      },
32
      {
33
        "measure":720,
34
        "type":"waitSeconds",
35
        "when":"2020-09-03T09:18:03.882231-07:00"
36
      },
37
      {
38
        "measure":900,
39
        "type":"waitSeconds",
40
        "when":"2020-09-03T09:22:03.882231-07:00"
41
      }
42
    ],
43
    "options":{
44
      "time":{
45
        "duration":"30m0s"
46
      }
47
    },
48
    "statistics":{
49
      "time":{
50
        "elapsed":"183.519µs",
51
        "simulated":"31m0s",
52
        "start":"2020-09-03T08:52:03.882219-07:00"
53
      }
54
    }
55
  }
Copied!
In this example, the waitSeconds measurement type is simply an int. If we want more information we can make it a struct or provide a MarshalJSON method, and Dash will automatically incorporate those details into its output.
Randomness
Dash also has the ability to sample randomly from a distribution to represent behaviors. Check out the Random Queue example for more details.
Knapsack
Random queue simulation
Last modified 6mo ago
Export as PDF
Copy link
Contents