({{, (RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess])[γ,r,μ,c] 
represents an open (Jackson) queueing network process with arrival vector γ, routing probability matrix r, service vector μ, and service channel vector c. }, {, (RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess])[γ,r,μ,c,k]
represents a closed (Gordon–Newell) queueing network process with k jobs in the system.}})

OpenersNotesSection(Spacer1)Details

(RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess]) is a continuous-time and discrete-state process.

(RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess]) at time t is the number of customers in the network at time t.

The arrivals at node i in the network follow (RefLink[PoissonProcess, paclet:ref/PoissonProcess])[(Subscript[γ, i])].

The service times at node i in the network follow (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])[(Subscript[μ, i])].

(RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess]) allows c to be any vector of positive integers, k any positive integer, and the entries of the routing probability matrix r must lie between 0 and 1.

(RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess]) can be used with such functions as (RefLink[QueueProperties, paclet:ref/QueueProperties]), (RefLink[StationaryDistribution, paclet:ref/StationaryDistribution]), and (RefLink[RandomFunction, paclet:ref/RandomFunction]).

OpenersPrimaryExamplesSection(Spacer1)Examples  (28)

OpenersExampleSection0(Spacer1)Basic Examples  (2)

Define a closed queueing network process:

γ={0,0,0,0};μ={1,0.7,1,2};
r={{0,0.5,0.3,0.2},{1,0,0,0},{1,0,0,0},{1,0,0,0}};
c={1,1,1,1};k=7;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

Simulate it:

data=RandomFunction[𝒩,{0,100}]

ListStepPlot[data,Filling->Axis]

Define an open queueing network process:

