Vous êtes sur la page 1sur 55

Mcanismes de

communication et de
synchronisation
Introduction
une application temps rel est typiquement constitue de
plusieurs tches excutes de faon concurrente
ces tches ne sont pas indpendantes
besoin d'changer des donnes
besoin de synchroniser les moments o les donnes sont
changes

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 2
Introduction
outils de coordination
famille des smaphores
smaphores binaire et comptage
spinlocks
mutexes
variables conditionnelles
famille des signaux
signaux POSIX.1
vnements POSIX.4
outils de communication
famille des files de messages
files de messages
pipes
FIFOs
mmoire partage

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 3
Outils de coordination
but : protger laccs des variables partages dans un
environnement avec premption
exemple : gestion dun stock
un thread lit dans un registre la valeur courante V0 du stock
et la dcrmente
un autre thread prempte le premier avant, lit la valeur
courante (toujours V0) , la dcrmente et met jour le
registre qui contient alors V0-1
le premier thread reprend son excution et met jour le
registre en crivant V0-1, au lieu de V0-2

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 4
Les diffrents types de smaphores
smaphores binaires
valeur : 0 ou 1
Acqurir
(valeur = 0)

valeur Disponible Indisponible valeur


initiale =
1
initiale = 0
(Available) (Unavailable)

Relcher
(valeur = 1)
ressource globale sans notion de proprit
peut tre relch par une tche quelconque, mme si elle
n'en n'a pas fait l'acquisition

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 5
Les diffrents types de smaphores
smaphores compte
valeur initiale positive ou nulle
dcrmente chaque fois que l'acquisition est accorde,
incrmente quand le smaphore est relch
quand la valeur devient nulle, la demande d'acquisition est
bloquante
ressource globale

Acqurir Acqurir
(valeur = valeur - 1) (valeur = 0)

valeur Disponible Indisponible valeur


initiale > 0 (Available) (Unavailable)
initiale = 0

Relcher
(valeur = valeur + 1) Relcher
(valeur = 1)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 6
Les diffrents types de smaphores
mutex
smaphores binaires amliors
amliorations autour des notions de proprit, de verrouillage
rcursif, de protection contre la destruction et les inversions
de priorit
l'implmentation des amliorations est facultative
les dtails d'implmentation peuvent varier

Acqurir Acqurir (rcursif)


(valeur = 1) (valeur = valeur + 1)

valeur Dverrouill Verrouill


initiale = 0 (Unlocked) (Locked)

Relcher (rcursif)
Relcher (valeur = valeur - 1)
(valeur = 0)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 7
Les diffrents types de smaphores
notion de proprit d'un mutex
la tche qui a fait l'acquisition d'un mutex en est propritaire.
Elle seule peut le relcher
comparer aux smaphores
verrouillage rcursif
la tche qui possde le mutex peut en redemander
l'acquisition
permet de rsoudre des problmes de deadlocks potentiels
entre routines d'une mme tche
protection contre la destruction
la tche qui possde un mutex est protge contre la
destruction par une autre tche
problmes lis l'inversion de priorit
quand une tche de haute priorit attend l'accs une
ressource possde par une tche de basse priorit

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 8
Smaphores POSIX.4
cration
destruction
acquisition
libration
libration de toutes les tches en attente (flush)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 9
Smaphores POSIX.4
smaphores
#include<semaphore.h>
existent sous deux formes :
smaphores nomms
smaphores bass sur la mmoire
smaphores nomms
mcanisme de gestion analogue celui d'un systme de
fichiers
smaphores bass sur la mmoire
granularit plus fine que les smaphores nomms
gestion plus complexe

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 10
Smaphores POSIX.4
smaphores nomms
sem_tsem_open(constchar*sem_name,
intoflags,mode_tcreation_mode,
unsignedintinitial_val);
cre le smaphore
il est recommand de fournir un nom "compatible" avec un
nom de fichier, et commenant par un un "/", et n'en
contenant pas d'autre
oflags rfre aux protections en lecture/criture, ou la
volont de crer un nouveau smaphore (O_CREAT et
O_EXCL)
intsem_close(sem_t*sem_id);
intsem_unlink(constchar*sem_name);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 11
Smaphores POSIX.4
smaphores bass sur la mmoire
intsem_init(sem_tsem_location,intpshared,
unsigned_intinitial_value);
crelesmaphore
sem_location est une place mmoire, ventuellement en

