Queue¶

Salabim has a class Queue for queue handling of components. The advantage over the standard list and deque are:

• double linked, resulting in easy and efficient insertion and deletion at any place
• builtin data collection and statistics
• priority sorting

Salabim uses queues internally for resources and states as well.

Definition of a queue is simple:

waitingline=sim.Queue('waitingline')


The name of a queue can retrieved with q.name().

There is a set of methods for components to enter and leave a queue and retrieval:

Component Queue Description
c.enter(q) q.add(c) or q.append(c) c enters q at the tail
c.enter_in_front(q, c1) q.add_in_front_of(c, c1) c enters q in front of c1
c.enter_behind(q, c1) q.add_behind(c, c1) c enters q behind c1
c.enter_sorted(q, p) q.add_sorted(c, p) c enters q according to priority p
c.leave(q) q.remove(c) q.insert(c,i) q.pop() q.pop(i) q.head() or q[0] q.tail() or q[-1] q.index(c) q.component_with_name(n) c leaves q insert c just before the i-th component in q removes head of q and returns it removes i-th component in q and returns it returns head of q returns tail of q returns the position of c in q returns the component with name n in q
c.successor(q) q.successor(c) successor of c in q
c.predecessor(q) q.predecessor(c) predecessor of c in q
c.count(q) q.count(c) returns 1 if c in q, 0 otherwise
c.queues()   returns a set with all queues where c is in
c.count() returns number of queues c is in

Queue is a standard ABC class, which means that the following methods are supported:

• len(q) to retrieve the length of a queue, alternatively via the level monitor with q.length()
• c in q to check whether a component is in a queue
• for c in q: to traverse a queue (Note that it is even possible to remove and add components in the for body).
• reversed(q) for the components in the queue in reverse order
• slicing is supported, so it is possible to get the 2nd, 3rd and 4th component in a queue with q[1:4] or q[::-1] for all elements in reverse order.
• del q[i] removes the i’th component. Also slicing is supported, so e.g. to delete the last three elements from queue, del q[-1:-4:-1]
• q.append(c) is equivalent to q.add(c)

It is possible to do a number of operations that work on the queues:

• q.intersection(q1) or q & q1 returns a new queue with components that are both in q and q1
• q.difference(q1) or q - q1 returns a new queue with components that are in q1 but not in q2
• q.union(q1) or q | q1 or q + q1 returns a new queue with components that are in q or q1
• q.symmetric_difference(q) or q ^ q1 returns a queue with components that are in q or q1, but not both
• q.clear() empties a queue
• q.copy() copies all components in q to a new queue. The queue q is untouched.
• q.move() copies all components in q to a new queue. The queue q is emptied.
• q.extend(q1) extends the q with elements in q1, that are not yet in q

Note that it is possible to rename a queue (particularly those created with +, -, ^, | or sum) with the rename() method:

(q0 | q1 | q2 | q3).rename('q0 - q3).print_info()


Salabim keeps track of the enter time in a queue: c.enter_time (q)

Unless disabled explicitly, the length of the queue and length of stay of components are monitored in q.length and q.length_of_stay. It is possible to obtain a number of statistics on these monitors (cf. Monitor).

With q.print_statistics() the key statistics of these two monitors are printed.

E.g.:

-------------------------------------------- -------------- ------------ ------------ ------------
Length of waitingline                        duration          50000        48499.381     1500.619
mean                  8.427        8.687
std.deviation         4.852        4.691

minimum               0            1
median                9           10
90% percentile       14           14
95% percentile       16           16
maximum              21           21

Length of stay in waitingline                entries            4995         4933           62
mean                 84.345       85.405
std.deviation        48.309       47.672

minimum               0            0.006
median               94.843       95.411
90% percentile      142.751      142.975
95% percentile      157.467      157.611
maximum             202.153      202.153


The arrival rate and departure rate (number of arrivals, departures per time unit) can be found with:

• q.arrival_rate()
• q.departur_rate()

With q.print_info() a summary of the contents of a queue can be printed.

E.g.

Queue 0x20e116153c8
name=waitingline
component(s):
customer.4995        enter_time 49978.472 priority=0
customer.4996        enter_time 49991.298 priority=0