Vous êtes sur la page 1sur 4

Istitut Supérieur d’Informatique et de Mathématiques de Monastir

Ens.: M.T. Bennani Travaux pratiques en systèmes temps réels Année : 2010-2011

TP N0 - Communication interprocessus (Processus léger et sémaphores)

Nom & Prénom :

Ce second TP est dédié à l’introduction de la communication entre les processus. Un intérêt


particulier sera apporté à l’utilisation des sémaphores. Aussi, les processus légers (i.e. threads)
seront utilisés pour mettre en œuvre cette communication.

1. Introduction de la bibliothèque ”semaphore.h” de POSIX


Le tableau1 ci-dessous présente un résumé du contenu de la bibliothèque ”semaphore.h”. Toutes

Nom du fichier ”semaphore.h”


Type de la donnée sem t
Initialisation int sem init(sem t *sem, int ppartage, unsigned valeur);
int sem destroy(sem t *sem);
Opérations int sem wait(sem t *sem);
Semaphore int sem post(sem t *sem);
int sem trywait(sem t *sem);
Compilation cc nomFichier.c -o nomExec -lrt

Table 1: Résumé du fichier ”semaphore.h”

les fonctions ci-dessus retournent ”-1” pour indiquer une erreur.


La fonction ”sem init” initialise le sémaphore avec la valeur contenue dans le paramètre
”valeur”. Ce parapmètre ne peut pas être négatif. Si la valeur du paramètre ”ppartage” n’est
pas 0, le semaphore peut être partagé par plusieurs processus (i.e. le processus qui l’initialise
et ses fils). Sinon, il ne peut être utilisé que par les processus léger associés au processus qui
l’a initialisé.
La fonction ”sem wait” vérifie la valeur du sémaphore. Si elle est égale à 0, elle bloque le
processus demandeur et décrémente la valeur.
”sem trywait” est similaire à la fonction précédente sauf qu’au lieu de bloquer le processus
lorsqu’elle décrémente une valeur égale à 0, elle retourne -1.
”sem post” permet d’incrémenter le sémaphore et de libérer un processus bloqué dans le cas
où la valeur est positive.
Remarque :
La création d’un processus léger (i.e. thread ) se fait par l’appel à la fonction :
”int pthread create(pthread t *tid,
const prthread attr t *tattr,
void*(*routine dem)(void*),
void *arg)”
de la bibiliothèque ”pthread.h”.
Le premier paramètre peremet de préciser le nom du processus léger. Le second paramètre
peremt de préciser les attributs d’un thread, par exemple, sa priorité, la taille de sa pile, etc.
Le troisième paramètre fixe le traitement associé au thread, c’est un pointeur de fonction. Le
dernier paramètre est passé au pointeur de fonction comme premier argument.
TPs en systèmes temps réels TP0 Année universitaire : 2010-2011

2. Utilisation des processus légers


Soit le programme du listing1 suivant :

Listing 1: processusLegers.c
1 #include <s t d i o . h>
#include < s t d l i b . h>
3 #include <pt h r e a d . h>

/∗ V a r i a b l e s g l o b a l e s ∗/
5 int x = 0 ;

/∗ F onc t ion a a s s o c i e r au t h r e a d ∗/
7 void ∗ m a f o n c t i o n ( void ∗ a r g )

{
9 p r i n t f ( ” Xthread = %d\n” , x ) ;
}
11 int main ( ) {

pthread t thread ;
13 i f ( p t h r e a d c r e a t e (& thread , NULL, m a f o n c t i o n , NULL) < 0 ) {
p e r r o r ( ” E r r e u r : l e t h r e a d n ’ e s t pas c r e e e ” ) ;
15 e x i t ( 1 ) ;

}
17 /∗ r e a l i s a t i o n d ’ un t r a i t e m e n t ∗/
x = 55;
19 p r i n t f ( ”Xmain = %d\n” , x ) ;

return ( 0 ) ;
21 }

(a) Compiler le programme et donner le résultat de son exécution.


(b) Mettre l’instruction suivante à la ligne 20 du listing1 :
”ptread join(thread,NULL);”.
Quel est le résultat de l’exécution du programme ?
(c) Refaire la même chose que dans la question précédente en mettant ”ptread join” à ligne
17 du listing1. Quel est le résultat de l’exécution du programme ?
(d) Interpréter le résultat des trois questions précédentes et préciser le rôle de la fonction
”ptread join”.

3. Création de plusieurs processus légers


Soit la fonction du listing2 suivant :

Listing 2: multiLeger.c
1 void ∗ maFonction2 ( void ∗ a r g ) {
int i ;
3 fo r ( i = 0 ; i < 5 ; i ++) {
p r i n t f ( ” Thread %s : %d\n” , ( char ∗ ) arg , i ) ;
5 sleep (1);
}
7 pthread exit (0);
}

Page 2
TPs en systèmes temps réels TP0 Année universitaire : 2010-2011

(a) Proposer un programme qui permet de retourner le résultat suivant :


Thread 1: 0
Thread 2: 0
Thread 1: 1
Thread 2: 1
Thread 1: 2
Thread 2: 2
Thread 1: 3
Thread 2: 3
Thread 1: 4
Thread 2: 4
4. Utilisation des sémaphores
Soit le code du listing3 suivant :
Listing 3: sem1.c
#include <s t d i o . h>
2 #include < s t d l i b . h>
#include <pt h r e a d . h>
4 #include <semaphore . h>

/∗ G l o b a l v a r i a b l e s ∗/
6 int x = 0 ;

sem t sync ;
8 /∗ F onc t ion a a s s o c i e r au t h r e a d ∗/

void ∗ m a f o n c t i o n ( void ∗ a r g )
10 {

p r i n t f ( ” Xthread = %d\n” , x ) ;
12 s e m p o s t (& sync ) ;
}
14 int main ( ) {

pthread t thread ;
16 /∗ C r e a t i o n du semaphore sync i n i t i a l i s e a 0 ∗/
i f ( s e m i n i t (&sync , 0 , 0 ) == −1) {
18 p e r r o r ( ”Ne peut pas i n i t i a l i s e r l e semaphore ” ) ;
exit (2);
20 }

i f ( p t h r e a d c r e a t e (& thread , NULL, m a f o n c t i o n , NULL) < 0 ) {


22 p e r r o r ( ” E r r e u r : l e t h r e a d n ’ e s t pas c r e e e ” ) ;
exit (1);
24 }

sem wait (& sync ) ;


26 /∗ r e a l i s a t i o n d ’ un t r a i t e m e n t ∗/
x = 55;
28 p r i n t f ( ”Xmain = %d\n” , x ) ;

/∗ d e s t r u c t i o n du semaphore sync ∗/
30 s e m d e s t r o y (& sync ) ;

return ( 0 ) ; }

Page 3
TPs en systèmes temps réels TP0 Année universitaire : 2010-2011

(a) Quel est le résultat de l’exécution du code du listing3 ?


(b) Changer le code du listing3 pour que le programme principal réalise son traitement en
premier lieu.
(c) Réaliser l’exércice numéro 2 de la série de TD2.

Page 4