zone partage
pshared indique la visibilit des smaphores (un ou plusieurs

processes)
intsem_destroy(sem_tsem_location);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 12
Smaphores POSIX.4
oprations sur les smaphores
mmes primitives pour les deux types de smaphores
intsem_post(sem_t*sem_id);
intsem_wait(sem_t*sem_id);
intsem_trywait(sem_t*sem_id);
intsem_getvalue(sem_tsem_id,int*value);
les problmes lis des inversions de priorit sont pris en
compte par le systme d'exploitation si la constante
_POSIX_PRIORITY_SCHEDULING est vraie
(/usr/include/unistd.h)
une opration sem_wait effectue dans un thread
Xenomai en mode secondaire le fait passer en mode
primaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 13
Mutexes
les proprits du mutex sont dcrites par des attributs
cration/destruction des attributs
intpthread_mutexattr_init(pthread_mutexattr_t*attr);
intpthread_mutexattr_destroy(pthread_mutexattr_t*attr);
les attributs sont ensuite modifis par des primitives
intpthread_mutexattr_settype(pthread_mutexattr_t*attr,
inttype);
intpthread_mutexattr_setprotocol(pthread_mutexattr_t*attr,
intprotocol);
intpthread_mutexattr_setpshared(pthread_mutexattr_t*attr,
intpshared);
les valeurs des attributs peuvent tre rcupres par
intpthread_mutexattr_gettype(pthread_mutexattr_t*attr,
int*type);
intpthread_mutexattr_getprotocol(pthread_mutexattr_t*attr,
int*protocol);
intpthread_mutexattr_getpshared(pthread_mutexattr_t*attr,
int*pshared);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 14
Mutexes
types de mutexes :
PTHREAD_MUTEX_NORMAL
PTHREAD_MUTEX_ERRORCHECK
PTHREAD_MUTEX_RECURSIVE
protocoles :
PTHREAD_PRIO_NONE
PTHREAD_PRIO_INHERIT(hritagedepriorit,supportparXenomai)
PTHREAD_PRIO_PROTECT(prioritplafond,nonsupport)
partage des mutexes :
PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED
Linux ne supporte que l'attribut "type"
Xenomai supporte les 3 attributs (par dfaut
PTHREAD_MUTEX_NORMAL, PTHREAD_PRIO_NONE et
PTHREAD_PROCESS_PRIVATE)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 15
Mutexes
cration du mutex
intpthread_mutex_init(pthread_mutex_t*mutexid,
pthread_mutexattr_t*attr);
un mutex peut tre galement initialis par les initialiseurs
pthread_mutex_tfmutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_trmutex=PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_mutex_temutex=PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
non support par Xenomai
destruction du mutex
intpthread_mutex_destroy(pthread_mutex_t*mutexid,);
ne peut se faire que sur un mutex libre (EBUSY)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 16
Mutexes
oprations sur les mutex
intpthread_mutex_lock(pthread_mutex_t*mutexid);
intpthread_mutex_trylock(pthread_mutex_t*mutexid);
intpthread_mutex_unlock(pthread_mutex_t*mutexid);
intpthread_mutex_timedlock(pthread_mutes_tmutexid,
conststruct*abstime);
pthread_mutex_lock nest pas un point dannulation
en cas dappel multiple pthread_mutex_lock par le mme
thread
pour un mutex normal on est en situation de deadlock
si le verrouillage est rcursif, il faut autant de unlock que de lock
si on a un mutex de diagnostic (PTHREAD_MUTEX_ERRORCHECK),
retour dun erreur (EDEADLOCK)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 17
Mutexes et Xenomai
quand une opration sur les mutexes (tentatives de lock
ou unlock) est effectue sur un thread Xenomai en mode
secondaire, il est automatiquement transform en mode
primaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 18
Barrires
Mcanisme simple d'attente d'un nombre prdfini de threads
initialisation d'une barrire en spcifiant le nombre de

threads qui doivent tre en attente avant que la barrire soit


