Browser width
is too narrow.

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

Simulation model of the M/M/1 loss system

This system consists of only a single server.

Server

The concept of a server implies the holding of entities in accordance with the specified delay time distribution function (service time) and the parameter(s) of this function.

If the server is idle, then when an entity arrives, the server starts servicing it (holding) and becomes busy.

Entity

Entity can represent different concepts in the model. It can be a forklift in a warehouse, or a barbershop client, or a car at a traffic light, a data packet in a computer network, a phone call, a passenger at an airport etc.
Schematic representation of a server in queueing theory

The M/M/1 loss system in terms of queuing theory

Thus, in the M/M/1 loss system, entities arrive at a single server according to a Poisson process. Service time is exponentially distributed.

If the server is busy, then when an entity arrives, it is rejected and considered lost. Therefore, such a system is called a loss system.

Watch the learning video about the M/M/1 loss system.
 
M/M/1 loss system

Blocks for discrete-event simulation

A simulation block in terms of OpenSIMPLY is ready for simulation component of a model.

The model consists of blocks connected in accordance with the behavior of the system under study.

The behavior of a block is described by a class of the programming language.

Any block operates with an entity, an object which passes through the connected blocks.

Using the Simula-like approach it is possible to create models with better performance, but this approach has the following significant drawbacks:
  • Model development takes more time
  • Model statistics must be manually implemented for each model individually
  • It is much more difficult to develop and debug a complex model

Thus, the block simulation approach is much easier and more reliable for model development, and it has built-in powerful and flexible statistics.

The model of the M/M/1 loss system in terms of OpenSIMPLY

To create a model of this system, you will need only two blocks: the Generator block, which creates entities, and the Server block, which simulates their servicing.

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

Download executable models of queuing theory and call centers.
 
OpenSIMPLY block model of the M/M/1 loss system

Model creation

To describe the behavior of the model, you need to create instances of the classes of the blocks used. For instances of the TGenerator and TServer classes, the variables Gen and Srv will be used, respectively.

When creating instances of block classes, some items of initial values must be specified.

For the Generator block
  • the capacity (the maximum number of entities to be created during the model run)
  • the function that determines the interarrival time of entities
  • the function parameter(s)


For the Server block
  • the function that determines the time of entity servicing
  • the function parameter(s)

Model parameters

The following variables and functions will be used for the initial values of the blocks.
  • Capacity: to specify the total number of entities for simulation (Generator)
  • InterarrivalTime: to specify the mean value between entities arrivals (Generator)
  • ServiceTime: to specify the mean value of service time (Server)
  • ExpTime: a block function that returns exponentially distributed random values

Model behavior

The lines below fully describe the behavior of the M/M/1 loss system in terms of the OpenSIMPLY model.

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

Srv := TServer.Create([ExpTime, ServiceTime]);                        //  Creating a Server.

Gen.Connect(Srv)                                                      //  Connecting Generator to Server.

Model wrapper

To compile a model, the code above should be placed in a standard wrapper of a model. This wrapper is the same for any model.

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

procedure TMyModel.Body;       //  Model description.
var
                               //  Blocks declaration.
begin
                               //  Model behavior.
end;

begin                           
       //  Assignment of initial values of the model.
 
  Simulate(TMyModel);           //  Starting a model.
end.

Complete program code containing input data and output of results.

program BlocksStyleMM1;
{$apptype xxx }  // xxx is either "GUI" or "Console" 

uses
  SimBase,
  SimBlocks,
  SimStdGUI;
  
type
  TMyModel = class(TModel)     //  Model declaration.  
    procedure Body; override;
  end;

var
  Capacity,                    //  Model parameters.  
  NumberOfServers: Integer;
  InterarrivalTime,
  ServiceTime: Double;

procedure TMyModel.Body;       //  Model description.
var
  Gen: TGenerator;             //  Blocks declaration. 
  Srv: TServer;
begin                          //  Model behavior.

  Gen := TGenerator.Create([Capacity, ExpTime, InterarrivalTime]);
  Srv := TServer.Create([ExpTime, ServiceTime]); 
  Gen.Connect(Srv);   

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

  Gen.ShowStats;               //  Results.
end;

begin
  Capacity := 1000;            //  Initial values of the model.
  InterarrivalTime := 1;
  ServiceTime := 0.5;

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


To validate the M/M/1 loss model, the simulation results can be verified using the exact formula. So, the value of loss probability can be obtained with Erlang B formula.


Simula-like simulation style

You can also create a simulation model of the M/M/1 loss system using a Simula-like simulation style. It is based on the concept of process, which is the cornerstone of the Simula language.

This style does not involve the use of blocks, and there is no provision for automatic statistics gathering. But despite these disadvantages, the simulation execution time is much faster and the possibility of creating any model components is unlimited.

Take a look at an example of a Simula-like simulation style of the same M/M/1 loss system.