Appliquez les lois opérationnelles

Pendant deux minutes du pic d’ouverture, l’équipe de la billetterie a relevé quelques compteurs : combien de temps le disque de la base de données a été occupé, combien d’accès il a servis, combien de commandes ont été validées. Rien de plus. Peut-on en déduire le temps que chaque commande passe sur le disque, ou le nombre de commandes en cours à chaque instant ?

Oui, et sans aucune hypothèse de probabilité ! Les lois opérationnelles sont des identités, vraies sur n’importe quelle période d’observation. Ce sont les outils les plus simples et les plus utiles de tout le cours.

Le modèle : des ressources que les requêtes visitent

On voit le système comme un ensemble de $K$ ressources (processeur, disques, réseau), que chaque requête visite une ou plusieurs fois avant de repartir. Pour la billetterie, une commande passe par le serveur web frontal, puis alterne entre le processeur du serveur d’application et le disque de la base de données.

Ce que l’on observe

Sur une période d’observation de durée $T$, on relève pour chaque ressource $i$ :

• $B_i$ : le temps occupé (busy time) de la ressource ;
• $A_i$ : le nombre d’arrivées (demandes de service) ;
• $C_i$ : le nombre de terminaisons (services achevés).

Pour le système entier, on note $A_0$ le nombre de requêtes entrées et $C_0$ le nombre de requêtes terminées. Ce sont des compteurs très faciles à obtenir : les outils système comme iostat ou vmstat les fournissent directement.

Ce que l’on en déduit

À partir de ces compteurs, on définit les variables dérivées :

Variable	Formule	Signification
Temps de service	$S_i = B_i / C_i$	durée moyenne d’un passage sur la ressource $i$
Utilisation	$U_i = B_i / T$	fraction du temps où $i$ est occupée
Débit de la ressource	$X_i = C_i / T$	passages terminés par seconde sur $i$
Taux d’arrivée	$\lambda_i = A_i / T$	demandes arrivant par seconde sur $i$
Débit du système	$X_0 = C_0 / T$	requêtes terminées par seconde
Nombre de visites	$V_i = C_i / C_0$	nombre moyen de passages sur $i$ par requête
Demande de service	$D_i = V_i S_i$	temps total de service reçu sur $i$ par requête

La dernière ligne est la plus importante du cours. La demande de service $D_i$ est le temps qu’une requête passe réellement à se faire servir par la ressource $i$, toutes visites confondues, sans compter l’attente.

Attention

Ne confondez pas $S_i$ et $D_i$. Le temps de service $S_i$ est mesuré par visite ; la demande $D_i$ est mesurée par requête. Si une commande lit quatre fois le disque pendant 15 ms à chaque fois, $S_{\text{disque}} = 15$ ms mais $D_{\text{disque}} = 60$ ms.

Les trois premières lois : utilisation, flux forcé, demande de service

On suppose l’équilibre des flux (job flow balance) : sur la période, il entre autant de requêtes qu’il en sort ($A_i = C_i$ et $A_0 = C_0$). C’est raisonnable dès que la période est longue devant le temps de réponse.

Loi d’utilisation. En écrivant $U_i = B_i/T = (C_i/T)(B_i/C_i)$, on obtient :

$$U_i = X_i \, S_i = \lambda_i \, S_i$$

L’utilisation d’une ressource est son débit multiplié par son temps de service. La deuxième égalité vient de l’équilibre des flux ($X_i = \lambda_i$).

Loi du flux forcé (forced flow law). Chaque requête du système provoque en moyenne $V_i$ passages sur $i$, donc :

$$X_i = V_i \, X_0$$

Le débit de chaque ressource est « forcé » par le débit du système. C’est ce qui permet de passer d’une ressource au système entier.

Loi de la demande de service. En combinant les deux précédentes :

$$D_i = V_i \, S_i = \frac{U_i}{X_0}$$

C’est une formule précieuse en pratique : vous n’avez même pas besoin de compter les visites. L’utilisation de la ressource et le débit du système suffisent pour connaître la demande de service.

Exemple

Voici les compteurs relevés pendant $T = 120$ s au pic d’ouverture :

