L’objectif est d’analyser l’importance de la distribution du temps de service sur le temps de réponse dans une file d’attente M/GI/1 avec un ordonnancement LIFO. Le processus d’arrivée est un processus de Poisson de taux (débit), les clients ont un temps de service de moyenne 1 pris comme unité de temps de référence.

Simulation de la file LIFO

Tout d’abord le code d’une file LIFO, ce code nous a été donné par Monsieur Arnaud Legrand. plutot que de retourner t1-t2, comme le code est à l’origine, nous avons choisi de stocker dans une data frame le résultat, afin de récupérer à la fois t2-t1, lambda, la loi utilisé.

set.seed(10)
library(plyr)
## Warning: package 'plyr' was built under R version 3.1.2
library(ggplot2)
## Warning: package 'ggplot2' was built under R version 3.1.2
Service <- function(n=1,typeservice,x,y) {
# genere un temps de service
  switch(typeservice,
         det = rep(1,n),
         uni = runif(n,x,y),
         gamma = rgamma(n,shape=x,scale=y),
         exp = rexp(n,x)
         )
}

FileLIFO <- function(n,lambda,typeservice,x,y,policy) {
    # simulates a M/GI/1 LIFO queue with different preemption policy
    # parameters:
    #    n :  total number of jobs
    #    lambda : arrival rate
    #    typeservice : service law (det uni gamma exp)
    #    x ,y : parameters of the service law
    #    policy: npmtn, pmtn, pmtn_restart, pmtn_reset
    # return value:
    #    vector with response time of each task assuming the queue is initially empty
    
    A <- rexp(n,lambda)         # inter arrival
    t1 <- cumsum(A)             # arrival dates
    t2 <- rep(NA,n)             # completion dates
    S <- Service(n,typeservice,x,y) # initial service times
    
    #### Variables that define the state of the queue
    t = 0               # current time
    remaining = rep(NA,n)  # how much work remains to do for each task
    running = NA        # index of the currently running task
    waiting = c()       # stack with tasks which have arrived and have not been completed yet
    next_arrival = 1    # index of the next task to arrive
    
    #### A few useful local functions 
    run_task = function() { # runs the last task of the waiting list
      if(length(waiting)>0) {
        running <<- waiting[length(waiting)]
        remaining[running] <<- switch(policy,
                                      npmtn = S[running],
                                      pmtn = min(S[running],remaining[running],na.rm=T),
                                      pmtn_restart = S[running],
                                      pmtn_reset = Service(1,typeservice,x,y)
                                      )
        waiting <<- waiting[-length(waiting)]
      }
    }

    push_task = function() { # insert the next_arrival-th task to the waiting list
                             # and run it if there is preemption
      if(policy != "npmtn") {
        if(!is.na(running)) {waiting <<- c(waiting,running)}
        running <<- NA
      }
      waiting <<- c(waiting,next_arrival)
      next_arrival <<- next_arrival+1 
      if(is.na(running)) { run_task() }
    }

    #### Main simulation loop
    while(TRUE) { 
      # Look for next event
      dt = NA
      if(next_arrival <=n) { dt = min(dt,(t1[next_arrival]-t), na.rm=T) }
      if(!is.na(running))  { dt = min(dt,remaining[running], na.rm=T)   }
      if(is.na(dt)) { break }
      
      # Update state
      t=t+dt
      if(!is.na(running)) {
        remaining[running] = remaining[running] - dt
        if(remaining[running]<=0) {
          t2[running] = t
          running = NA
          run_task()
        }
      }
      if((next_arrival<=n) & (t==t1[next_arrival])) {
        push_task()
      }
    }
    #n
     df <- data.frame(N=n,TEMPS = (t2 - t1), LAMBDA = lambda, LOI = typeservice, POLICY = policy, LABEL = as.factor(paste(typeservice, "(", x, ",", y, ")", sep = "")))
   return (df)
   
    
}    

Question 1. Nature des lois de service :

· Illustrer les différences de natures entre les différentes lois de temps de service.

Pour cela nous allons apporter quelques modification à la fonction Service c’est pour cela que nous l’avons renommé. On y ajoutera une dataframe avec les données utiles pour répondre à la question.