γ={4,5};μ={8,10};
r={{0,1/2},{1/4,0}};
c={1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Properties of the first node in the network:

QueueProperties[{𝒩,1}]

OpenersExampleSection1(Spacer1)Scope  (10)

OpenersExampleSubsection0(Spacer1)Simple Feedforward Networks  (2)

Define a network with three queues in series:

γ={3.,0,0};μ={4,7,8.2};
r={{0,1,0},{0,0,1},{0,0,0}};
c={1,1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Routing probability matrix for the network:

r//MatrixForm

Compute a probability for the steady state of the network:

Probability[x==2&&y==1&&z==3,{x,y,z}\[Distributed]𝒩[∞]]

Verify the result using Burke's theorem:

Probability[x==2&&y==1&&z==3,{x,y,z}\[Distributed]ProductDistribution[QueueingProcess[3,4][∞],QueueingProcess[3,7][∞],QueueingProcess[3,8.2][∞]]]

Performance measures for the first node in the network:

QueueProperties[{𝒩,1}]

Define a feedforward queueing network:

γ={3.,4,0,2,1};μ={4,6,8.2,9,11};
r={{0,0,1,0,0},{0,0,1,0,0},{0,0,0,0.3,0.7},{0,0,0,0,0},{0,0,0,0,0}};
c={1,1,1,1,1};

Routing probability matrix for the network contains no back routes:

r//MatrixForm

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Compute a probability for the steady state of the network:

Probability[x1==1&&x2==1&&x3==0&&x4==0&&x5==2,{x1,x2,x3,x4,x5}\[Distributed]𝒩[∞]]

Verify the result using Poisson aggregation and decomposition:

Probability[x1==1&&x2==1&&x3==0&&x4==0&&x5==2,{x1,x2,x3,x4,x5}\[Distributed]ProductDistribution[QueueingProcess[3,4][∞],QueueingProcess[4,6][∞],QueueingProcess[3+4,8.2][∞],QueueingProcess[7*0.3+2,9][∞],QueueingProcess[7*0.7+1,11][∞]]]

Performance measures at the fourth and fifth nodes in the network:

Table[QueueProperties[{𝒩,i}],{i,{4,5}}]

OpenersExampleSubsection1(Spacer1)Simple Feedback Networks  (3)

Define a network process corresponding to a queue with feedback probability p:

𝒩=QueueingNetworkProcess[{γ},{{p}},{μ},{1}];

(RefLink[PDF, paclet:ref/PDF]) for the steady state of the network:

𝒟=StationaryDistribution[𝒩];

PDF[𝒟,{n}]

Sum[%,{n,0,∞}]

Performance measures:

QueueProperties[{𝒩,1}]//Simplify

Network with two nodes that feed back into each other:

γ={4,7};μ={9,14};
r={{0,1/3},{1/8,0}};
c={1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Routing probability matrix for the network:

r//MatrixForm

Mean system size:

Total[Table[QueueProperties[{𝒩,i},"MeanSystemSize"],{i,2}]]//N

Mean time spent in the system:

%/Total[γ]//N

Define a cyclic queue with three nodes:

γ={0,0,0};μ={2.5,1.1,4.5};
r={{0,1,0},{0,0,1},{1,0,0}};
c={1,2,1};k=9;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

Routing probability matrix for the network:

r//MatrixForm

Simulate the network:

data=RandomFunction[𝒩,{0,40}]["Path"];

Table[ListLinePlot[Table[{data[[i,1]],data[[i,2,j]]},{i, Length[data]}],Filling-> Axis,FillingStyle-> LightRed,ImageSize-> 135],{j,3}]

OpenersExampleSubsection2(Spacer1)Jackson Networks  (2)

Define an open queueing network:

γ={3,6};μ={7,17};
r={{1/6.,1/9},{1/4,1/8}};
c={1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Simulate the network:

data=RandomFunction[𝒩,{0,100}]["Path"];

Plot the simulated values at the nodes in the network:

Table[ListLinePlot[Table[{data[[i,1]],data[[i,2,j]]},{i, Length[data]}],Filling-> Axis,FillingStyle-> LightRed],{j,2}]

Performance measures at the nodes in the network:

Table[QueueProperties[{𝒩,i}],{i,2}]

Stationary distribution for an open network:

γ={1,5};μ={3,8};
r={{1/4,1/9},{1/8,0}};
c={1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

𝒟=StationaryDistribution[𝒩];

Probability density function:

PDF[𝒟,{m,n}]

Sum[%,{m,0,∞},{n,0,∞}]

DiscretePlot3D[PDF[𝒟,{m,n}]//Evaluate,{m,0,4},{n,0,4},ExtentSize->0.5,PlotRange->All]

Cumulative distribution function:

CDF[𝒟,{m,n}]

DiscretePlot3D[CDF[𝒟,{m,n}]//Evaluate,{m,0,35},{n,0,35},ExtentSize->Right,PlotRange->{0,1.05}]

Mean and variance:

Mean[𝒟]

Table[QueueProperties[{𝒩,i},"MeanSystemSize"],{i,2}]

Variance[𝒟]

Table[Variance[MarginalDistribution[𝒟,i]],{i,2}]

Probabilities and expectations:

NProbability[m+n<7, {m,n}\[Distributed]𝒟]

Expectation[m^3+n^2, {m,n}\[Distributed]𝒟]

OpenersExampleSubsection3(Spacer1)Gordon–Newell Networks  (3)

Define a closed queueing network:

γ={0,0,0};μ={1.3,4,5};
r={{0,0.2,0.8},{0,0,1},{0.3,0.7,0}};
c={1,2,1};k=10;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

There are no arrivals from outside the network:

γ

Properties of the second node in the network:

QueueProperties[{𝒩,2}]

Simulate the network:

data=RandomFunction[𝒩,{0,100}]["Path"];

Plot the simulated values at the first two nodes in the network:

Table[ListLinePlot[Table[{data[[i,1]],data[[i,2,j]]},{i, Length[data]}],Filling-> Axis,FillingStyle-> LightRed],{j,2}]

A closed network with seven nodes:

γ={0,0,0,0,0,0,0};μ={85,85,120,120,70,20,20};
r={{1/3,1/4,0,1/4,0,1/6,0},
{1/3,1/4,0,1/4,1/6,0,0}, 
{0,0,1/3,1/3,1/3,0,0}, 
 {1/3,0,1/3,0,1/3,0,0}, 
 {0,0,0,5/6,0,0,1/6}, 
 {1/6,1/6,1/6,1/6,1/6,1/6,0},
{0,1/6,1/6,1/6,1/6,1/6,1/6}};
c={1,1,1,1,1,1,1};k=35;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

Steady-state performance measures at each node in the network:

Table[QueueProperties[{𝒩,i},"MeanSystemSize"],{i,7}]//N

Table[QueueProperties[{𝒩,i},"MeanSystemTime"],{i,7}]//N

Table[QueueProperties[{𝒩,i},"MeanQueueSize"],{i,7}]//N

Table[QueueProperties[{𝒩,i},"MeanQueueTime"],{i,7}]//N

Stationary distribution for a closed network:

γ={0,0,0};μ={3,4,8};
r={{0,1,0},{0,0,1},{1,0,0}};
c={1,1,1};k=2;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

𝒟=StationaryDistribution[𝒩];

Probability density function:

PDF[𝒟,{m,n,p}]

Sum[%,{m,0,∞},{n,0,∞},{p,0,∞}]

Mean and variance:

Mean[𝒟]

Table[QueueProperties[{𝒩,i},"MeanSystemSize"],{i,3}]

Variance[𝒟]

Probabilities and expectations:

Probability[m+n>p, {m,n,p}\[Distributed]𝒟]

Expectation[m+n+p, {m,n,p}\[Distributed]𝒟]

Expectation[m^3+n^2+p, {m,n,p}\[Distributed]𝒟]

OpenersExampleSection3(Spacer1)Applications  (12)

OpenersExampleSubsection4(Spacer1)Machine Repair  (3)

An electronics manufacturer uses five robots when manufacturing its circuit boards. The breakdown times for the robots are exponentially distributed with a mean of 30 hours. The company has two repairmen who can repair the robots, and the repair times are exponentially distributed with a mean of three hours. Find the average number of robots that are operational at any given time by using a queueing network with two states, "working" and "broken":

γ={0,0};μ={1/30,1/3};
r={{0,1},{1,0}};
c={5,2};k=5;

maintenanceNetwork=QueueingNetworkProcess[γ,r,μ,c,k];

The average number of operational robots:

QueueProperties[{maintenanceNetwork,1},"MeanSystemSize"]//N

Two machines in a factory are desired to be operational at all times. The machines break down according to an exponential distribution with mean failure rate 1. Upon breakdown, a machine has a probability 3/4 that it can be repaired locally by a single repair person who works according to an exponential distribution with parameter 1. With probability 1/4, the machine must be repaired by a specialist who works according to an exponential distribution with parameter 3. There is a probability 1/3 that a machine will also require the special service after completing the local service. Find the percentage of time that both machines are operational by using a queueing network with states "working", "locallyRepairable", and "specialistRepairable":

γ={0,0,0};μ={1,1,3};
r={{0,3/4,1/4},{2/3,0,1/3},{1,0,0}};
c={2,1,1};k=2;

repairNetwork=QueueingNetworkProcess[γ,r,μ,c,k];

Both machines are operational for around 23% of the time:

PDF[repairNetwork[∞],{2,0,0}]//N

A repair facility shared by a large number of machines has two sequential stations with service rates one per hour and two per hour, respectively. The cumulative failure rate of the machines is 0.5 per hour. Find the probability that both service stations in the repair facility are idle:

γ={0.5,0};μ={1,2};
r={{0,1},{0,0}};
c={1,1};

serviceNetwork=QueueingNetworkProcess[γ,r,μ,c];

Probability that both service stations are idle:

PDF[serviceNetwork[∞],{0,0}]

Average repair time for a machine going through both repair stages:

QueueProperties[{serviceNetwork,1},"MeanSystemTime"]+QueueProperties[{serviceNetwork,2},"MeanSystemTime"]

OpenersExampleSubsection5(Spacer1)Computer Systems  (4)

In a series network of three routers, the packets arrive at the rate of 100 packets per second. The service rates of the three routers are 250 packets per second, 150 packets per second, and 200 packets per second, respectively. Find the probability of having two packets at each of the three routers using a series network:

γ={100,0,0};μ={250,150,200};
r={{0,1,0},{0,0,1},{0,0,0}};
c={1,1,1};

routerProcess=QueueingNetworkProcess[γ,r,μ,c];

Probability of having two packets at each of the three routers:

𝒟=StationaryDistribution[routerProcess];

PDF[𝒟,{2,2,2}]

N[%]

Obtain the same result using (RefLink[Probability, paclet:ref/Probability]):

Probability[x==2&&y==2&&z==2,{x,y,z}\[Distributed]𝒟]//N

Find the probability that there are three packets in the network:

Probability[x+y+z==3,{x,y,z}\[Distributed]𝒟]//N

Ten requests circulate in a three-node central server system. The central server (node 1) sends requests with probabilities 0.3 and 0.7 to the remaining two nodes. The exponential service times at the three nodes are 1, 2, and 0.8, respectively. Find the bottleneck device in this closed network of servers:

γ={0,0,0};μ={1,1/2,1/0.8};
r={{0,0.3,0.7},{1,0,0},{1,0,0}};
c={1,1,1};k=10;

serverNetwork=QueueingNetworkProcess[γ,r,μ,c,k];

The first node is the bottleneck device:

Table[QueueProperties[{serverNetwork,i},"MeanSystemTime"],{i,3}]

Table[QueueProperties[{serverNetwork,i},"MeanSystemSize"],{i,3}]

Ten requests circulate in a three-node central server system. The central server (node 1) sends requests with probabilities 0.3 and 0.5 to the remaining two nodes. External requests arrive only at the central server and follow a Poisson process with a rate of 0.15, while the exponential service times at the three nodes are 1, 2, and 0.8, respectively. Find the bottleneck device in this open network of servers:

γ={0.15,0,0};μ={1,1/2,1/0.8};
r={{0,0.3,0.5},{1,0,0},{1,0,0}};
c={1,1,1};

serverNetwork=QueueingNetworkProcess[γ,r,μ,c];

The first node (central server) is the bottleneck device:

Table[QueueProperties[{serverNetwork,i},"MeanSystemTime"],{i,3}]

Table[QueueProperties[{serverNetwork,i},"MeanSystemSize"],{i,3}]

New programs arrive at a CPU according to a Poisson process with rate γ. A program spends an exponentially distributed execution time of mean 1/μ1 in the CPU. At this stage, the program execution is either complete with probability p or it requires additional information from secondary storage with probability 1-p. The retrieval of information from secondary storage requires an exponentially distributed amount of time with mean 1/μ2. Find the mean time that each program spends in the system:

cpuProcess=QueueingNetworkProcess[{γ,0},{{0,1-p},{1,0}},{μ1,μ2},{1,1}];

Using Little's formula, this is the mean time spent by a program:

(QueueProperties[{cpuProcess,1}, "MeanSystemSize"]+QueueProperties[{cpuProcess,2}, "MeanSystemSize"])/γ//FullSimplify

OpenersExampleSubsection6(Spacer1)Customer Service  (1)

Customers arrive at a supermarket according to a Poisson process with a mean rate of 40 per hour. They take an average of 3/4 hour to fill their shopping carts before proceeding to the four checkout counters in the store. The checkout times are exponentially distributed with a mean of four minutes. Find the average number of customers in the store at any given time:

γ={40,0};μ={4/3,60/4};
r={{0,1},{0,0}};
c={∞,4};

shoppingProcess=QueueingNetworkProcess[γ,r,μ,c];

The average number of customers in the store:

QueueProperties[{shoppingProcess,1},"MeanSystemSize"]+QueueProperties[{shoppingProcess,2},"MeanSystemSize"]//N

OpenersExampleSubsection7(Spacer1)Communication Networks  (2)

A transmitter has two permits for message transmission. As long as the transmitter has a permit, it generates messages at an exponential rate of λ. The messages enter the transmission system and are sent at an exponential rate of μ. As soon as a message arrives on the other side of the transmission system, the corresponding permit is sent back to the transmitter at an exponential rate of μ. Find the steady-state probability mass function (pmf) for the network:

γ={0,0,0};s={λ,μ,μ};
r={{0,1,0},{0,0,1},{1,0,0}};
c={1,1,1};k=2;

transmissionProcess=QueueingNetworkProcess[γ,r,s,c,k];

Steady-state distribution for the network:

𝒟=StationaryDistribution[transmissionProcess];

Steady-state pmf for the network:

PDF[𝒟,{m,n,p}]

Probability that there are no messages at the transmitter:

Probability[m==0,{m,n,p}\[Distributed]𝒟]

The following shows the telephone system at an insurance company. Calls come in to the 800 number (black) and are then directed to claims (red) or policy service (blue):

Graph[{1->2,1-> 3,Table[2-> i,{i,4,6}],Table[3-> j,{j,7,13}],2-> 3,3-> 2}//Flatten,VertexStyle->Evaluate[{1->Black,2->Red,3-> Blue, Table[j-> Green, {j,4,6}], Table[j->Orange, {j, 7,13}]}//Flatten], VertexSize ->Large, PlotTheme-> "DiagramBlock",ImageSize-> 300]

The arrival rates from the outside to the three nodes:

γ={35,0,0};

The service rates at the three nodes:

μ = {120, 10, 3};

The routing probability matrix for the network:

MatrixForm[r = {{0, 0.55, 0.45}, {0, 0, 0.02}, {0, 0.01, 0}}]

The diagram indicates that the service channel vector is as follows:

c={1,3,7};

Hence, this open network is described as follows:

𝒩= QueueingNetworkProcess[γ, r, μ, c];

Compare the mean queue lengths at the three nodes:

Table[QueueProperties[{𝒩,i},"MeanQueueSize"],{i,3}]

The total average time spent by a customer in the system is around 17 minutes:

((∑_i^3)QueueProperties[{𝒩,i},"MeanSystemSize"])/35

% 60

OpenersExampleSubsection8(Spacer1)Airport Terminal  (1)

Passengers arrive at an airport and proceed to one of the four check-in counters at the terminal. Next, they proceed to the security check, and finally they board their flights from one of the three gates in the terminal:

Graph[{1->5,2->5,3-> 5,4->5,5->6,5->7,5->8},VertexStyle->{1->Blue,2->Blue,3->Blue,4->Blue,5->Orange,6->Red,7->Red,8->Red},VertexSize ->0.1,ImageSize->300]

The terminal network is described by:

proc=QueueingNetworkProcess[{300.,400,200,250,0,0,0,0},{{0,0,0,0,1,0,0,0},{0,0,0,0,1,0,0,0},{0,0,0,0,1,0,0,0},{0,0,0,0,1,0,0,0},{0,0,0,0,0,3./10,5./10,2/10},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0}},{400,500,700,300,1200,350,450,400},{1,1,1,1,1,1,1,1}];

Study the performance at the security check and at the third gate:

{QueueProperties[{proc,5}],QueueProperties[{proc,8}]}

OpenersExampleSubsection9(Spacer1)Supply Chain Network  (1)

A manufacturing supply chain is composed of a factory, three warehouses, and six stores:

Graph[{1\[UndirectedEdge]2,1\[UndirectedEdge]3,1\[UndirectedEdge]4,2\[UndirectedEdge]5,2\[UndirectedEdge]6,3\[UndirectedEdge]7,3\[UndirectedEdge]8,4\[UndirectedEdge]9,4\[UndirectedEdge]10},
VertexShape->{1->,2->,3->,4->,5->,6->,7->,8->,9->,10->},VertexSize->0.6]

The arrival, service, and routing information for the network are:

γ={13.,0,0,0,0,0,0,0,0,0};

μ={14,10,11.2,5,14,12.8, 13.4, 17.2,15.9,18.1};

c=Table[1,{10}];

r=(({{0, 0.5, 0.2, 0.3, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0.8, 0.2, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0.4, 0.6, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0.3, 0.7}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}));

𝒩=QueueingNetworkProcess[γ,r,μ,c];

Compare the performance measures at the first and second warehouses:

Row[Table[QueueProperties[{𝒩,i}],{i,{2,3}}]]

OpenersExampleSection4(Spacer1)Properties & Relations  (3)

A queueing network process with a single node is equivalent to a queueing process:

𝒩=QueueingNetworkProcess[{γ},{{p}},{μ},{1}];

Find the arrival rate for the equivalent queueing process:

λ=(λ1/.Solve[λ1==γ+λ1 p,λ1][[1]])

𝒬=QueueingProcess[λ,μ];

These have the same stationary distribution:

PDF[StationaryDistribution[𝒩],{k}]

PDF[StationaryDistribution[𝒬],k]

Define a network with two queues in series:

γ={α,0};μ={a,b};
r={{0,1},{0,0}};
c={1,1};

𝒩=QueueingNetworkProcess[γ,r,μ,c];

(RefLink[PDF, paclet:ref/PDF]) for the steady state of the network:

𝒟=StationaryDistribution[𝒩];

pdf1=PDF[𝒟,{x,y}]

Obtain the same result using a product of the individual queueing processes:

𝒬1=QueueingProcess[α,a];

𝒬2=QueueingProcess[α,b];

pdf2=PDF[ProductDistribution[StationaryDistribution[𝒬1],StationaryDistribution[𝒬2]],{x,y}]

pdf1==pdf2

A zero external arrival vector γ corresponds to a closed queueing network:

γ={0,0};μ={5,1.7};
r={{0.1,0.9},{0.8,0.2}};
c={1,1};k=7;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

There are always exactly seven jobs in this system:

data=RandomFunction[𝒩,{0,5}]["Path"][[All, 2]]

Total[data,{-1}]

OpenersExampleSection5(Spacer1)Neat Examples  (1)

Define a closed queueing network:

γ={0,0,0,0};r={{0,0.5,0.3,0.2},{1,0,0,0},{1,0,0,0},{1,0,0,0}};μ={1,0.5,1,2};c={1,1,1,1};k=7;

𝒩=QueueingNetworkProcess[γ,r,μ,c,k];

Generate random data for the network:

data=RandomFunction[𝒩,{0,10^4}];

Compare the actual property values with the values obtained from simulation:

{QueueProperties[{𝒩,2}],QueueProperties[{data,2}]}

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[QueueingProcess, paclet:ref/QueueingProcess])  ▪  (RefLink[QueueProperties, paclet:ref/QueueProperties])  ▪  (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])  ▪  (RefLink[PoissonProcess, paclet:ref/PoissonProcess])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Queueing Processes, paclet:guide/QueueingProcesses])}, {▪(RefLinkPlain[Random Processes, paclet:guide/RandomProcesses])}, {▪(RefLinkPlain[Systems Modeling, paclet:guide/SystemsModeling])}})}})