leve
pthread_barrier_tbarriere;
pthread_barrier_init(&barriere,NULL,NB_THREADS);
les threads qiu appellent pthread_barrier_wait sont bloqus
jusqu' ce qu'il y ait NB_THREADS threads en attente
pthread_barrier_wait(&barriere);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 19
Variables conditions
synchronisation des threads sur la satisfaction d'une
condition : la vrification d'un prdicat sur une donne
partage
deux oprations de base pour les threads participants :
signaler la condition, quand le prdicat est vrifi
attendre la condition (le thread est bloqu jusqu' ce qu'un
autre thread signale la condition)
toutes les oprations se font sous la protection d'un mutex
pour viter une situation de comptition (race condition)
entre les threads qui attendent la condition et ceux qui la
signalent

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 20
Variables conditions
les proprits sont dcrites par des attributs
initialisation/destruction des attributs
intpthread_condattr_init(pthread_condattr_t*attr);
intpthread_condattr_destroy(pthread_condattr_t*attr);
les attributs sont modifis par les primitives
intpthread_condattr_setclock(pthread_condattr_tattr,
clockid_tclk_id);
dfinit lhorloge utilise pour pthread_cond_timedwait
intpthread_condattr_setpshared(pthread_condattr_tattr,
intpshared);
variable condition accessible seulement aux threads du
process (PTHREAD_PROCESS_PRIVATE) ou tous
(PTHREAD_PROCESS_SHARED)
les valeurs des attributs peuvent tre rcupres par
intpthread_condattr_getclock(pthread_condattr_tattr,
clockid_t*clk_id);
intpthread_condattr_getpshared(pthread_condattr_tattr,
int*pshared);
seul Xenomai supporte ces attributs (pas Linux)
F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 21
Variables conditions
cration
intpthread_cond_init(pthread_cond_t*cond,
pthread_condattr_t*attr);

