Sie sind auf Seite 1von 5

Guide to Matlab programs for ErlangB, Engset, BCQ

Xuan Zheng and M. Veeraraghavan, March 30, 2004


Updated by Xiuduan Fang and Eric Humenay Nov 26, 2006
1. erlangb.m
The function [Pb, U]=erlangb(, m) calculates the blocking probability and
utilization for an M/M/m/m system with an infinite customer population. The
arguments for erlangb.m are as follows:
1) , offered traffic load (defined as the aggregate call arrival rate divided
by the service rate ); a positive number. The unit of is Erlang.
2) m, the number of servers in the system; an positive integer.
The function erlangb returns two values:
1) Pb, call blocking probability.
2) U, utilization.
For example, entering the command [Pb,U]=erlangb(1,5), we get
Pb =0.0031 and U=0.1994, which means that the call blocking probability
is 0.31% and the utilization is 19.94% when =1 erlang and m =5.

2. plot_Pb_util.m
The function plot_Pb_util(starting_rho,ending_rho,step_rho, m, testno) calls
the function erlangb to plot call blocking probability and utilization against
load for a given value of m. It saves the calculated results into a txt file and the
final figure into a Matlab figure. The arguments for plot_Pb_util are as
follows:
1) starting_rho: lower bound for the load - can be >1
2) ending_rho: upper bound for the load - can be >1
3) step_rho: set step_rho a smaller value if you want finer granularity
4) m: the number of servers
5) testno: the id of the test; a number which is attached to the filename string
(i.e., plot_Pb_util for this program) to create the file names for saving figures
and data. For example, if the input testno is 2, then the output figure will be
plot_Pb_util 2.fig and the output txt file will be plot_Pb_util 2.txt.
An example command to run this program is plot_Pb_util(1,20,1,20,1).

3. find_m_util.m
The function [m, U]=find_m_util.m(P_b, load) finds the m needed to meet a
given Pb for a given load and calculates corresponding utilization too. The
outputs are m, the number of servers needed and the utilization, U.

4. plot_m_util.m
The function plot_m_util(starting_rho, ending_rho, step_rho, Pb, testno) plot
m and utilization against load for a given value of Pb. It saves the calculated
results into a txt file and the final figure into a Matlab figure.
For example, plot_m_util(1, 100, 1, 0.01, 1).

5. bcc.m
The function [Pl, Pb]=bcc(load,server,customer) calculates the blocking
probability for a finite number of sources queuing system using the Engset
equation.
The arguments for bcc.m are as follows:
1) , offered traffic load (defined as the per-customer call arrival rate
divided by the service rate ). The unit of is Erlang.
2) m, the number of servers in the system.
3) n, the number of customers.
The function bcc returns two values:
4) Pl, call congestion probability.
5) Pb, time congestion probability.
For example, calling [Pl, Pb]=bcc(0.5, 10, 30), we get call congestion
probability Pl=0.2407 and time congestion probability Pb=0.2617 when
=0.5erlang, m =10, and n=30.

6. plot_bcc.m
The function plot_bcc(starting_rho, ending_rho, step_rho, server, customer,
testno) calls the function [Pl, Pb]=bcc(load,server,customer) to plot call
congestion probability, Pl and time congestion probability Pb against load for
a given number of servers and a given number of customers.
For example, plot_bcc(1/3, 10, 0.5, 3, 4, 1)


7. find_server.m
The function [server, realPl, realPb]=find_server(customer, load, Pl) finds the
number of servers needed to meet a given call congestion probability, Pl,
provided that we know the number of customer and the offer traffic load for
a bcc queueuing system. The arguments for find_server.m are as follows:
1) customer: the number of customers, M
2) load: the offered load for each customer
3) Pl: call congestion probability
The function find_server returns three values:
1) server: the number of servers, N
2) realPl: the actual call congestion probability
3) realPb: the actual time congestion probability

8. bcq.m
The function result=bcq(, , m, n) calculates the mean waiting time for an
M/M/m/n system with a finite customer population. The arguments for bcq.m
are as follows:
1) , the per-customer call arrival rate. The unit of is 1/s.
2) , the service rate. The unit of is 1/s.
3) m, the number of servers in the system.
4) n, the number of customers.
For example, a call bcq(0.5, 0.8, 10, 30) means the mean waiting time
when =0.5, =0.8, m =10, and n=30.

9. plot_bcq.m
The function plot_bcq(lambda, starting_mu, ending_mu, step_mu, server,
customer, testno) calls the function result=bcq(lambda,mu,server,customer) to
plot call waiting time against call holding time for a given value of lambda, a
given number of servers, and a given number of customers.
For example, plot_bcq(3, 1, 10, 1, 3, 10, 1)

10. demo.m
This file calls plot_Pb_util, plot_m_util, plot_bcc, and plot_bcq.

Das könnte Ihnen auch gefallen