Browser width is too narrow.

Rotate the screen or increase the width.
OpenSIMPLY Free simulation modeling software
▲
▲
▲

The model of the M/M/C/K,T queuing system

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 are also arrived as a Poisson process to common queue. 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 queue

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 the "TGenerator", "TQueue", "TSelector" and "TServer" classes represent these blocks correspondingly.

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 parameter "RandomSelection", 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 "TGenerator", "TQueue" and "TSelector" class instances accordingly. The "TServer" class and server parameters will be specified as parameters in the "Assign" method of "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 as in the M/M/1 loss system example.

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.