pthread_cond_tcond=PTHREAD_COND_INITIALIZER;
(non support par Xenomai)
destruction
intpthread_cond_destroy(pthread_cond_t*cond);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 22
Variables conditions
utilisation des variables conditions
la variable conditionnelle est un outil pour signaler la
satisfaction de la condition
l'attente doit se faire sous la protection d'un mutex
intpthread_cond_wait(pthread_cond_t*cond,
pthread_mutex_t*mutex);
intpthread_cond_timedwait(pthread_cond_t*cond,
pthread_mutex_t*mutex,
conststructtimespec*abstime);
l'appel est bloquant et le mutex est automatiquement
relch de faon atomique

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 23
Variables conditions
utilisation des variables conditions
la signalisation que la condition est satisfaite se fait
galement sous la protection du mutex
intpthread_cond_signal(pthread_cond_t*cond);
intpthread_cond_broadcast(
pthread_cond_t*cond);
le signal est fugace : il n'est pas mmoris et une condition
signale ne sera pas prise en compte par un thread qui se
mettrait en attente aprs le signalement
il faut librer le mutex aprs le signalement. Les threads en
attente du mutex entrent alors en comptition pour le
prendre

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 24
Variables conditions
Thread attendant la condition Thread signalant la condition
appel de pthread_mutex_lock() : blocage du
mutex associ la condition
test de la non satisfaction de la condition
appel de pthread_cond_wait() : dblocage du
mutex
attente...
appel de pthread_mutex_lock ()
modification/test de la condition
appel de pthread_cond_signal() : rveil du
thread en attente
dans pthread_cond_wait() : tentative de
rcupration du mutex
appel de pthread_mutex_unlock() :
dblocage du thread en attente
fin de pthread_cond_wait()
appel de pthread_mutex_unlock() : retour la
situation initiale
F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 25
Variables conditions et Xenomai
quand une opration sur les variables conditions
(tentatives d'attente ou de signalisation) est effectue sur
un thread Xenomai en mode secondaire, il est
automatiquement transform en mode primaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 26
Exemple (1)
#include<stdio.h>
#include<pthread.h>

#defineNUM_THREADS3
#defineTCOUNT10
#defineCOUNT_THRES12
intcount=0;
intthread_ids[3]={0,1,2};
pthread_mutex_tcount_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_tcount_hit_threshold=PTHREAD_COND_INITIALIZER;

main(void)
{
inti;
pthread_tthreads[3];

pthread_create(&threads[0],NULL,inc_count,(void*)&thread_ids[0]);
pthread_create(&threads[1],NULL,inc_count,(void*)&thread_ids[1]);
pthread_create(&threads[2],NULL,watch_count,(void*)&thread_ids[2]);

for(i=0;i<NUM_THREADS;i++){
pthread_join(threads[i],NULL);
}

return0;
}
F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 27
Exemple (2)
void*watch_count(void*idp)
{
inti=0;
int*my_id=idp;

printf("watch_count():thread%d\n",*my_id);

pthread_mutex_lock(&count_lock);

while(count<COUNT_THRES){
pthread_cond_wait(&count_hit_threshold,&count_lock);
printf("watch_count():thread%d,count%d\n",*my_id,count);
}

pthread_mutex_unlock(&count_lock);

return(NULL);
}

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 28
Exemple (3)
void*inc_count(void*idp)
{
inti=0;
int*my_id=idp;

for(i=0;i<TCOUNT;i++){
pthread_mutex_lock(&count_lock);
count++;
printf("inc_counter():thread%d,count=%d,unlockingmutex\n",
*my_id,count);
if(count==COUNT_THRES){
printf("inc_count():Thread%d,count%d\n",*my_id,count);
pthread_cond_signal(&count_hit_threshold);
}
pthread_mutex_unlock(&count_lock);
}

return(NULL);
}

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 29
spinlocks
dans le cas de programmation noyau et que le temps
d'attente de la ressource est court
un smaphore classique serait trs inefficace
attente active (ne relche pas la CPU)
utile uniquement dans un environnement multiprocesseur
primitives :
intpthread_spin_init(pthread_spinlock_t*lock,
intpshared);
intpthread_spin_destroy(pthread_spinlock_t*lock);
intpthread_spin_lock(pthread_spinlock_t*lock);
intpthread_spin_trylock(pthread_spinlock_t*lock);
intpthread_spin_unlock(pthread_spinlock_t*lock);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 30
Quelques fonctions utiles
excution unique d'une fonction : pthread_once
quand plusieurs threads instancient une mme fonction
(code), il peut arriver que l'on veuille qu'un seul de ces
threads excute une fonction particulire du code
par exemple ouvrir un fichier, ou initialiser un mutex
il n'est pas toujours possible de le faire avant la cration
des threads (dans la fonction main, par exemple)
le mcanisme propos par pthread_once permet
d'implmenter ceci trs facilement de faon atomique
initialisation d'une variable de type pthread_once_t
pthread_once_tvar=PTHREAD_ONCE_INIT
excution de func par le premier thread qui parvient
l'instruction pthread_once(&var,func)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 31
Quelques fonctions utiles
exemple
pthread_once_tvariable_decontrole=PTHREAD_ONCE_INIT;
pthread_mutex_tmutex;
pthread_ttid[10];
voidinitialisation_mutex(){
/*fonctionspourinitialiserlesystme*/
pthread_mutex_init(&mutex,NULL);
...
}
voidcorps_du_thread(){
...
pthread_once(&variable_de_controle,initialisation_mutex);
...
}
main(){
inti;
...
for(i=0,i<10,i++){
pthread_create(tid[i],NULL,corps_du_thread,);
}
...
}

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 32
Quelques fonctions utiles
donnes spcifiques des threads
pour stocker de faon permanente des donnes spcifiques
chaque thread
pas facile de prvoir des variables globales spcifiques
associes chacune des instances d'un thread si on peut ne
pas connatre priori le nombre d'instances qui vont
s'excuter
par exemple si on veut compter combien de fois chaque
thread va demander l'acquisition d'un mutex
on va associer la donne spcifique une cl qui sera
ensuite utilise pour accder la donne
cration d'une cl :
pthread_key_create(pthread_key_tkey_id,
void(*destr(void*));

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 33
Quelques fonctions utiles
association d'une donne la cl
pthread_setspecific(pthread_key_tkey_id,
constvoid*data);
accs une donne
void*pthread_getspecific(pthread_key_t)
retourne un pointeur sur la donne spcifique du thread
associe la cl
destructeur
le mcanisme de rfrence par cl fait appel des pointeurs
pour stocker les donnes spcifiques en mmoire, d'o un
risque potentiel de fuite
la fonction destr passe dans pthread_key_create va
tre excute la fin du thread pour pouvoir ventuellement
librer la zone mmoire occupe

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 34
outils de communication
but : change dinformations entre diffrentes tches
files de messages
mmoire partage
en utilisant ventuellement des moyens de
synchronisation
peuvent aussi servir de moyen de synchronisation
files de messages avec oprations daccs bloquantes

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 35
les files de messages
dfinition : un objet de type tampon travers lequel les
tches peuvent envoyer et recevoir des messages des
fins de communication ou de synchronisation
Mmoire
Bloc de contrle (espace systme
de la file ou priv)

QCB

nom ou
identificateur

... ...
Longueur message
maximale du
Tche 1 Tche 2 message Tche 1 Tche 2

Liste d'attente des Liste d'attente des


tches mettrices tches rceptrices
Longueur
de la queue

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 36
les files de messages
tats des files de messages
Message arriv
cration (nmsg = nmsg + 1)
de la file Message arriv
Message arriv
(nmsg = 0) (nmsg = lfile)
(nmsg = 1)

Vide Non vide Pleine

Message reu Message reu


(nmsg = 0) (nmsg = lfile - 1)
Message reu
(nmsg = nmsg - 1)

les effets lis la lecture d'une file vide ou l'criture dans


une file pleine varient selon l'implmentation
erreur
blocage

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 37
les files de messages
oprations sur les files de messages
cration
protections dfinies au moment de la conception et
uniquement sur le mode d'accs (lecture et/ou criture)
destruction
dbloquage des tches en attente
perte des messages dans la file

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 38
les files de messages
oprations sur les files de messages
criture
mode FIFO, LIFO et/ou bas sur une priorit du message
diffrentes politiques de blocage d'criture dans une file
pleine
peut dpendre de l'origine du message (tche ou ISR)
lecture
diffrentes politiques de blocage de lecture dans une file vide
politique de destruction automatique ou non du message lu
broadcast

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 39
les files de messages
oprations sur les files de messages
obtenir de l'information sur les caractristiques
modifier les caractristiques

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 40
files de messages POSIX.4
cration
mqd_tmq_open(constchar*mq_name,intoflags,
mode_tcr_mode,
structmq_attr *attr);
nom " la systme de fichier" (cf smaphores)
oflags rfre aux protections en lecture/criture, la
politique de blocage (O_NONBLOCK) ou la
volont de crer une nouvelle file (O_CREAT et
O_EXCL)
cr_mode dfinit la protection sur le nom de la file
attr contient les informations physiques de la file (nombre
maximum de messages, longueur maximum d'un
message)
un thread Xenomai primaire sera bascul en mode

secondaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 41
files de messages POSIX.4
#include<mqueue.h>
structure mq_attr
structmq_attr
{
longintmq_flags;/*Messagequeueflags.*/
longintmq_maxmsg;/*Maximumnumberofmessages.*/
longintmq_msgsize;/*Maximummessagesize.*/
longintmq_curmsgs;/*Numberofmessagescurrently
queued.*/
};
mode
#include<sys/stat.h>
protection (I_IRUSR,I_IWUSR, ...)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 42
files de messages POSIX.4
destruction
intmq_close(mqd_tmq_id);
fermeture de la file

mq_unlink(constchar*mq_name);
destruction

un thread Xenomai primaire bascule en mode secondaire


demande d'information
intmq_getattr(mqd_tmqid,
structmq_attr*attr);
modification des proprits
intmq_setattr(mqd_tmqid,
conststructmq_attr*new_attr,
structmq_attr*old_attr);
ne permet de modifier que la politique de blocage

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 43
files de messages POSIX.4
criture
intmq_send(mqd_tmqid,constchar*msgbuf,
size_tmsqsize,unsignedintprio);
diffrents niveaux de priorit pour le message, compris entre

MQ_PRIO_MAX et MQ_PRIO_MIN (dfinis dans


<linux/mqueue.h>
les messages sont insrs dans la file suivant la priorit, en

mode FIFO niveau gal de priorit


pas d'effet sur la priorit de la tche de lecture

lecture
intmq_receive(mqd_tmqid,char*msgbuf,
size_tmqsize,unsignedint*prio);
lecture du message de tte de la file (donc le plus prioritaire)

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 44
files de messages POSIX.4
il existe des versions temporises des fonctions d'criture
et de lecture
intmq_timedsend(mqd_tmqid,constchar*msgbuf,
size_tmsqsize,unsignedintprio,
constantstructtimespec*abs_timeout);
ntmq_timedreceive(mqd_tmqid,char*msgbuf,
size_tmqsize,unsignedint*prio
constantstructtimespec*abs_timeout);
un thread Xenomai secondaire basculera en mode
primaire l'appel d'une fonction de lecture ou d'criture

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 45
files de messages POSIX.4
demande de notification
intmq_notify(mqd_tmqid,
conststrucsigevent*specs);
un vnement POSIX.4 destin la tche le demandant sera

gnr automatiquement si on crit dans la file alors qu'elle est


vide
les caractristiques de l'vnement sont dcrites dans la

structure sigevent
une seule tche peut faire la demande de notification

la demande ne peut se faire que si aucun thread n'est bloqu

sur une opration de lecture sur la file


il faut "rarmer" la demande de notification aprs excution

un thread Xenomai secondaire basculera n mode primaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 46
files de messages POSIX.4
Comportement sur fork et exec
analogue celui des systmes de fichier :
file hrite au clonage par fork
file ferme sur exit et _exit
comportement diffrent sur exec :
la file est ferme (alors qu'un fichier reste ouvert). Il faut donc
refaire un appel mq_open

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 47
Mmoire partage
moyen de communication trs efficace entre tches
implment naturellement pour les threads
ne passe pas par le systme d'exploitation (donc rapide)
mais dangereux
accs concurrent une mme ressource
ncessite l'utilisation des outils de synchronisation (mutex
et/ou smaphores)
seul moyen par lequel des outils de synchronisation
anonymes de POSIX (mutexes, variables conditionnelles,
smaphores) peuvent tre partags entre des modules
excuts dans l'espace noyau et des processes
utilisateurs, ou entre des processus utilisateurs diffrents

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 48
Mmoire partage POSIX.4
complexe...
parce qu'elle utilise la possibilit de projeter en mmoire
des fichiers
mcanisme trs puissant de partage et de sauvegarde de
donnes, mme entre machines distantes (il suffit qu'elles
partagent un mme disque)
deux tapes :
ouvrir (crer) l'objet de mmoire partage (shm_open)
utiliser le descripteur retourn pour projeter cet objet dans
l'espace mmoie de la tche (mmap)
tous les appels des fonctions manipulant la mmoire
partage font basculer des threads Xenomai primaires en
mode secondaire

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 49
Mmoire partage POSIX.4
#include<sys/mman.h>
cration d'un segment de mmoire partage
intshm_open(constchar*name,intoflag,
mode_tmode);
retourne un descripteur analogue celui d'un fichier, avec les
mmes restrictions que pour les smaphores et les files de
messages
oflag et mode sont quivalents ceux utiliss par open
modification de la taille du segment
intftruncate(intfd,off_tsize);
la taille du segment est nulle la cration
ftruncate est une fonction "gnraliste" qui agit galement
sur les fichiers, pour augmenter ou diminuer la taille

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 50
Mmoire partage POSIX.4
fermeture et destruction
close(intfd);
shm_unlink(constchar*name);

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 51
Mmoire partage POSIX.4
projection de la mmoire partage
caddr_tmmap(caddr_taddr,size_tlen,intprot,
intflag,intfildes,off_toffset);
projection dans l'espace d'adressage de l'objet associ au

descripteur fildes des len octets partir du dcalage


offset
mmap permet de projeter d'autres objets que des segments de

mmoire partage (par exemple, des fichiers classiques)


addr est une proposition d'adresse. L'adresse effectivement

choisie par le systme est retourne par mmap(fd = mmap(...)


contiendra l'adresse effective)
il est recommand de prendre des multiples de PAGESIZE

pour len
intmunmap(void*addr,size_tlen);
annulation de la projection

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 52
Mmoire partage POSIX.4
projection de la mmoire partage
caddr_tmmap(caddr_taddr,size_tlen,intprot,
intflag,intfildes,off_toffset);

Mmoire

len
offset len

Stockage

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 53
Verrouillage de la mmoire
verrouillage de pages mmoire
essentiel pour les processes temps rels car la pagination
n'est pas un comportement prdictible
intmlock(const*start_addr,size_tlength);
intmlockall(inttype);
type permet de prciser quelles pages on dsire verrouiller,

en faisant un OR de
MCL_CURRENT : les pages actuellement possdes
MCL_FUTURE : les pages qui seront alloues dans le futur (y
compris la pile)
intmunlock(const*start_addr,size_tlength);
intmunlockall(void);
sous Linux, on peut verrouiller au maximum la moiti de la
mmoire totale
le verrouillage nest pas hrit au cours dun fork

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 54
Modules

F. Touchard Polytech Marseille INFO4 2016-17 Introduction aux systmes Temps Rels Communication et synchronisation inter-processes 55