ordonnancement

tp/tp4/cpu.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+
+int main(int argc, char *argv[])
+{
+	    unsigned long long i = 0;
+
+    while (1)
+        i++;
+
+
+	return 0;
+}

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 <stdio.h>
+
+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** ?
+