Question 1:
===========

Donner l'arbre des processus créés par le code suivant :

      main()
      {
    1	fork();
    2	fork();
    3	fork();
      }

Expliquer les relations père-fils entre les processus
à l'aide des numéros de ligne indiqués en face des appels
à fork().


Question 2:
===========

Ecrire un programme qui crée un processus fils.

Le processus fils se mets en pause pendant 20 secondes et
se termine (voir la fonction sleep)

Le processus père se met en attente du fils et crée un nouveau
processus dès que le fils précédent et terminé, après avoir
indiqué le code de sortie du processus fils terminé.

Observer les processus en activité avec la commande ps ou top ou  htop.
Que se pass-t-il si vous arrêtez le processus fils avec la commande
kill -9 ?

Que se passe-t-il si vous arrêtez le processus père alors que le 
fils est encore en activité ?


Question 3:
===========

Ecrivez un programme qui crée n processus selon la hiérarchie suivante, 
avec n passé en paramètre :

      P1--P2 -- ... -- Pn-1 -- Pn

Question 4:
==========

Même question que 3) mais avec la hiérarchie suivante :

    P0-+-P1
       |-P2
       |-...
       |- 
       |-n-1
       `-Pn

Question 5:
===========

Même question que pour la 3 et la 4 mais en combinant les hiérarchies de 
la question 3 et 4 de la manière suivante :

    P0-+-P1-- ... -- Pn-1 -- Pn
       |-P2
       |-...
       |- 
       |-n-1
       `-Pn

Question 6:
===========

Ecrire un programme qui crée un processus fils pour lancer la commande ps -f.
Le processus père attendra la fin du processus fils. Analyser le résultat
du programme.

Question 7:
===========

En utilisant l'aide de l'appel système pipe(), écrire un programme de test qui 
se communique vers lui même à travers le tube.


Question 8:
===========

Ecrire un programme qui crée un tube puis crée
ensuite un processus fils (fork()). Le processus
fils utilise le tube pour envoyer un message au
père, qui le convertit en majuscule et l'affiche sur la
sortie standard. Pour convertir un caractère en
majuscule, voir la fonction toupper()


Question 9:
===========

Ecrire un programme qui crée un tube, puis crée un
processus fils.

Le processus fils :

- utilise le tube pour y envoyer une chaînee de
caractère
- fait une pause de 10secondes.
- Envoie un deuxième message dans le tube
Le processus père :
- Lit puis affiche tous les messages qui arrivent
par le tube

Mettre en évidence que l'appel à read() du père
est bloquant. Comment pourrait-on utiliser cette
propriété pour synchroniser des processus ? Implémenter
l'un des mécanismes de synchronisation vus en
concurrence avec les tubes (mutex, sémaphore, etc)


Question 10:
============

Ecrire un programme qui calcule la somme des carrés avec
plusieurs processus communiquants.

Exemple : 458^2 + 1234^2 + 999^2.

Un processus sera utilisé pour calculer chaque Terme. Le processus 
fils fait le calcul et l'envoie au père

Le père lit tout les résultats et en fait l'addition avant d'afficher le résultat.

Votre programme devra fonctionner avec un nombre quelconque de
termes donnés en ligne de commande au programme initial.


Question 11:
============

En utilisant fork(), execve() pipe() programmer l'équivalent de la commande 
shell suivante en C : 

    ls /dev | head -n 30


Question 12 :
=============

Créer un programme C qui contruit un anneau de communication entre 3 processus
via des pipes système. Votre programme devra créer 3 tubes t1, t2, t3 et 3 processus
p1, p2 et p3. 

- Tout ce que p1 envoit dans t1 est lu par p2 depuis t1. 
- Tout ce que p2 envoit dans t2 est lu par p3 depuis t2.
- Touce ce que p3 envoit dans t3 est lu par p1 depuis t3.

Le processus p1 enverra un caractère dans t1 et s'attendra à le récupérer dans t3 le
plus vite possible.

Mesurer le temps nécessaire au caractère pour faire le tour complet de l'anneau. 

Réfléchir à la manière dont vous procéderiez pour écrire le même programme 
construisant un anneau de communication entre un nombre n quelconque de processus.