Le but de cette séance est de manipuler les processus et une première méthode de communication entre ceux-ci.

1. Rappels sur les Processus

1.1. Commandes Shell

Quelle commande permet d’afficher la liste des processus liés à votre shell ? Quelle option permet d’afficher tous les processus de votre système ?

Combien y-a-t-il de processus sur votre système (rappel : commande wc).

1.2. Le Système “/proc“

Faire l’opération suivante, où <pid> est le numéro de processus de votre shell :

$ cd /proc/<pid>; ls

Explorer les données de contrôle associées à votre processus shell. Lesquelles vous paraissent les plus importantes ?

2. Création de Processus

2.1. Premier exemple

Exécuter le code suivant, plusieurs fois. Que constatez-vous ?

Pour les deux processus, ajouter

• un temps d’attente de 3 secondes (avec time.sleep(nb))
• l’affichage de la phrase “Fin de sommeil” avant de quitter le programme.

2.2. Communication Simple Enfant-Parent

La commande statut = os.wait() permet au parent d’attendre la terminaison de son enfant. La valeur de retour statut est un tuple contenant le pid de l’enfant, et l’indication de terminaisondu processus (on peut la définir avec la commande exit(nb)).

Ecrire un programme dans lequel

• l’enfant tire au hasard un entier nb entre 1 et 10, dort nb secondes et termine avec exit(nb).
• le parent crée un enfant puis attend sa terminaison. Le parent affiche le nombre nb de l’enfant ainsi que son pid.

2.3. Création et Gestion de Plusieurs Enfants

Écrire un programme qui

• crée 10 enfants
• chaque enfant tire un nombre au hasard entre 1 et 10, dort nb secondes et termine avec exit(nb).
• le programme principal affiche le pid du dernier enfant qui a terminé et affiche la moyenne des nb des enfants.

3. Expérience avec l’Ordonnancement Linux

3.1. Un Banc d’Essai

Le but est de tester l’algorithme d’ordonnancement de Linux. On commmence par écrire une fonction q_activité() qui réalise une boucle (vide) de QUANTUM pas de tel manière que cela prend environ 1 seconde sur votre système, puis affiche le pid du processus. Le but est de simuler des calculs sur un quantum d’une seconde.

Écrire un programme qui

• à partir d’une liste de nb paires (durée, priorité)
• crée nb enfants et affecte chacune des paires à l’un des enfants
• chaque enfant
  • met sa priorité à priorité avec la commande io.nice(inc) (voir les détails ci-dessous)
  • effectue durée appels de la fonction q_activité()
  • termine en renvoyant son temps de réponse
• le processus parent affiche :
  • le temps moyen de traitement
  • le temps de réponse maximum

On testera avec l’exemple vu en TD, exercice B.4. On considérera que l’on a des quantums d’une seconde et que le surcoût de gestion (création des processus, calcul du temps …) est négligeable.

Remarques d’Implémentation:

• on calculera les temps écoulés en secondes avec time.time(), en appelant deux fois la fonction et faisant la différence entre les deux valeurs renvoyées,
• on convertira les priorités du TD en niveaux nice en notant que
  • nice considère des niveaux de 0 à 19 (inclus) où le niveau le plus élevé correspond à la priorité la plus basse. On considérera que la priorité 5 correspond au niveau 0 et la priorité 1 au niveau 16.
  • l’appel nice utilise comme paramètre inc qui est un incrément, donc positif, au niveau de nice actuel.

3.2. Tests

Tester également avec 10 processus qui choisissent leur paire (durée, priorité) au hasard entre 1 et 10, et 1 et 5 respectivement. Faire la moyenne des résultats obtenus, ainsi que d’autres analyses statistiques si vous en avez le temps.