• disque de la base de données : occupé $B = 72$ s, $C = 4\,800$ accès ;
• processeur du serveur d’application : occupé $B = 36$ s, $C = 6\,000$ passages ;
• système : $C_0 = 1\,200$ commandes terminées.

Pour le disque : $U = 72/120 = 0{,}6$ ; $X = 4\,800/120 = 40$ accès/s ; $S = 72/4\,800 = 15$ ms. Pour le système : $X_0 = 1\,200/120 = 10$ commandes/s. Chaque commande visite donc le disque $V = 4\,800/1\,200 = 4$ fois, et sa demande de service vaut $D = 4 \times 15 = 60$ ms. On vérifie avec la loi de la demande de service : $U/X_0 = 0{,}6/10 = 0{,}06$ s.

Pour le processeur : $U = 0{,}3$, $V = 5$, $S = 6$ ms et $D = 0{,}3/10 = 30$ ms.

La loi de Little

C’est la plus célèbre des lois de performance. Elle relie le nombre moyen de requêtes présentes dans un système $N$, son débit $X$ et le temps de réponse moyen $R$ :

$$N = X \, R$$

• $N$ est le nombre moyen de requêtes présentes (en attente ou en service) ;
• $X$ est le débit (requêtes terminées par seconde) ;
• $R$ est le temps moyen qu’une requête passe dans le système.

L’intuition est simple : si 10 commandes entrent chaque seconde et que chacune reste 0,2 s, alors à tout instant il y a en moyenne $10 \times 0{,}2 = 2$ commandes en cours de traitement. Pensez à une file devant une boulangerie : si 2 clients arrivent par minute et que chacun reste 5 minutes, il y a en moyenne 10 clients dans la boutique.

L'aire entre arrivées et départs est à la fois la somme des temps de séjour (16 s) et l'intégrale du nombre de requêtes présentes : diviser par T donne N = 1,6, diviser par C donne R = 1,6 s, d'où N = X R.

La force de cette loi, c’est qu’elle s’applique à n’importe quel sous-système dont on sait délimiter les entrées et les sorties : une file d’attente seule, un disque (file comprise), le serveur entier, ou même un système avec ses utilisateurs.

À retenir

Loi de Little : $N = X R$. Connaissant deux des trois grandeurs, on déduit la troisième. Elle vaut pour une ressource, une file, un serveur ou un système entier, sans hypothèse sur les lois d’arrivée ou de service.

En entretien

« La loi de Little dit que le nombre moyen de requêtes en cours est égal au débit multiplié par la latence moyenne. Une API qui sert 200 requêtes par seconde avec 50 ms de latence a en moyenne 10 requêtes en vol, donc il lui faut au moins 10 connexions ou fils d’exécution disponibles. »

Le temps de réponse d’un système interactif

Dans un système interactif, un nombre fixe $M$ d’utilisateurs alternent entre deux états : ils attendent une réponse (pendant $R$), puis ils réfléchissent avant de cliquer à nouveau (pendant un temps de réflexion moyen $Z$). Appliquons Little à la boucle complète « utilisateurs plus système » : les $M$ utilisateurs sont tous quelque part dans la boucle, et chaque tour dure $R + Z$. Donc $M = X_0 (R + Z)$, d’où :

$$R = \frac{M}{X_0} - Z$$

• $M$ est le nombre d’utilisateurs connectés ;
• $X_0$ est le débit du système ;
• $Z$ est le temps de réflexion moyen entre la réponse et la requête suivante.

Exemple

Pendant la période observée, 152 personnes naviguent sur la billetterie, chacune réfléchit en moyenne $Z = 15$ s entre deux clics, et le système termine $X_0 = 10$ requêtes/s. Le temps de réponse moyen vaut :

$$R = \frac{152}{10} - 15 = 15{,}2 - 15 = 0{,}2 \text{ s}$$

Si 200 personnes étaient connectées et que le débit restait à 10 requêtes/s, on aurait $R = 20 - 15 = 5$ s. Mais le débit resterait-il à 10 requêtes/s ? Probablement pas : plus d’utilisateurs envoient plus de requêtes. Jusqu’où le débit peut-il monter ? C’est la question du chapitre suivant.

Little appliquée à chaque moitié de la boucle : X₀ Z = 150 personnes réfléchissent et X₀ R = 2 requêtes sont en cours, soit bien les 152 utilisateurs connectés.

