# Redirections, tubes, synchronisation

#### Ex1
Soit le graphe de processus suivant (un tube est établi entre Pf2 et
Pf1f1)

```bash
	| P
	|____
	|    \  Pf1  
	|     \
	|      \
	|\Pf2  |\
	| \    | \Pf1f1
	|  \   |  \
	O   O  O   O
	    ()-->--()
```

1.  Ecrivez un programme pipe-ex.c qui implante le graphe ci-dessus
    (y compris le tube) et tel que :  
    -   Pf2 écrive en permanence toutes les 3 secondes son PID dans
        le tube en affichant ce qu'il écrit
    -   Pf1f1 lise en permanence chaque seconde depuis tube
        `sizeof(pid_t)` en affichant ce qu'il lit

    Vérifiez que le programme fonctionne comme prévu, i.e il affiche
    :

    ```bash
    16411 sent 16411
    	16412 received 16411
    16411 sent 16411
    	16412 received 16411
    .....

    ```

2.  Lancez le programme ci-dessus et faites les essais suivants
    (relancez le programme après chaque essai). Expliquez à chaque
    fois vos observations.
    1.  Envoyez le signal `SIGSTOP` à Pf2, puis le signal SIGCONT à
        Pf2.
    2.  Envoyez le signal `SIGSTOP` à Pf1f1, puis le signal SIGCONT à
        Pf1f1.
    3.  Envoyez le signal `SIGTERM` à Pf2.
    4.  Envoyez le signal `SIGTERM` à Pf1f1.  
3.  Modifiez le programme pipe-ex.c en assurant que tous les
    processus ferment les descripteurs du tube non utilisés. Faites
    les mêmes essais que ci-dessus et expliquez ce que vous
    observez.
4.  Modifiez encore une fois le programme pipe-ex.c pour que les
    deux processus Pf1, Pf2 écrivent dans le tube simultanement et
    que seul Pf1f1 le lise. Qu'observez-vous ?

#### Ex2
Reprendre l'[exercice 1](../tp5/parallelisme.md) du tp précédent. Vous devez utiliser comme
seul moyen de communication, entre les fils et le pere, des tubes (plus de `mmap`). 
Les processus fils, à la création, ne savent pas quelle tranche ils doivent sommer.

1. De combien de tubes a-t-on besoin ?
2. On rappelle que l'écriture dans un tube est atomique jusqu'à `PIPE_BUF`.
3. Écrire le programme correspondant.

#### Ex3
Testez le programme de l'exercice 3 du td6 (Ératosthène + pipe)

#### Ex4
Il s'agit d'un [exercice](./src/billes.c) classique de synchronisation. Des billes, dans une zone rectangulaire, se déplacent en rebodissant
sur les parois et les unes sur les autres. Chaque bille est un processus. L'état global est une zone partagée, protégée
en écriture par un sémaphore (cf cours).

L'affichage graphique est géré par le processus père (superviseur). Chaque bille, après mise à jour de sa position,
envoie un message au superviseur par un tube pour rafraîchir la fenêtre d'affichage. **Seule cette partie est à compléter**.

<div align="center">
<img src="billes.png">
</div>

```bash
gcc -o billes billes.c -lX11 -lm
```