INFO604 : Systèmes de synchronisation et Processus

Quelques documents pour les TD et TP d'INFO604 :

• énoncé du TD1
• énoncé du TD2
• énoncé du TD3
• énoncé du TD4
• énoncé du TD5
• énoncé du TD6

TP1 : Tri fusion en parallèle

• énoncé du TP1
• fichier triFusion.h
• fichier test-tp1.c
• Solution du TP1.

TP2 : Mémoire partagée et tubes

• énoncé du TP2 et fichier source principal
• fichier monTube.h
• fichier monTube.c
• makefile

TP3 : Simulation d'une pizzeria

• Énoncé du TP3
• fichier pizzeria.c
• fichier clients.o
• fichier synchroPizza.h
• fichier synchroPizza.c
• makefile

Résumé des entêtes des fonctions C utilisées.

• Entêtes de fonctions

Exemple d'utilisation de sémaphores nommées :

• programme ``createur.c`` qui crée un sémaphore.
• programme ``parleur.c`` qui décrémente (DOWN) un sémaphore.
• programme ``gestionnaire.c`` qui incrémente (UP) un sémphore.
• programme ``destructeur.c`` qui détruit un sémaphore.

Exemple d'utilisation de sémaphores sans-noms :

• programme ``semThread.c`` qui implémente le parleur et le gestionnaire avec des threads.

Exemple d'utilisation d'une variable de condition :

• programme ``var_cond.c``.

Deux versions du même programme. Dans les deux cas l'affichage est effectué à l'aide de la librairie ncurses. Dans le premier exemple, la synchronisation est assurée à l'aide d'un sémaphore et de deux mutex alors que dans le second utilise deux mutex et une variable de condition.

• programme ``danseursSem.c``.
• programme ``danseursCond.c``.

Version parallèle du tri rapide (quicksort). La première version utilise un "trywait" et l'attente active pour faire attendre les threads et détecter s'il reste du travail à accomplir. La deuxième version évite l'attente active en ayant recours à une variable globale indiquant si le travail est terminé. La troisième version utilise une variable de condition de manière à ce que le thread principal puisse tuer tous ces fils une fois le travail terminé.

• programme ``triRapidePar-v1.c``.
• programme ``triRapidePar-v2.c``.
• programme ``triRapidePar-v3.c``.

Trois programme très simples pour illustrer une utilisation de mémoire partagée. Le premier alloue un segment de mémoire partagée et affiche son identifiant. Les deux suivant demandent un identifiant et attachent le segment de mémoire correspondant pour ensuite y écrire (resp. lire) des nombres entrés par l'utilisateur. Finalement, le dernier programme alloue de la mémoire partagée, se l'attache puis effectue un fork. Ensuite, les deux programmes (père et fils) effectuent la même chose que mpEcritre et mpLecture.

• programme ``mpAllocation.c``.
• programme ``mpEcriture.c``.
• programme ``mpLecture.c``.
• programme ``mpFork.c``.

Exemple d'utilisation d'un tube. Le programme crée d'abord le tube puis effectue un fork. Ensuite, le père lis des nombres entrés au clavier et les inscrit dans le tube. Le fils lis les nombres inscrits dans le tube et les affiche.

• programme ``tubeFork.c``.