Piège

Oublier $Z$. Appliquer directement $R = M / X_0$ donnerait ici 15,2 s au lieu de 0,2 s : on compterait comme « en attente » des utilisateurs qui sont en train de lire la page.

Tout faire en quelques lignes de Python

Les lois opérationnelles se codent en quelques lignes. C’est le genre de script que l’on garde sous la main pour vérifier la cohérence de mesures :

T, C0 = 120.0, 1_200                       # durée d'observation (s), commandes terminées
compteurs = {                              # ressource : (temps occupé B en s, passages C)
    "web":        (24.0, 1_200),
    "processeur": (36.0, 6_000),
    "disque":     (72.0, 4_800),
}

X0 = C0 / T
print(f"Débit du système X0 = {X0:.1f} req/s")
for nom, (B, C) in compteurs.items():
    U = B / T                # loi d'utilisation
    S = B / C                # temps de service par visite
    V = C / C0               # visites par requête
    D = U / X0               # loi de la demande de service (= V * S)
    print(f"{nom:<11} U={U:.2f}  S={S*1000:5.1f} ms  V={V:.0f}  D={D*1000:5.1f} ms")

La sortie donne une demande de 20 ms pour le serveur web, 30 ms pour le processeur et 60 ms pour le disque. Nous réutiliserons ces trois demandes dans tous les chapitres suivants.

Chaque bloc est une visite de durée S ; la demande D est la longueur totale de la barre. Le processeur a le plus de visites, mais c'est le disque qui a la plus grande demande (60 ms).

En résumé

• Les lois opérationnelles sont des identités tirées de compteurs ($T$, $B_i$, $A_i$, $C_i$, $C_0$), sans hypothèse probabiliste ; on suppose seulement l’équilibre des flux.
• Utilisation : $U_i = X_i S_i$. Flux forcé : $X_i = V_i X_0$.
• Demande de service : $D_i = V_i S_i = U_i / X_0$, le temps de service total par requête sur la ressource $i$.
• Little : $N = X R$, valable pour tout sous-système délimité.
• Temps de réponse interactif : $R = M / X_0 - Z$, qui n’est autre que Little appliquée à la boucle utilisateurs plus système.
• Ne confondez pas $S_i$ (par visite) et $D_i$ (par requête), ni le temps de service (sans attente) et le temps de réponse (avec attente).

Exercices

Exercice · Du compteur à la demande

facile

Sur une période de 5 minutes, un serveur de fichiers a terminé 9 000 requêtes. Son disque a été occupé 180 s et a effectué 27 000 accès.

Calculez l’utilisation du disque, son débit, son temps de service, le nombre de visites par requête et la demande de service.

Voir la solution

$T = 300$ s.

• Utilisation : $U = 180/300 = 0{,}6$.
• Débit du disque : $X = 27\,000/300 = 90$ accès/s.
• Temps de service : $S = 180/27\,000 \approx 6{,}67$ ms.
• Débit du système : $X_0 = 9\,000/300 = 30$ req/s, donc $V = 27\,000/9\,000 = 3$ visites par requête.
• Demande de service : $D = V S = 3 \times 6{,}67 = 20$ ms, que l’on retrouve par $U/X_0 = 0{,}6/30 = 0{,}02$ s.

En code

Python

T = 5 * 60                      # période d'observation (s)
C0, B, C = 9_000, 180, 27_000   # requêtes terminées, temps occupé du disque (s), accès disque

U = B / T                       # utilisation
X = C / T                       # débit du disque (accès/s)
S = B / C                       # temps de service par accès (s)
X0 = C0 / T                     # débit du système (req/s)
V = C / C0                      # visites par requête
D = V * S                       # demande de service (s)
print(U, X, round(S * 1000, 2), X0, V)   # 0.6 90.0 6.67 30.0 3.0
print(round(D * 1000, 1), U / X0)        # 20.0 0.02 : les deux calculs de D concordent

R

T  <- 5 * 60                    # période d'observation (s)
C0 <- 9000; B <- 180; C <- 27000