ServiceTest <- function(n,typeservice,x,y) {
# genere un temps de service
  switch(typeservice,
         det = {df <- data.frame(N=n,TYPE = typeservice, X=x, Y=y, REP=rep(1,n),id=c(1:n))},
         uni = {df <- data.frame(N=n,TYPE = typeservice, X=x, Y=y, REP=runif(n,x,y),id=c(1:n))},
         gamma = {df <- data.frame(N=n,TYPE = typeservice, X=x, Y=y, REP=rgamma(n,shape=x,scale=y),id=c(1:n))},
         exp = {df <- data.frame(N=n,TYPE = typeservice, X=x, Y=y, REP=rexp(n,x), id=c(1:n))}
         )
   return (df)
}
lambda_values = c("det","uni","gamma","exp")
res=data.frame()
i<-1

res <- rbind(res,ServiceTest(100,"det",0,0)) # initial service times
res <-rbind(res,ServiceTest(100,"uni",0,2)) # initial service times
res <-rbind(res,ServiceTest(100,"gamma",.2,5)) # initial service times
res <-rbind(res,ServiceTest(100,"exp",1,0)) # initial service times

res2 <- ddply(res, c("TYPE", "REP"),summarize, type=TYPE,rep=REP, n=N, id=id)

ggplot(res2, aes(x = factor(id), y=rep,color =TYPE)) +
  geom_bar(data=res2,stat="identity", position="identity") +geom_point() +  geom_line() + xlab("n ID") + ylab("Temps de Service") 
## geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?

plot of chunk unnamed-chunk-3 Bon, ce n’est pas trop lisible mais ca permet de donner une vue générale, en effet nous voyon notamment que la loie gamma n’est pas vraiment régulière il y a de fort changement elle fourni des temps avoisinant 0 et jusqu’a 6. On voit aussi que la loi deterministe fourni un temps de service constant de 1 ici. Au niveau de la loi exponentielle elle est similaire à la loi gamma mais avec en ecart type moins important. De meme pour la loi uniforme.

Regardons de plus pres chaque loi

LOI DETERMINISTE :

res<-data.frame()
res <- rbind(res,ServiceTest(100,"det",0,0)) # initial service times
res2 <- ddply(res, c("TYPE", "REP"),summarize, type=TYPE,rep=REP, n=N, id=id)
ggplot(res2, aes(x = factor(id), y=rep,color =TYPE)) +
  geom_bar(data=res2,stat="identity", position="identity") +geom_point() +  geom_line() + xlab("n ID") + ylab("Temps de Service") 
## geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?

plot of chunk unnamed-chunk-4

mean(res2$rep)
## [1] 1

On peut voir que pour chaque valeur nous avons un temps de service de 1. Comme nous l’avions dit précedemment. Le temps de service est bien de 1.

LOI UNIFORME :

res<-data.frame()
res <-rbind(res,ServiceTest(100,"uni",0,2)) # initial service times
res2 <- ddply(res, c("TYPE", "REP"),summarize, type=TYPE,rep=REP, n=N, id=id)
ggplot(res2, aes(x = factor(id), y=rep,color =TYPE)) +
  geom_bar(data=res2,stat="identity", position="identity") +geom_point() +  geom_line() + xlab("n ID") + ylab("Temps de Service")
## geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?

plot of chunk unnamed-chunk-5

mean(res2$rep)
## [1] 1.071

Nous pouvons voir des temps de service inconstant puisque les valeurs vont d’environ 0 jusqu’a 2. Cependant le temps moyen de service avoisine 1. Ce qui est normal puisque nous choisissons une valeur entre 0 et 2, la moyenne est de 1, nos résultats sont cohérents?

LOI GAMMA :

res<-data.frame()
res <-rbind(res,ServiceTest(100,"gamma",.2,5)) # initial service times
res2 <- ddply(res, c("TYPE", "REP"),summarize, type=TYPE,rep=REP, n=N, id=id)
ggplot(res2, aes(x = factor(id), y=rep,color =TYPE)) +
geom_bar(data=res2,stat="identity", position="identity") +geom_point() +  geom_line() + xlab("n ID") + ylab("Temps de Service") 
## geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?

plot of chunk unnamed-chunk-6

mean(res2$rep)
## [1] 1.167

Pffiou, plus on avance plus les variations du temps de service sont importantes. Ici nous avons pour valeur max quasiment 15, mais lorsque nous regardons la moyenne elle est aussi proche de 1.

LOI EXPONENTIELLE :

res<-data.frame()
res <-rbind(res,ServiceTest(100,"exp",1,0)) # initial service times
res2 <- ddply(res, c("TYPE", "REP"),summarize, type=TYPE,rep=REP, n=N, id=id)
ggplot(res2, aes(x = factor(id), y=rep,color =TYPE)) +
geom_bar(data=res2,stat="identity", position="identity") +geom_point() +  geom_line() + xlab("n ID") + ylab("Temps de Service") 
## geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?

