mu : nbre de tache que le serveur peut traiter/s lambda : nbre de tache qui arrive /s
library(ggplot2)
library(plyr)
creatDataFrame <- function(n, lambda, mu, nomFonction) {
a <- rexp(n, lambda)
if (nomFonction == "rexp") {
s <- rexp(n, mu)
} else if (nomFonction == "runif") {
s <- runif(n, 0, mu)
} else if (nomFonction == "rlang") {
s <- rgamma(n, mu, 1)
} else if (nomFonction == "rdeter") {
s <- array(1, n)
}
t1 <- c()
t2 <- c()
rn <- c()
t1[1] <- 0
t2[1] <- 0
rn[1] <- 0
for (i in 2:n) {
t1[i] <- t1[i - 1] + a[i]
t2[i] <- max(t1[i], t2[i - 1]) + s[i]
rn[i] <- t2[i] - t1[i]
}
df = data.frame(Type = nomFonction, Lambda = lambda, A = a, S = s, T1 = t1,
T2 = t2, R = rn)
# df
}
creatFinalDataFrame <- function(stepLambda, nloop, nomFonction) {
i <- 0.1
# n<- i*nloop;
df <- creatDataFrame(nloop, i, 1, nomFonction)
i <- i + stepLambda
while (i <= 1) {
# n<-i*nloop;
df <- rbind(df, creatDataFrame(nloop, i, 1, nomFonction))
i <- i + stepLambda
}
df
}
df <- creatFinalDataFrame(0.05, 1000, "rexp")
# df;
dexp <- ddply(df, c("Lambda", "Type"), summarize, Time = mean(R), InterConfi = sd(R)/sqrt(length(R)))
Lois uniforme
df <- creatFinalDataFrame(0.05, 1000, "runif")
dfunif <- ddply(df, c("Lambda", "Type"), summarize, Time = mean(R), InterConfi = sd(R)/sqrt(length(R)))
Lois de Erlang
df <- creatFinalDataFrame(0.05, 1000, "rlang")
dfRlang <- ddply(df, c("Lambda", "Type"), summarize, Time = mean(R), InterConfi = sd(R)/sqrt(length(R)))
Lois Déterministe
df <- creatFinalDataFrame(0.05, 1000, "rdeter")
dfRDeter <- ddply(df, c("Lambda", "Type"), summarize, Time = mean(R), InterConfi = sd(R)/sqrt(length(R)))
Affichage des courbes
dfFinal <- rbind(dexp, dfunif, dfRlang, dfRDeter)
ggplot(dfFinal, aes(x = Lambda, y = Time, ymin = Time - InterConfi, ymax = Time +
InterConfi, color = Type)) + geom_pointrange()
Il faudrait faire varier le nombre de tour de boucle en fonction de lambda car au début la variabilité est très faible ce qui demande beaucoup moins de valeur nécessairement.
On ne peut cependant pas le faire car pour calculer l'intervalle de confiance ça suppose que les valeurs sont indépendantes l'une de l'autre et ce n'est possible que s'il y a un reset assez fréquent. Donc quand le système est saturé le reset n'est pas fait très souvent. Donc les temps de traitement dépendent fortement des temps de traitement des tâches précédentes.
Concernant les courbes, on remarque que globalement il n'y en a pas vraiment qui se démarque des autres. Mise à part la courbe correspondant à la loi uniforme, les autres ont les mêmes allures.
La loi uniforme présente une courbe assez “plate”. C'est à dire que les variations sont faibles. Cela signifie que le système est stable quelques soient le nombre de requête à traiter.
A contrario avec les autres courbes où l'ont remarque que lorsqu'il y a beaucoup de requête à traiter, le temps d'attente augmente significativement.