# Système d'Exploitation : Cours 3 : Processus & Threads

- [Système d'Exploitation : Cours 3 : Processus & Threads](#système-dexploitation--cours-3--processus--threads)
  - [Processus](#processus)
  - [Multi programmation](#multi-programmation)
  - [Types de processus](#types-de-processus)
  - [Etats d'un processus](#etats-dun-processus)
    - [Principaux états](#principaux-états)
    - [Transitions d'états](#transitions-détats)
  - [Les Interruptions](#les-interruptions)
  - [Gestion de processus](#gestion-de-processus)
    - [PCB](#pcb)
    - [Création de processus](#création-de-processus)
    - [Dupliquer](#dupliquer)
    - [Remplacer](#remplacer)
    - [Identité](#identité)
    - [Terminer un processus](#terminer-un-processus)
    - [Attendre la fin d'un processus](#attendre-la-fin-dun-processus)
  - [Thread](#thread)
    - [Créer un thread](#créer-un-thread)
    - [Terminaison d'un thread](#terminaison-dun-thread)
    - [Attente de la terminaison d'un thread](#attente-de-la-terminaison-dun-thread)

## Processus

- Concept central pour tout OS. C'est une séquence d'actions produite par l'exécution d'une suite d'instructions.
- Un processus est une instance d'un programme en cours d'exécution.
  - Tâches en cours
  - Environnement propre, son contexte d'exécution.
  - Espace mémoire propre, son espace d'adressage, contient code et données du programme.

**Programme :** concept statique ; code et données, pas d'actions.

**Processus :** concept dynamique, exécution du programme (instance, plusieurs processus d'un même programme possibles) avec un état courant.

## Multi programmation

- Système temps partagé : l'UC passe d'un processus à l'autre rapidement.
  - Plusieurs fils d'exécution séquentiels
- Virtualisation d'une UC
  - N UC virtuelles mais une UC physique
  - N compteurs ordinaux logiques mais un compteur physique
  - Différent d'un vrai parallélisme matériel (multi processeur)

## Types de processus

- Processus utilisateur
  - Exécution des applications
  - Utilisateur particulier : root
  - Certaines instructions interdites ou limitées
- Processus système : exécution en mode kernel.

> Mode noyau != mode super user

## Etats d'un processus

- Contexte ou vecteur d'état
  - Information de l'exécution du processus
  - Point interruptible : instant pendant lequel le contexte contient des informations stables.

### Principaux états

- Bloqué
  - Attente de ressources nécessaires
- Activable
  - Ressources disponibles
  - En attente de l'UC
- Actif
  - Ressources disponibles
  - S'exécute sur l'UC

### Transitions d'états

- Activable → Actif
  - Modification du vecteur d'état par le scheduler
  - Commutation de contexte
- Active → Activable
  - Interruption prioritaire (ex : fin quantum de temps)
  - Communcation de contexte
- Actif → Bloqué
  - Processus lui même
  - Blocage matériel : demande de ressource non dispo
  - Blocage logiciel : prévu par le programmeur
  - Commutation de contexte
- Bloqué → Activable
  - Sur l'arrivée d'un evénement
  - Signalé par une interruption
  - Commutation de contexte pas automatique

## Les Interruptions

- Arrivée d'un évènement → arrivée d'une interruption
- Prise en compte de l'évèneent → traitement de l'interruption
- Rôle très important : unique moyen pour le SE de prendre la main sur le CPU.

## Gestion de processus

### PCB

- Ensemble de PCB (Process Control Block)
  - Structure de donnée propre au SE
  - Info accessible uniquement par le noyau (appel système)
  - Contient : 
    - Identité : PID, PPID, droits
    - Exécution : Etat, contexte, priorité
    - Ressources : mémoire, temps, fichiers
  
### Création de processus

- Un processus peut en créer un autre
- Windows : pas de hiérarchie 
- UNIX : Parents, enfants, groupe, identifié par une numéro (PID,PPID)
- Arbre de processus 

### Dupliquer

```c
int pid = fork();
```

Duplication du processus appelé.
Renvoie `0` si c'est le fils, renvoie le PID du fils si c'est le père.

### Remplacer

Les appels système de la famille `exec` permettent de remplacer entièrement le processus courant par celui d'une autre application.

L'appel système de base est `execve()`.
Des variantes sont implémentée : 
- `execl()` : l → Liste d'arguments
- `exelv()` : v → tableau à la manière de `argv`. 
- Termine par e → transmet l'environnement (`tab envp[]`)
- Termine par p → recherche l'application à lancer à partir du PATH, pour les autres, il faut le chemin d'accès.

### Identité

Dans un terimnal : 

```
echo $$
```

ou 

```
ps
```

En C : 
```c
pid_t getpid()
```

### Terminer un processus

```c
void exit(int status)
```

Le status est une variable entière qui donne des information sur le succès ou l'échec de l'exécution du processus : `0` normal, sinon anormal.
Macros : `EXIT_SUCCESS` et `EXIT_FAILURE`
Cette valeur doit être récupérée par le parent. Pas de libération de ressource tant que ce n'est pas fait : état zombie.

### Attendre la fin d'un processus

```c
pid_t wait(int* status)
```
Attends la fin d'un processus fils. Si pas de fils, retourne -1.
Si plusieurs fils : impossible d'en séléctionner un en particulier.
`status` permet de récupérer la valeur retournée par le fils.

```c
pid_t waitpid(pid_t pid, int* stat_infos, int options)
```
Attendre la fin d'un processus particulier.

## Thread

- Processus → couteux en temps
- Contexte lourd
- Un thread est un processus léger
- Espace mémoire partagé
  - Partage des données facile
  - Attention à la synchronisation

### Créer un thread

```c
int pthread_create(pthread_t* idptr, pthread_attr_t attr, void*(*fonc)(void*), void* arg)
```
- `idptr` → pointeur pour récupérer l'identité du thread
- `attr` → attribut du thread : `pthread_attr_default` ou `0`
- `fonc` → pointeur sur la fonction exécutée par le thread
- `arg` → pointeur sur les arguments passés au thread

Contrairement au processus, le code n'est pas dupliqué

### Terminaison d'un thread

 ```c
 int pthread_exit(void* status)
 ```

 stauts → pointeur sur le résultat retourné par le thread

 ### Attente de la terminaison d'un thread

  ```c
 int pthread_join(pthread_t id, void* status)
 ```

- `id` → identité du thread attendu
- `status` → pointeur sur le résultat retourné par le thread attendu