198 lines
7.7 KiB
Markdown
198 lines
7.7 KiB
Markdown
# Gestion des processus et des ressources
|
|
|
|
## Le programme
|
|
|
|
|
|
|
|
------
|
|
|
|
Nous le savons, un ordinateur possède une architecture de Von Neumann, il y a donc différents composants tels que la mémoire vive, la mémoire 'dure' (Disque dur, SSD...), un processeur... C'est cet élément-ci qui nous intéresse aujourd'hui.
|
|
|
|
Le processeur est le cerveau de l'ordinateur et c'est lui qui exécute les tâches de la machine.
|
|
|
|
Comment expliquer que notre processeur arrive à ouvrir un navigateur web, un lecteur de musique, télécharger un jeu ou encore envoyer des messages le tout simultanément. (Sans parler des tâches de fond de l'ordinateur)
|
|
|
|
Tous ces programmes sont en réalité des lignes immenses de code et le processeur, lui, agit seul. Il exécute une à une les instructions de chaque programme, mais donne la sensation de tout gérer en même temps.
|
|
|
|
> Les processeurs multi-cœurs fonctionnent de la même façon à l'exception près qu'il n'y a pas 1 cœur, mais 4 voire 8 cœurs. Mais au vu de la multitude de programmes tournant en même temps sur la machine, le nombre de cœurs est nettement inférieur.
|
|
|
|
## 1. Notion de processus
|
|
|
|
Un **processus** est un programme **en cours d'exécution** : lorsqu'on lance un programme, le système d'exploitation crée un processus, c'est-à-dire une instance vivante du programme avec tout ce dont elle a besoin (instructions chargées en mémoire, données, ressources allouées).
|
|
|
|
Il ne faut pas confondre les deux :
|
|
|
|
- le **programme** est un fichier statique posé sur le disque (la recette de cuisine) ;
|
|
- le **processus** est son exécution en mémoire (le plat en train de cuire).
|
|
|
|
Un même programme peut d'ailleurs être lancé plusieurs fois et donner plusieurs processus distincts (deux fenêtres du même navigateur, par exemple). Un processus peut aussi créer lui-même d'autres processus, appelés **processus fils**.
|
|
|
|
Les processus prêts à s'exécuter sont placés dans une file (tout cela est géré par l'OS [Rappel 1ère]) et le processeur les traite à tour de rôle.
|
|
|
|
*Exemple de répartition de deux programmes par l'OS :*
|
|
|
|
<img src="assets/file.png" alt="File" style="width:50%;" />
|
|
|
|
Chaque processus possède différentes informations stockées en mémoire (dans le PCB (*Process Control Block*)) comme :
|
|
|
|
| Nom | Description |
|
|
| ---------- | ----------------------------------------------------- |
|
|
| PID | Process ID, identifiant du processus |
|
|
| Etat | Etat du processus |
|
|
| Registre | Valeur des registres lors de la dernière interruption |
|
|
| Mémoire | Emplacement mémoire alloué par le système |
|
|
| Ressources | Ressources utilisées par le processus. |
|
|
|
|
## 2. Gestion des processus
|
|
|
|
Nous l'avons vu, chaque processus possède plusieurs informations. **L'état** d'un processus permet de comprendre comment la file d'exécution est créée et comment celle-ci perdure.
|
|
|
|
Il existe 3 états différents :
|
|
|
|
- Prêt : Le processus attend d'être exécuté. Il est dans la file d'exécution.
|
|
- Elu : En cours d'exécution
|
|
- Bloqué/En attente : Le processus nécessite une ressource non disponible, tel qu'un emplacement mémoire ou une entrée/sortie.
|
|
Lorsque la ressource sera disponible, le processus repassera en état prêt.
|
|
- On peut imaginer que le processus attend l'intervention de l'utilisateur, ou le chargement d'une ressource (donc d'autres processus), etc.
|
|
|
|
Il existe aussi deux autres états :
|
|
|
|
- Nouveau : le processus vient d'être créé, il n'est pas encore dans la file d'exécution
|
|
- Terminé : l'exécution du processus est finie.
|
|
|
|
<u>Voici un schéma des différents états :</u>
|
|
|
|
<img src="assets/etat.png" style="zoom:50%;" />
|
|
|
|
### L'ordonnanceur
|
|
|
|
C'est **l'ordonnanceur** (*scheduler* en anglais), un composant du système d'exploitation, qui décide quel processus prêt devient élu, et pour combien de temps.
|
|
|
|
La politique la plus simple est le **tourniquet** (*round-robin*) : chaque processus reçoit à tour de rôle une petite tranche de temps processeur (quelques millisecondes), appelée **quantum**. Quand son quantum est écoulé, le processus élu repasse à l'état prêt et retourne dans la file. C'est cette alternance très rapide qui donne l'illusion que tout s'exécute en même temps.
|
|
|
|
D'autres politiques existent (par priorité, par plus court travail d'abord...), c'est ce que vous manipulerez dans le TP Ordonnanceur.
|
|
|
|
## 3. Interblocage :
|
|
|
|
L'interblocage intervient lorsque plusieurs processus sont bloqués les uns par les autres.
|
|
Imaginons deux programmes.
|
|
|
|
```
|
|
# Programme 1 :
|
|
Accès à la ressource A
|
|
Accès à la ressource B
|
|
....
|
|
Libération de ressource B
|
|
Libération de ressource A
|
|
```
|
|
|
|
```
|
|
# Programme 2 :
|
|
Accès à la ressource B
|
|
Accès à la ressource A
|
|
....
|
|
Libération de ressource A
|
|
Libération de ressource B
|
|
```
|
|
|
|
### 3. 1. Un exemple d'ordonnancement
|
|
|
|
```
|
|
# Programme 1 :
|
|
Accès à la ressource A
|
|
Accès à la ressource B
|
|
```
|
|
|
|
- Le processus 1 a commencé, via un premier processus. Afin de faire tourner tous les programmes 'en même temps' il repasse dans la file d'exécution
|
|
|
|
```
|
|
# Programme 2 :
|
|
Accès à la ressource B
|
|
....
|
|
```
|
|
|
|
- Ici l'accès ne peut se faire, le programme 2 passe donc en état **Bloqué**
|
|
|
|
```
|
|
# Programme 1 :
|
|
....
|
|
Libération de ressource B
|
|
Libération de ressource A
|
|
```
|
|
|
|
- Le programme 1 se termine et donc libère A et B
|
|
|
|
```
|
|
# Programme 2 :
|
|
Accès à la ressource B
|
|
Accès à la ressource A
|
|
....
|
|
Libération de ressource A
|
|
Libération de ressource B
|
|
```
|
|
|
|
- Le programme 2 peut donc s'exécuter normalement
|
|
|
|
### 3. 2. Mauvais ordonnancement :
|
|
|
|
```
|
|
# Programme 1 :
|
|
Accès à la ressource A
|
|
```
|
|
|
|
- Le programme 1 crée un premier processus, qui appelle la ressource A
|
|
|
|
```
|
|
# Programme 2 :
|
|
Accès à la ressource B
|
|
```
|
|
|
|
- Le programme 2 crée un premier processus, qui appelle la ressource B
|
|
|
|
```
|
|
# Programme 1 :
|
|
Accès à la ressource B
|
|
```
|
|
|
|
- Le programme 1 attend la ressource B utilisée par le programme 2 et passe en état bloqué.
|
|
|
|
```
|
|
# Programme 2 :
|
|
Accès à la ressource A
|
|
```
|
|
|
|
- Le programme 2 attend la ressource A utilisée par le programme 1 et passe en état bloqué.
|
|
|
|
Ici les deux programmes sont en état bloqué car chacun attend la ressource de l'autre. Il y a interblocage et donc aucun des programmes ne peut s'exécuter.
|
|
|
|
## 4. En pratique
|
|
|
|
### 4. 1. Windows
|
|
|
|
Sous Windows il est possible de voir les processus en cours d'exécution grâce au **gestionnaire de tâches**. Celui-ci est accessible grâce aux touches Ctrl+Maj+Echap.
|
|
Il suffit ensuite d'aller dans l'onglet détail et on obtient tous les processus.
|
|
|
|
<img src="assets/liste_processus_windows.png" style="width:60%;" />
|
|
|
|
Nous retrouvons bien, l'**état**, le **PID**, la **mémoire occupée**
|
|
|
|
### 4. 2. Linux
|
|
|
|
Sous linux, il suffit d'accéder au terminal. Et d'y écrire la commande **ps**, il est possible de voir les **PID** et **PPID** (processus parent)
|
|
|
|
|
|
|
|
### 4. 3. macOS
|
|
|
|
macOS étant un système Unix (dérivé de BSD), on retrouve les mêmes commandes que sous Linux en grande partie.
|
|
Pour voir les processus, ici, on utilisera plutôt **TOP** (dispo sous linux également donc).
|
|
|
|
<img src="assets/top.png" alt="top" style="zoom:50%;" />
|
|
|
|
---------
|
|
|
|
Auteurs : Florian Mathieu, Enzo Frémeaux, Timothée Decoster
|
|
|
|
Licence CC BY-SA
|
|
|
|
<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International</a>. |