plot of chunk unnamed-chunk-7

mean(res2$rep)
## [1] 1.149

Encore des variations mais moins important que pour la loi précédement. Puisqu’elles se désinent entre quasiment 0 et plus de 4. Du coté de la valeur moyenne elle est aussi d’environ 1.

Pour conclure, on peut voir que ces lois offres différents temps de service. La loi deterministe est constante. Les autres varient avce plus ou moins d’amplitude mais au finalement elle on toute une moyenne de 1, nous allons voir dans la suite. Quelles sont les effets de chacune de ces loi sur le temps de service moyen.

Question 2. Étude détaillée de la file M/M/1 − LIFO :

· Étudier la distribution stationnaire du temps de réponse pour différents débit d’arrivées (par exemple λ = 0.2,0.4,0.6,0.8) pour la file M/M/1−LIFO (i.e., avec un temps de service et d’interarrivée exponentiel) pour chacun des modes de gestion. Vous représenterez sur un même graphique votre estimation des temps moyens de service en fonction du débit d’arrivée avec une couleur différente pour chacun des modes de gestion. Vous étudierez la stabilité du système, ses performances, les similarités et/ou les différences de comportement observés

#Création de la dataframe pour les résultats des appels de la fonction FileLIFO.
resulat <- data.frame()

#Création d'un vecteur contenant chaque valeur de lambda à tester.
lambda_values = c(.2,.4,.6,.8)
i<-1
# Loi exponentielle, mode non préemptif.
while (i<=4) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="npmtn"))
    i<-i+1
}
# Loi exponentielle, mode préemptif.
i<-1
while (i<=4) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn"))
    i<-i+1
}
# Loi exponentielle, mode préemptif restart.
i<-1
while (i<=4) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn_restart"))
    i<-i+1
}
# Loi exponentielle mode préemptif reset
i<-1
while (i<=4) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn_reset"))
    i<-i+1
}
# calcul final
resulat2 <- ddply(resulat, c("LAMBDA", "POLICY"), summarize, TempsMoyen = mean(TEMPS), 
    vari = var(TEMPS), ecart = 2*sd(TEMPS)/sqrt(length(TEMPS)))

# Tracer des différents type de services, avec une loi exponentielle, avec nos intervales de confiances.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =POLICY)) + geom_point() +  geom_line()+geom_errorbar() + geom_vline(xintercept = 1) + xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Type de Temps de Service", colour = " Type de Temps de Service")

plot of chunk unnamed-chunk-8

Nous avons commencé par choisir une valeur de n grande afin de limiter l’intervalle de confiance. On peut voir sur le graphique ci-dessus que les types de service Sans péemption, Avec Préemption (normal) et Avec préemption reset evolution plutot régulièrement. Cependant, nous pouvons voir une augmentation absolument extra ordinaire de la courbe bleu, représentant le type préemption avec restart. Cette aumgentation avoisine l’exponentielle.

Bon regardons quand meme de plus pret l’evoluation des 3 courbes, un peu plus de précisions ne ferai pas de mal…

Pour cela nous rajoutons un y limite entre 0 et 6.2 nous permettant un zoom sur les 3 courbes.

# Tracer des courbes avec une limitation sur les ordonnées à 0, 6.2.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =POLICY)) + geom_point() + geom_errorbar() + geom_vline(xintercept = 1)+ geom_line() + xlab("Lambda") + ylab("Temps de service moyen ") + ylim(0,6.2)+ labs(name = "Type de Temps de Service", colour = " Type de Temps de Service")
## Warning: Removed 2 rows containing missing values (geom_point).
## Warning: Removed 2 rows containing missing values (geom_path).

plot of chunk unnamed-chunk-9

En effet nous pouvons voir des courbes qui évoluent régulièrement (elles suivent plus ou moins une droite) avec en plus des intervales de confiances résonables. En faite, lorsque nous regardons bien la courbe orange, donc celle sans préemption semble la plus efficace car elle fourni pour chaque valeur choisi un temps minimal.

Question 3. Étude de la file M/GI/1 − LIFO

Tracer le temps moyen de réponse en fonction de λ pour les différentes lois proposées et les différents modes de gestion ci-dessus. Vous choisirez 2 valeurs pour la famille des lois Gamma. Vous étudierez la stabilité du système, ses performances, les similarités et/ou les différences de comportement observés…

Dans cette dernière question nous allons maintenant étudier le comportement du temps moyen en fonction de λ pour chaque de chaque mode avec pour chaque mode l’ensemble des lois. Commencons par le mode NON-PREEMPTIF

