mirror of
https://github.com/Zenithsiz/ist-ddrs-lab2
synced 2026-02-03 14:10:05 +00:00
91 lines
3.2 KiB
R
91 lines
3.2 KiB
R
# Determines the flow blocking probabilities of a circuit switched network using
|
|
# the reduced load approximation. It uses the method of repeated substitutions
|
|
# (Keith Ross book, page 184)
|
|
|
|
source("erlB.R")
|
|
|
|
##############################################################################
|
|
# Insert here the input parameters
|
|
|
|
# Links must be identified by contiguous integers starting at 1. These numbers
|
|
# must be used as indexes of the LinkCapacities vector and of the vectors
|
|
# defining the routes of each flow. Do not use the node numbers for this
|
|
# purpose!
|
|
|
|
# Define here the capacity of each link. The capacity must be expressed in number
|
|
# of circuits. This assumes that each call occupies one circuit.
|
|
LinkCapacities <- c(2, 2, 2) # In number of circuits
|
|
|
|
# Define here the flows. Flows is a list of lists that stores in each list (1)
|
|
# the offered load and (2) the route of each flow; the routes must be defined
|
|
# using the link identifiers (and not the node identifiers)
|
|
Flows <- list(
|
|
list(load = 0.5, route = c(1, 3)),
|
|
list(load = 0.5, route = c(2, 3))
|
|
)
|
|
|
|
# Do not write bellow this line!
|
|
##############################################################################
|
|
|
|
numLinks <- length(LinkCapacities)
|
|
numFlows <- length(Flows)
|
|
|
|
niter <- 0
|
|
errorTarget <- 0.00001
|
|
error <- Inf
|
|
|
|
LinkBlocking <- rep(0, numLinks)
|
|
LinkBlockingPrevious <- rep(Inf, numLinks)
|
|
while (error > errorTarget) { # Repeated substitutions
|
|
LinkLoads <- rep(0, numLinks)
|
|
for (j in 1:numLinks) { # Iterates over links
|
|
for (k in 1:numFlows) { # Iterates over flows
|
|
Route <- Flows[[k]]$route
|
|
if (any(Route == j)) { # Checks to see if this flow crosses link j
|
|
Load <- Flows[[k]]$load
|
|
AcceptRoute <- Route[-which(Route == j)] # Removes link j from this flow
|
|
LengthAcceptRoute <- length(AcceptRoute)
|
|
if (LengthAcceptRoute == 0) { # Computes acceptance probability of this flow
|
|
AcceptProb <- 1
|
|
} else {
|
|
AcceptProb <- 1
|
|
for (l in 1:LengthAcceptRoute) {
|
|
Link <- AcceptRoute[l]
|
|
AcceptProb <- AcceptProb * (1 - LinkBlocking[Link])
|
|
}
|
|
}
|
|
ReducedLoad <- Load * AcceptProb # Computes reduced load of this flow
|
|
LinkLoads[j] <- LinkLoads[j] + ReducedLoad # Accumulates load in link
|
|
}
|
|
} # Ends iteration over flows
|
|
} # Ends iteration over links
|
|
for (m in 1:numLinks) { # Calculates link blocking probabilities
|
|
LinkBlocking[m] <- erlB(LinkLoads[m], LinkCapacities[m])
|
|
}
|
|
error <- max(abs(LinkBlocking - LinkBlockingPrevious))
|
|
LinkBlockingPrevious <- LinkBlocking
|
|
niter <- niter + 1
|
|
}
|
|
|
|
# Computes blocking probability of each flow
|
|
FlowBlocking <- c(length = numFlows)
|
|
for (i in 1:numFlows) {
|
|
Route <- Flows[[i]]$route
|
|
AcceptProb <- 1
|
|
for (j in 1:length(Route)) {
|
|
Link <- Route[j]
|
|
AcceptProb <- AcceptProb * (1 - LinkBlocking[Link])
|
|
}
|
|
FlowBlocking[i] <- 1 - AcceptProb
|
|
}
|
|
|
|
cat(sprintf("Number of iterations = %d", niter), "\n")
|
|
|
|
for (i in 1:numLinks) {
|
|
cat(sprintf("Blocking probability of link %d = %f", i, LinkBlocking[i]), "\n")
|
|
}
|
|
|
|
for (i in 1:numFlows) {
|
|
cat(sprintf("Blocking probability of flow %d = %f", i, FlowBlocking[i]), "\n")
|
|
}
|