TP3 - LIPN

Institut Galilée
Licence 2
Systèmes d’exploitation et Réseaux
TP 3
Ordonnancement
Vous allez utiliser tout au long de ce TP une bibliothèque de programmation qui va vous permettre
d’ordonnancer des processus : la bibliothèque libsched (library for scheduling). La version de la bibliothèque
que vous allez utiliser est légèrement différente de la version originale pour ne pas tenir compte de certains
mécanismes complexes. Cette bibliothèque propose de très nombreuses fonctionnalités. Au cours de cette
séance de TP nous utiliserons principalement les deux suivantes :
— Création de processus à exécuter (et que l’ordonnanceur pourra traiter)
— Modification de l’algorithme d’ordonnancement
Pour plus de détails sur le fonctionnement de la bibliothèque, consultez l’annexe du TP. Vous y trouverez
aussi des explications sur les notions d’archives : fichiers en ”.a”, ”.so” et ”.sa”.
La première étape de ce TP consiste à compiler la bibliothèque libsched afin de pouvoir l’utiliser sur
votre machine. Suivez les instructions suivantes :
1. Téléchargez les sources des bibliothèques elf et sched à l’adresse suivante :
http://lipn.univ-paris13.fr/~fouquere/ENSEIGNEMENT/L2SR (cliquez sur le lien ”TP3 (compléments)”)
2. Décompressez l’archive dans votre répertoire de travail (ex : TP3 ASR) : effectuez la commande
tar xzvf tp3_lib.tgz Vous devez maintenant avoir une arborescence du type :
Le répertoire libsched contient tous les fichiers
sources de la bibliothèque de programmation de
l’ordonnanceur. Le répertoire libelf contient tous
TP3_ASR
les fichiers sources de la bibliothèque elf. Cette bi|-- libsched
bliothèque permet de gérer le format ELF (Execu|-- libelf
table and Linking Format), format assez standard des
|-- exercices
fichiers compilés (en tout cas sous Unix). Le répertoire
|-- Makefile
exercices contient un fichier de démonstration
|-- demo.c
(demo.c) que vous pourrez compiler et exécuter. Le fi|-- exo-random.c
chier exo-random.c est une base de travail pour l’exer|-- exo-sjf.c
cice 1, exo-sjf.c correspond à l’exercice 2, exo-rr.c
|-- exo-rr.c
correspond à l’exercice 3 et exo-mlrr.c vous servira
|-- exo-mlrr.c
pour l’exercice 4. Le fichier Makefile vous permettra de compiler et exécuter facilement tous les programmes.
3. Créez la librairie libelf et copiez les librairies et en-têtes dans libsched :
cd libelf/
./configure --disable-shared
make
cp lib/libelf.a ../libsched
mkdir ../libsched/libelf
cp lib/*.h ../libsched/libelf
cd ..
4. Créez la librairie libsched :
cd libsched/
make
cd ..
5. Modifiez votre environnement pour que la nouvelle librairie libsched soit utilisable pour les
compilations et exécutions :
LD_LIBRARY_PATH=./../libsched/
1
6. La suite du TP s’effectue dans le répertoire exercices :
cd exercices
1
Politique FIFO
Le fichier demo.c, fourni avec l’archive, contient un scénario d’exécution de processus qui utilise
une politique d’ordonnancement FIFO en mode batch. Vous n’avez rien à ajouter au fichier pour qu’il
fonctionne.
1. Dans le répertoire exercices, exécutez la commande make demo.sched. Le fichier demo.c va être
compilé et lié à la bibliothèque libsched. Un fichier demo.sched va être créé. Testez-le. Ce
programme montre l’exécution de 4 processus de tailles différentes (2 courts, 2 longs) en respectant
la politique d’ordonnancement.
2. Modifiez le fichier demo.c pour que les processus courts s’exécutent avant les processus longs.
Utilisez la commande make demo.sched pour recompiler le programme.
3. Créez une une fonction ProcMoyen qui décrit le comportement d’un processus plus long qu’un
processus court, et plus court qu’un processus long. Modifiez la fonction main, pour créer dans
l’ordre 2 processus courts, 2 processus moyens et 1 processus long. Testez votre programme.
2
Politique Random
Nous allons écrire une première politique très simple : Election aléatoire. Cette politique consiste à
choisir au hasard un processus prêt à s’exécuter. Qu’il soit ancien ou récent, long ou court, la politique ne
tient compte d’aucun de ces critères. On utilisera cette politique avec un ordonnanceur en mode batch.
1. A l’aide de la fonction C random() écrivez la fonction RandomElect qui choisi un processus en cours
d’exécution. Un squelette de programme existe déjà dans le fichier exo-random.c. Indications :
— Le nombre maximum de processus est donné par la constante MAXPROC.
— Vérifiez avant de choisir un processus qu’il est en attente Tproc[pid] = RUN.
— Utilisez int i = (int) random() ; pour récupérer un entier aléatoire.
Pour compiler cet exercice, utilisez la commande la commande make exo-random.sched.
2. Vérifiez après plusieurs exécutions que l’élection des processus est bien aléatoire.
3
Politique Shortest Job First (PCTE, SJF)
Nous souhaitons maintenant implémenter la politique SJF (en mode batch). Pour cela, vous devez
compléter le fichier exo-sjf.c fourni dans l’archive. Ce fichier lance l’exécution de 5 processus longs, 5
processus moyens et 5 processus courts. Pour compiler cet exercice, utilisez la commande la commande
make exo-sjf.sched.
1. En regardant le code du fichier exo-sjf.c, déterminez la valeur du champ duration pour chaque
type de processus qui sera créé.
2. Complétez la fonction SJFElect en implémentant l’algorithme qui, lors de chaque élection, choisi
le processus le plus court. Indications :
— N’oubliez pas de vérifier que le processus est en attente avant de le choisir.
— Consultez l’annexe du TP pour trouver se trouve l’information de durée pour un processus.
4
Politique Round Robin (RR, quantum)
Nous souhaitons maintenant implémenter la politique Round Robin (en mode temps partagé). Pour
cela, vous devez compléter le fichier exo-rr.c fourni dans l’archive. Ce fichier lance l’exécution de 5
processus longs, 5 processus moyens et 5 processus courts. Complétez la fonction RRElect en implémentant
l’algorithme qui, lors de chaque élection, choisi le processus suivant dans la table des processus. Indications :
— Utilisez la variable statique head pour stocker la tête de la file.
— N’oubliez pas de vérifier que le processus est en attente avant de le choisir.
Pour compiler cet exercice, utilisez la commande la commande make exo-rr.sched.
2
5
Politique Round Robin à multiniveaux
Attention ! Cet exercice est plus dur que les autres. Prenez le temps de réfléchir à l’algorithme avant
de vous lancer dans le code . . .Il vous faudra sans doute un peu de temps et de réflexion avant d’en venir
à bout. Nous souhaitons maintenant implémenter la politique Multi Level Round Robin (en mode temps
partagé) comme vu en TD. Pour cela, vous devez compléter le fichier exo-mlrr.c fourni dans l’archive.
Ce fichier lance l’exécution de 2 processus longs spéciaux, 3 processus longs, 3 processus moyens et 3
processus courts. Les processus longs spéciaux lancent eux-mêmes et à intervalles réguliers de nouveaux
processus longs. Donc des processus arrivent en cours d’exécution. Pour compiler cet exercice, utilisez la
commande make exo-mlrr.sched.
1. Complétez la fonction MLRRElect en implémentant l’algorithme vu en TD sans tenir compte du
phénomène de famine. Indications :
— Utilisez un tableau d’entiers statique pour stocker la tête de chaque file.
— Vous pouvez utiliser le champ file du descripteur de processus...
— Le nombre de files est donné dans le fichier sched.h par la constante NBFILES.
— N’oubliez pas de vérifier que le processus est en attente avant de le choisir.
2. Implémentez et testez la solution proposée en TD pour pallier au phénomène de famine induit par
cet algorithme.
3