#Création de la dataframe pour les résultats des appels de la fonction FileLIFO.
resulat <- data.frame()
lg<-9
#Création d'un vecteur contenant chaque valeur de lambda à tester.
lambda_values = c(.1,.2,.3,.4,.5,.6,.7,.8,.9)
i<-1
# Loi det, mode non préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"det",0,0, policy="npmtn"))
    i<-i+1
}
i<-1
# Loi uniforme, mode non préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"uni",0,2, policy="npmtn"))
    i<-i+1
}
i<-1
# Loi gamma, mode non préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",4,.25, policy="npmtn"))
    i<-i+1
}
i<-1
# Loi gamma, mode non préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",.2,5, policy="npmtn"))
    i<-i+1
}
i<-1
# Loi exponentielle, mode non préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="npmtn"))
    i<-i+1
}

# calcul final
resulat2 <- ddply(resulat, c("LAMBDA", "LABEL"), summarize, TempsMoyen = mean(TEMPS), 
    vari = var(TEMPS), ecart = 2*sd(TEMPS)/sqrt(length(TEMPS)))

# Tracer du type de services NPMTN, pour chaque loi, avec nos intervales de confiances.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =LABEL)) + geom_point() +  geom_line()+geom_errorbar() +geom_vline(xintercept = 1)+ xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Loi", colour = "Loi")

plot of chunk unnamed-chunk-10

Déja nous pourvons observer que pour la loi Gamma de paramètre .2, 5, il y a vraiment une explosion du temps moyen directement dès le début de lambda. On peut ajouter à cela que la lois déterministe à celle qui à le temps de réponse qui augmente le moins rapidement. Entre ces deux extrement nous avons la loi exponentielle, l’autre lois gamma et la lois uniforme dont ces deux dernière pourraient presque se superposer. Au niveau des intervalles de confiances, il semble satisfaisant avec un n à 50 000.

D’après Wikipédia, cela est tout à fait normal puisque la variation du temps de servicce joue enormément sur le temps moyen de réponse.

Continuons avec le mode PRÉEMTIF REPRISE. Biensur nous garderons les memes valeurs que précedemment.

#Création de la dataframe pour les résultats des appels de la fonction FileLIFO.
resulat <- data.frame()
lg<-9
#Création d'un vecteur contenant chaque valeur de lambda à tester.
lambda_values = c(.1,.2,.3,.4,.5,.6,.7,.8,.9)
i<-1
# Loi det, mode préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"det",0,0, policy="pmtn"))
    i<-i+1
}
i<-1
# Loi uniforme, mode préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"uni",0,2, policy="pmtn"))
    i<-i+1
}
i<-1
# Loi gamma, mode préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",4,.25, policy="pmtn"))
    i<-i+1
}
i<-1
# Loi gamma, mode préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",.2,5, policy="pmtn"))
    i<-i+1
}
i<-1
# Loi exponentielle, mode préemptif.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn"))
    i<-i+1
}

# calcul final
resulat2 <- ddply(resulat, c("LAMBDA", "LABEL"), summarize, TempsMoyen = mean(TEMPS), 
    vari = var(TEMPS), ecart = 2*sd(TEMPS)/sqrt(length(TEMPS)))

# # Tracer du type de services PMTN, pour chaque loi, avec nos intervales de confiances.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =LABEL)) + geom_point() +  geom_line()+geom_errorbar() +geom_vline(xintercept = 1)+ xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Loi", colour = "Loi")

plot of chunk unnamed-chunk-11

Nous pouvons observer que les évolutions se font de la meme facon, en effet ici nous n’avons pas de forte explosion, ni de courbes très lente, comme précédemment. Ici tout le monde va à la meme vitesse. Au niveau du temps moyen de réponse pour comparer avec celui du mode sans préemption nous somme un peu au dessous car nous ne montons pas au dessus de 10 ici.

Passons avec le mode PRÉEMTIF RESTART. Biensur nous garderons les memes valeurs que précedemment.

#Création de la dataframe pour les résultats des appels de la fonction FileLIFO.
resulat <- data.frame()
lg<-9
#Création d'un vecteur contenant chaque valeur de lambda à tester.
lambda_values = c(.1,.2,.3,.4,.5,.6,.7,.8,.9)
i<-1
# Loi det, mode préemptif avec restart.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"det",0,0, policy="pmtn_restart"))
    i<-i+1
}
i<-1
# Loi uniforme, mode préemptif avec restart.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"uni",0,2, policy="pmtn_restart"))
    i<-i+1
}
i<-1
# Loi gamma, mode préemptif avec restart.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",4,.25, policy="pmtn_restart"))
    i<-i+1
}
i<-1
# Loi gamma, mode préemptif avec restart.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",.2,5, policy="pmtn_restart"))
    i<-i+1
}
i<-1
# Loi exponentielle, mode préemptif avec restart.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn_restart"))
    i<-i+1
}

