M/M/C/K,T queue simulation

The M/M/C/K,T queuing system in terms of queuing theory

This queuing system can already represent the real objects. Such system is a special case of M/M/C queuing system.

Entities arrive at a common queue with FIFO discipline as a Poisson process. Queue discipline is the FIFO too. Entities from the queue are also distributed between C servers. The service time value of all servers is exponentially distributed. Free server is selected randomly.

The difference is that the queue capacity is not infinite, but limited with K waiting places; the timeout (maximum waiting time) is not infinite, but has a certain value T.

The M/M/C/K,T queuing model in terms of OpenSIMPLY

The Generator, Queue, Selector and Server blocks are used for this system description as for M/M/C queuing system.

In Delphi and Free Pascal, these blocks are represented by the classes TGenerator, TQueue, TSelector and TServer, respectively.

Download executable model of the M/M/C/K,T queuing system as almost real call center.

The M/M/C/K,T queuing system block model

Model creation

FIFO is the default discipline for the Queue block, so it does not need to be specified explicitly.

The selection rule for the Selector block should be specified with the RandomSelection parameter, because the servers are searching randomly. But this parameter can be omitted, and the default selection rule "First free selection" will be used instead, if only the queue probability, the mean waiting time or the mean queue length values are of interest.

Since the Selector block can create the specified number of instances of the block of the specified type and automatically assign them to the selection points, it should not create the TServer type array for a number of servers; and the variable for it is not required.

So, only the variables Gen, Que and Sel will be used for the instances of the classes TGenerator, TQueue and TSelector, respectively. The TServer class and server parameters will be specified as parameters in the Assign method of the TSelector.

Model parameters

Capacity is the total number of entities for simulation.
QueueCapacity is the number of waiting places in a queue.
InterarrivalTime is mean value between entities arrivals.
QueueTimeout is maximum waiting time in a queue.
NumberOfServers is the total number of entities for simulation.
ServiceTime is mean value of service time.
ExpTime is a block function returning exponentially distributed random values.
ConstantTime is a block function returning every time the same constant value.

Model behavior

The lines below fully describe the behavior of M/M/C/K,T queuing system in terms of OpenSIMPLY:

Gen := TGenerator.Create([Capacity, ExpTime, InterarrivalTime]);    //  Creating a Generator.

Que := TQueue.Create([QueueCapacity, ConstantTime, QueueTimeout]);  //  Creating a Queue with constant timeout.

Sel := TSelector.Create([NumberOfServers]);                         //  Creating a Selector with default rule.

Gen.Connect(Que);                                                   //  Connecting Generator to Queue.

Que.Connect(Sel);                                                   //  Connecting Queue to Selector.

Sel.Connect(1, NumberOfServers, TServer, [ExpTime, ServiceTime]);   //  Creating Servers and assigning them to Selector.

To compile a model, the code above should be placed in a standard wrapper of a model.

Complete program code containing input data and output of results.

program MMCKTqueue;
{$apptype xxx }  // xxx "GUI" or "Console" 
{$S-}
uses
  SimBase,
  SimBlocks,
  SimStdGUI;
  
type
  TMyModel = class(TModel)             //  Model declaration.  
    procedure Body; override;
  end;

var
  Capacity,                            //  Model parameters.
  QueueCapacity,
  NumberOfServers: Integer;
  InterarrivalTime,
  QueueTimeout,
  ServiceTime: Double;
 
procedure TMyModel.Body;               //  Model description.
var                                    
  Gen: TGenerator;                     //  Blocks declaration.
  Que: TQueue;   
  Sel: TSelector;
begin 
  Gen := TGenerator.Create([Capacity, ExpTime, InterarrivalTime]);
  Que := TQueue.Create([QueueCapacity, ConstantTime, QueueTimeout]);
  Sel := TSelector.Create([NumberOfServers]); 
  Gen.Connect(Que);
  Que.Connect(Sel);
  Sel.Connect(1, NumberOfServers, TServer, [ExpTime, ServiceTime]);  

  Run(Gen);                            //  Launching the start block.

  Que.ShowStat;                        //  Results.
end;

begin
  Capacity := 3000;                    //  Initial values of the model.
  InterarrivalTime := 1;
  QueueCapacity := 3;
  QueueTimeout :=1 ;
  ServiceTime := 1.3;
  NumberOfServers := 2;

  Simulate(TMyModel);                  //  Starting a model.
end.