# 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** ?