resulat2 <- ddply(resulat, c("LAMBDA", "LABEL"), summarize, TempsMoyen = mean(TEMPS), 
    vari = var(TEMPS), ecart = 2*sd(TEMPS)/sqrt(length(TEMPS)))

# Tracer du type de services pmtn_restart, pour chaque loi, avec nos intervales de confiances.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =LABEL)) + geom_point() +  geom_line()+geom_errorbar() +geom_vline(xintercept = 1)+ xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Loi", colour = "Loi")

plot of chunk unnamed-chunk-12

Waouh… Impressionant ! Le temps de réponse moyen explose totalement pour l’ensemble des lois. Ici on bat tous les record.

La lois déterministe met par contre plus de temps que les autres lois pour exploser, contrairement à la lois gamma(4,.25) qui elle n’attendra pas pour augmenter aumgenter en flèche directement mais finira par évolution plus lentement après lambda=0,5.

Enfin si vous souhaitez faire crasher votre réseaux, n’hésitez pas, ce mode est fait pour vous…

Ca y est la dernière avec le mode PRÉEMTIF RESET. Biensur nous garderons les memes valeurs que précedemment.

#Création de la dataframe pour les résultats des appels de la fonction FileLIFO.
resulat <- data.frame()
lg<-9
#Création d'un vecteur contenant chaque valeur de lambda à tester.
lambda_values = c(.1,.2,.3,.4,.5,.6,.7,.8,.9)
i<-1
# Loi det, mode préemptif avec reset.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"det",0,0, policy="pmtn_reset"))
    i<-i+1
}
i<-1
# Loi uniforme, mode préemptif avec reset.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"uni",0,2, policy="pmtn_reset"))
    i<-i+1
}
i<-1
# Loi gamma, mode mode préemptif avec reset.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",4,.25, policy="pmtn_reset"))
    i<-i+1
}
i<-1
# Loi gamma,  mode préemptif avec reset.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"gamma",.2,5, policy="pmtn_reset"))
    i<-i+1
}
i<-1
# Loi exponentielle, mode préemptif avec reset.
while (i<=lg) {
    resulat <- rbind(resulat, FileLIFO(n=50000, lambda_values[i],"exp",1,0, policy="pmtn_reset"))
    i<-i+1
}

# calcul final
resulat2 <- ddply(resulat, c("LAMBDA", "LABEL"), summarize, TempsMoyen = mean(TEMPS), 
    vari = var(TEMPS), ecart = 2*sd(TEMPS)/sqrt(length(TEMPS)))

# Tracer du type de services pmtn_reset, pour chaque loi, avec nos intervales de confiances.
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =LABEL)) + geom_point() +  geom_line()+geom_errorbar() +geom_vline(xintercept = 1)+ xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Loi", colour = "Loi")

plot of chunk unnamed-chunk-13

Nous pouvons voir des courbes qui mettent du temps a exploser, les 3 lois, déterministe, gamma 4 et uniforme, vont exploser pour un lambda de .6. Cependant au dessus le system explose pour ces 3 lois.avec un temps moyen déplorable….

D’après wikipédia, dans ce cas plus la variance du temps de réponse est grande plus les courbes évoluent lentement.

Nous allons limité la fenetre afin de mieux voir l’évolution des courbes exposentielle et gamma .2

# Tracer du type de services pmtn_restart, pour chaque loi, avec nos intervales de confiances. limité y [0;25]
ggplot(resulat2, aes(x = LAMBDA, y = TempsMoyen, ymin = TempsMoyen - ecart, ymax = TempsMoyen + ecart, color =LABEL)) + geom_point() +  ylim(0,25)+geom_line()+geom_errorbar() +geom_vline(xintercept = 1)+ xlab("Lambda") + ylab("Temps de service moyen ") + labs(name = "Loi", colour = "Loi")
## Warning: Removed 7 rows containing missing values (geom_point).
## Warning: Removed 7 rows containing missing values (geom_path).

plot of chunk unnamed-chunk-14

On peut donc maintenant voir que la courbe de gamme propose un temps moyen, absolument extraordinaire!!!(ca n’aumgente jamais) Cependant la lois expo elle va augmenter régulièrement mais garde un temps moyen très correct.