Code du simulateur.

propre = function(N = 10, lambda = .2, mu = 'uni', policy = 'fifo'){
  if(policy != 'fifo' && policy != 'lifo_restart' && policy != 'srpt')
    print('Politique inconnue, fifo appliquée\nPolitiques disponibles : fifo ; lifo_restart ; srpt')
  if(mu != 'uni' && mu != 'exp' && mu != 'gamma' && mu != '1')
    print('Loi de service inconnue, 1 appliquée\nLois diponibles : uni ; exp ; gamma ; 1')
  
  # arrivees des taches
  Arrival = cumsum(rexp(n=N, rate = lambda));
  
  # temps de service/tache
  if(mu == 'exp'){
    Service = rexp(N,rate = 1);
  } else if(mu == 'gamma'){
    Service = rgamma(N, shape = .1, rate = .1);
  } else if(mu == 'uni'){
    Service = runif(N, min = 0.5, max = 1.5);
  } else{
    Service = rep(N, x=1);
  }
  
  # temps restant/tache
  Remaining = rep(N, x=NA);
  
  # completion des taches
  Completion = rep(N, x=NA);
  
  # temps actuel
  t = 0;
  
  # tache en cours de traitement
  CurrentTask = NA;
  
  # arrivee de la prochaine tache
  NextArrival = 1;

  while (TRUE) {
      dtA = NA; # temps avant arrivee
      dtC = NA; # temps avant completion
      if(length(Arrival[Arrival>t])>0) {
          dtA = head(Arrival[Arrival>t],n=1)-t  # temps jusqu'à la prochaine arrivée
      }
      if(!is.na(CurrentTask)) {
          dtC = Remaining[CurrentTask]; # temps jusqu'à la prochaine terminaison
      }
      if(is.na(dtA) & is.na(dtC)) {
          break;
      } 
      dt = min(dtA,dtC,na.rm=T) # temps avant prochain evenement
  
      # Mettre à jour comme il faut:
      #   la date
      t = t + dt;
      
      #   les arrivées
      if((NextArrival <= N) & (Arrival[NextArrival] <= t)) { 
          Remaining[NextArrival] = Service[NextArrival];
          NextArrival = NextArrival + 1;
      }
      
      #   le remaining 
      if(!is.na(CurrentTask)) {
          Remaining[CurrentTask] = Remaining[CurrentTask] - dt ;
          if(Remaining[CurrentTask] <= 0) {
              Completion[CurrentTask] = t;
              Remaining[CurrentTask] = NA;
          }
          CurrentTask = NA;
      }
      
      # et currentTask (selon la politique d'ordonnancement)
      if(policy == 'srpt'){
        WaitingList=(1:N)[!is.na(Remaining)];
        if(length(WaitingList)>0) {
            CurrentTask = which(Remaining==min(Remaining, na.rm=TRUE))[1];
        }
      } else if(policy == 'lifo_restart'){
        WaitingList=(1:N)[!is.na(Remaining)];
        if(length(WaitingList)>0) {
            CurrentTask = tail(WaitingList,n=1);
            if(mu == 'exp'){
              Remaining[CurrentTask] = rexp(1,rate = 1);
            } else if(mu == 'gamma'){
              Remaining[CurrentTask] = rgamma(1, shape = .1, rate = .1);
            } else if(mu == 'uni'){
              Remaining[CurrentTask] = runif(1, min = 0.5, max = 1.5);
            } else{
              Remaining[CurrentTask] = 1;
            }
        }
      } else{
        WaitingList=(1:N)[!is.na(Remaining)];
        if(length(WaitingList)>0) {
            CurrentTask = head(WaitingList,n=1);
        }
      }
  }
  
  return(data.frame(lambda=lambda, mu=1, Idx=1:N, Completion=Completion, Arrival=Arrival, Service=Service, ModeSched=policy, ModeArri=mu))
}
library(dplyr);
## 
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
## 
##     filter, lag
## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union
library(ggplot2);

lambda = seq(from=0.05, to=.9, by=.1)

unififo = data.frame()
for(i in lambda){
  unififo = rbind(unififo,propre(N=1000, mu='uni', lambda=i, policy='fifo'))
}

expfifo = data.frame()
for(i in lambda){
  expfifo = rbind(expfifo,propre(N=1000, mu='exp', lambda=i, policy='fifo'))
}

gammafifo = data.frame()
for(i in lambda){
  gammafifo = rbind(gammafifo,propre(N=1000, mu='gamma', lambda=i, policy='fifo'))
}

unilifo = data.frame()
for(i in lambda){
  unilifo = rbind(unilifo,propre(N=1000, mu='uni', lambda=i, policy='lifo_restart'))
}

explifo = data.frame()
for(i in lambda){
  explifo = rbind(explifo,propre(N=1000, mu='exp', lambda=i, policy='lifo_restart'))
}

gammalifo = data.frame()
for(i in lambda){
  gammalifo = rbind(gammalifo,propre(N=1000, mu='gamma', lambda=i, policy='lifo_restart'))
}