U  <- B / T                     # utilisation
X  <- C / T                     # débit du disque (accès/s)
S  <- B / C                     # temps de service par accès (s)
X0 <- C0 / T                    # débit du système (req/s)
V  <- C / C0                    # visites par requête
D  <- V * S                     # demande de service (s)
c(U = U, X = X, S_ms = S * 1000, X0 = X0, V = V)   # 0.6  90  6.67  30  3
c(D_ms = D * 1000, U_sur_X0 = U / X0)              # 20  0.02

Exercice · Little dans tous les sens

moyen

1. Une file de messages reçoit 500 messages par seconde et en contient 1 500 en moyenne. Combien de temps un message y reste-t-il ?
2. Un site a en moyenne 40 requêtes en cours et un temps de réponse moyen de 0,2 s. Quel est son débit ?
3. Un pool de 32 fils d’exécution traite des requêtes qui durent 80 ms chacune, sans attente. Quel débit maximal peut-il soutenir ?

Voir la solution

1. $R = N/X = 1\,500/500 = 3$ s.
2. $X = N/R = 40/0{,}2 = 200$ req/s.
3. Au maximum, les 32 fils sont tous occupés : $N = 32$. Avec $R = 0{,}08$ s, $X = 32/0{,}08 = 400$ req/s. Au-delà, les requêtes supplémentaires devront attendre un fil libre, et le temps de réponse augmentera.

En code

Python

# Loi de Little : N = X * R, on isole l'inconnue à chaque fois
R_file = 1_500 / 500            # 1. R = N / X
X_site = 40 / 0.2               # 2. X = N / R
X_pool = 32 / 0.080             # 3. X = N / R avec les 32 fils occupés
print(R_file, X_site, X_pool)   # 3.0 s  200.0 req/s  400.0 req/s

R

# Loi de Little : N = X * R, on isole l'inconnue à chaque fois
R_file <- 1500 / 500            # 1. R = N / X
X_site <- 40 / 0.2              # 2. X = N / R
X_pool <- 32 / 0.080            # 3. X = N / R avec les 32 fils occupés
c(R_file, X_site, X_pool)       # 3  200  400

Exercice · Un système interactif

difficile

Un logiciel de gestion est utilisé par 60 agents simultanés. On mesure un débit de 5 transactions/s et un temps de réponse moyen de 2 s. Le processeur du serveur a une utilisation de 0,5.

1. Quel est le temps de réflexion moyen des agents ?
2. Quelle est la demande de service du processeur ?
3. Combien de transactions sont en moyenne présentes dans le serveur ? Et combien d’agents sont en train de réfléchir ?

Voir la solution

1. De $R = M/X_0 - Z$, on tire $Z = M/X_0 - R = 60/5 - 2 = 10$ s.
2. $D_{\text{CPU}} = U/X_0 = 0{,}5/5 = 0{,}1$ s, soit 100 ms par transaction.
3. Little sur le serveur seul : $N = X_0 R = 5 \times 2 = 10$ transactions en cours. Little sur les agents en réflexion : $N_Z = X_0 Z = 5 \times 10 = 50$. On vérifie que $10 + 50 = 60$ : tous les agents sont bien comptés.

En code

Python

M, X0, R, U_cpu = 60, 5, 2, 0.5   # agents, débit (tr/s), temps de réponse (s), utilisation CPU

Z = M / X0 - R                    # 1. loi du temps de réponse interactif
D_cpu = U_cpu / X0                # 2. loi de la demande de service
N_serveur = X0 * R                # 3. Little sur le serveur
N_reflexion = X0 * Z              #    Little sur les agents qui réfléchissent
print(Z, D_cpu)                   # 10.0 s  0.1 s
print(N_serveur, N_reflexion, N_serveur + N_reflexion)   # 10  50  60 : tout le monde est compté

R

M <- 60; X0 <- 5; R <- 2; U_cpu <- 0.5

Z <- M / X0 - R                   # 1. loi du temps de réponse interactif
D_cpu <- U_cpu / X0               # 2. loi de la demande de service
N_serveur <- X0 * R               # 3. Little sur le serveur
N_reflexion <- X0 * Z             #    Little sur les agents qui réfléchissent
c(Z = Z, D_cpu = D_cpu)                                   # 10  0.1
c(N_serveur, N_reflexion, N_serveur + N_reflexion)        # 10  50  60