From 2a483e0f4b51b5367b82d0c53f5fb80a7b3b97d1 Mon Sep 17 00:00:00 2001 From: Denis Monnerat Date: Fri, 25 Sep 2026 12:17:20 +0200 Subject: [PATCH] ordonnancement --- tp/tp4/cpu.c | 13 ++ tp/tp4/ordonnancement.md | 399 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 412 insertions(+) create mode 100644 tp/tp4/cpu.c create mode 100644 tp/tp4/ordonnancement.md diff --git a/tp/tp4/cpu.c b/tp/tp4/cpu.c new file mode 100644 index 0000000..edcb51f --- /dev/null +++ b/tp/tp4/cpu.c @@ -0,0 +1,13 @@ +#include + + +int main(int argc, char *argv[]) +{ + unsigned long long i = 0; + + while (1) + i++; + + + return 0; +} diff --git a/tp/tp4/ordonnancement.md b/tp/tp4/ordonnancement.md new file mode 100644 index 0000000..092491f --- /dev/null +++ b/tp/tp4/ordonnancement.md @@ -0,0 +1,399 @@ +# Interruptions - Ordonnancement + +- partie 1 : [interruptions](interruptions.md) +- partie 2 : [Ordonnamcement](ordonnancement.md) + + +#### Ex1 1 + +Ouvrez un terminal et exécutez : + +```bash +ps +``` + +Puis : + +```bash +ps -f +``` + +et : + +```bash +ps -eo pid,ppid,stat,ni,pri,psr,comm +``` + +Cette dernière commande affiche notamment : + +- `PID` : identifiant du processus ; +- `PPID` : identifiant du processus père ; +- `STAT` : état du processus ; +- `NI` : valeur de nice ; +- `PRI` : priorité affichée par Linux ; +- `PSR` : numéro du processeur sur lequel le processus s'est exécuté ; +- `COMMAND` : nom du programme. + +### Questions + +1. Quelle est la valeur de `nice` d'un processus nouvellement créé ? +2. Quelles valeurs peut prendre `nice` ? +3. Que signifie une valeur de `nice` élevée ? +4. Que signifie l'état `R` ? +5. Que signifie l'état `S` ? +6. Pourquoi le champ `PSR` peut-il changer au cours du temps ? + + +#### Ex2. + +Nous allons créer un programme très simple qui consomme du temps processeur. + +Créez le fichier `cpu.c` : + +```c +#include + +int main(void) +{ + unsigned long long i = 0; + + while (1) + i++; + + return 0; +} +``` + +Compilez-le : + +```bash +gcc -O2 -o cpu cpu.c +``` + +Lancez-le : + +```bash +./cpu +``` + +Dans un autre terminal : + +```bash +top +``` + +### Questions +7. Quel pourcentage de CPU utilise le processus `cpu` ? +8. Observez le champ `NI`. +9. Observez le champ `PR`. +10. Sur quel processeur le processus s'exécute-t-il ? + +Utilisez : + +```bash +watch -n 0.1 ps -C cpu -o pid,ni,pri,psr,comm +``` + +11. Appuyez sur `1` dans `top`. Que constatez-vous concernant les différents processeurs ? + +Pour arrêter le programme : + +```bash +killall cpu +``` + +#### Ex3 + +Lancez maintenant **deux** instances : + +```bash +./cpu & +./cpu & +``` + +Puis : + +```bash +watch -n 0.1 ps -C cpu -o pid,ni,pri,psr,pcpu,comm +``` + +et observez avec : + +```bash +top +``` + +### Questions + +12. Si votre machine possède plusieurs processeurs logiques, les deux processus utilisent-ils nécessairement le même processeur ? +13. Lancez quatre processus : + +```bash +./cpu & +./cpu & +./cpu & +./cpu & +``` + +Observez leur utilisation CPU. + +14. Que se passe-t-il si vous lancez davantage de processus que votre machine ne possède de processeurs logiques ? +15. Pourquoi un processus CPU-bound finit-il malgré tout par laisser le processeur à un autre processus ? + + +#### Ex4 + +La commande `nice` permet de lancer un processus avec une valeur de `nice` particulière. + +Lancez : + +```bash +nice -n 10 ./cpu & +``` + +Puis : + +```bash +watch -n 0.1 ps -C cpu -o pid,ni,pri,pcpu,comm +``` + +Comparez avec un processus lancé normalement : + +```bash +./cpu & +``` + +### Questions + +16. Quelle est la valeur de `nice` des deux processus ? +17. Leur valeur de `PRI` est-elle identique ? +18. Que signifie concrètement `nice = 10` ? +19. Est-ce que `nice` signifie que le processus est exécuté « moins souvent » au sens strict ? + + +#### Ex5 + +Lancez deux processus : + +```bash +./cpu & +./cpu & +``` + +Repérez leurs PID : + +```bash +pgrep cpu +``` + +Choisissez l'un des deux PID et modifiez sa valeur de nice : + +```bash +renice 10 -p PID +``` + +par exemple : + +```bash +renice 10 -p 12345 +``` + +Observez : + +```bash +ps -p 12345 -o pid,ni,pri,pcpu,comm +``` + +### Expérience + +Essayez de faire tourner simultanément deux processus `cpu` : + +- l'un avec `nice = 0` ; +- l'autre avec `nice = 10`. + +Observez leur consommation CPU pendant plusieurs secondes. + +### Questions + +20. Le processus avec `nice = 10` reçoit-il toujours du CPU ? +21. Que constatez-vous lorsque les deux processus se disputent le même processeur ? +22. Si les deux processus peuvent s'exécuter simultanément sur deux processeurs différents, l'effet de `nice` est-il aussi visible ? +23. Expliquez pourquoi. + +> **Attention :** `nice` modifie la priorité relative d'un processus, mais ne lui réserve pas une quantité fixe du processeur. + + +#### Ex6 + +Linux permet de restreindre les processeurs sur lesquels un processus peut s'exécuter. + +Utilisez : + +```bash +nproc +``` + +pour connaître le nombre de processeurs logiques disponibles. + +Lancez : + +```bash +taskset -c 0 ./cpu & +``` + +Puis : + +```bash +ps -C cpu -o pid,psr,pcpu,comm +``` + +Vous pouvez également consulter directement l'affinité : + +```bash +taskset -p PID +``` + +### Questions + +24. Sur quel processeur le processus est-il autorisé à s'exécuter ? +25. Pourquoi le champ `PSR` reste-t-il normalement égal à `0` ? +26. Quelle différence faites-vous entre : + +```text +nice +``` + +et : + +```text +taskset +``` + + +#### Ex7 + +Nous allons maintenant forcer deux processus à utiliser **le même processeur**. + +Lancez : + +```bash +taskset -c 0 ./cpu & +taskset -c 0 ./cpu & +``` + +Observez : + +```bash +top +``` + +Puis : + +```bash +ps -C cpu -o pid,ni,pri,psr,pcpu,comm +``` + +### Questions + +27. Les deux processus peuvent-ils s'exécuter simultanément sur le CPU 0 ? +28. Quelle proportion approximative du temps processeur reçoit chaque processus ? + +Modifiez maintenant la priorité du premier processus : + +```bash +renice 10 -p PID1 +``` + +et laissez le second avec : + +```text +nice = 0 +``` + +29. Observez à nouveau `top`. +30. Expliquez qualitativement l'effet de `nice` lorsque deux processus CPU-bound sont contraints de partager le même processeur. + +#### Ex8 + +Linux fournit de nombreuses informations sur chaque processus dans : + +```text +/proc/PID/ +``` + +Pour un processus `cpu`, examinez : + +```bash +cat /proc/PID/status +``` + +puis : + +```bash +cat /proc/PID/sched +``` + +Dans `sched`, recherchez notamment : + +```text +se.sum_exec_runtime +nr_switches +nr_voluntary_switches +nr_involuntary_switches +``` + +### Questions + +31. Que représente `se.sum_exec_runtime` ? +32. Quelle différence faites-vous entre : + +- changement de contexte volontaire ; +- changement de contexte involontaire ? + +33. Pourquoi un processus `cpu` devrait-il avoir relativement peu de changements de contexte volontaires ? + + +#### Ex9 + +Nous allons mettre en place l'expérience suivante : + +- deux processus `cpu` ; +- tous deux limités au CPU 0 ; +- processus A : `nice = 0` ; +- processus B : `nice = 15`. + +Lancez-les : + +```bash +taskset -c 0 ./cpu & +``` + +et : + +```bash +taskset -c 0 nice -n 15 ./cpu & +``` + +Notez leurs PID. + +Après environ 30 secondes, récupérez : + +```bash +cat /proc/PID_A/sched +cat /proc/PID_B/sched +``` + +Relevez notamment : + +```text +se.sum_exec_runtime +nr_switches +``` + +### Questions + +34. Le temps CPU obtenu par A et B est-il identique ? +35. Comparez les valeurs de `se.sum_exec_runtime`. +36. Quelle conclusion pouvez-vous tirer sur l'influence de `nice` ? +37. Pourquoi cette expérience est-elle plus significative lorsque les deux processus sont attachés au **même CPU** ? +