unisrpt = data.frame()
for(i in lambda){
  unisrpt = rbind(unisrpt,propre(N=1000, mu='uni', lambda=i, policy='srpt'))
}

expsrpt = data.frame()
for(i in lambda){
  expsrpt = rbind(expsrpt,propre(N=1000, mu='exp', lambda=i, policy='srpt'))
}

gammasrpt = data.frame()
for(i in lambda){
  gammasrpt = rbind(gammasrpt,propre(N=1000, mu='1', lambda=i, policy='srpt'))
}
a=unififo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
A = data.frame(lambda=lambda, politique = 'fifo', loi = 'uni', Mean = c(a['resp_mean']))
b=expfifo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
B = data.frame(lambda=lambda, politique = 'fifo', loi = 'exp', Mean = b['resp_mean'])
c=gammafifo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
C = data.frame(lambda=lambda, politique = 'fifo', loi = 'gamma', Mean = c['resp_mean'])
d=unilifo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
D = data.frame(lambda=lambda, politique = 'lifo_restart', loi = 'uni', Mean = d['resp_mean'])
e=explifo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
E = data.frame(lambda=lambda, politique = 'lifo_restart', loi = 'exp', Mean = e['resp_mean'])
f=gammalifo %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
FF = data.frame(lambda=lambda, politique = 'lifo_restart', loi = 'gamma', Mean = f['resp_mean'])
g=unisrpt %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
G = data.frame(lambda=lambda, politique = 'srpt', loi = 'uni', Mean = g['resp_mean'])
h=expsrpt %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
H = data.frame(lambda=lambda, politique = 'srpt', loi = 'exp', Mean = h['resp_mean'])
i=gammasrpt %>% group_by(lambda) %>% summarise(resp_mean = mean(Completion-Arrival))
I = data.frame(lambda=lambda, politique = 'srpt', loi = 'gamma', Mean = i['resp_mean'])
 
J=data.frame(
  lambda=c(A$lambda, B$lambda, C$lambda, D$lambda, E$lambda, FF$lambda, G$lambda, H$lambda, I$lambda),
  loi=c(as.vector(A$loi), as.vector(B$loi), as.vector(C$loi), as.vector(D$loi), as.vector(E$loi), as.vector(FF$loi), as.vector(G$loi), as.vector(H$loi), as.vector(I$loi)),
  mean = c(A$resp_mean, B$resp_mean, C$resp_mean, D$resp_mean, E$resp_mean, FF$resp_mean, G$resp_mean, H$resp_mean, I$resp_mean),
  politique=c(as.vector(A$politique), as.vector(B$politique), as.vector(C$politique), as.vector(D$politique), as.vector(E$politique), as.vector(FF$politique), as.vector(G$politique), as.vector(H$politique), as.vector(I$politique)))

On constate que lorsque le taux d’arrivées augmente, le temps d’attente moyen n’est pas régi uniquement par la loi de temps de service ni par la politique de traitement des tâches, car par exemple la politique LIFO-restart est très efficace pour réagir face à une loi gamma, mais devient inutilisable pour une loi uniforme. En revanche, la politique FIFO est plus efficace face à une loi uniforme que face à une loi gamma. Enfin, la politique SRPT semble tout de même très efficace face à chaque loi de temps de service.

ggplot(J, aes(x=lambda, y=mean, group=loi)) + geom_line(aes(colour=loi)) + facet_wrap(~politique) + ggtitle("lambda en en fontion du temps de réponse\nFacet sur les politiques, une couleur par loi") + ylab("Temps de réponse moyen")

ggplot(J, aes(x=lambda, y=mean, group=politique)) + geom_line(aes(colour=politique)) + facet_wrap(~loi) + ggtitle("lambda en fonction du temps de réponse\nFacet sur les lois, une couleur par politique") + ylab("Temps de réponse moyen")

Sur les graph ci-dessus, il est compliqué d’analyser les intervalles de confiance. Voici donc un graph avec une seule coubre qui represente le comportement du serveur dans le cas d’une politique FIFO et d’une loi uniforme, avec les intervalles de confiance à 95% de confidence.

Etude avec mu = 1 pour les intervalles de confiance (politique FIFO) :

lambda = seq(from=0.05, to=.9, by=.1)

unififo = data.frame()
for(i in lambda){
  unififo = rbind(unififo,propre(N=5000, mu='1', lambda=i, policy='fifo'))
}

library(dplyr);
library(ggplot2);

unififo %>% group_by(lambda) %>% summarise(confiance = t.test(Completion-Arrival)$conf.int[2] - mean(Completion-Arrival), resp_mean = mean(Completion-Arrival)) %>%
ggplot(aes(x=lambda, y=resp_mean))+geom_line()+geom_errorbar(aes(ymin=resp_mean-confiance, ymax=resp_mean+confiance),width=.05, position=position_dodge(0.05))