IPC Système V 1.1

Segments de mémoire partagée

• Les processus UNIX, même issus d'un même père, ne partagent aucune zone mémoire

– après un appel à fork(), le père et le fils ont des zones data et bss différentes

• UNIX offre un mécanisme pour créer une zone mémoire comune à plusieurs processus

• Cette zone est accédée de façon transparente, par l'utilisation de pointeurs

IPC Système V 1.2

interface de programmation

• Fichiers de description /usr/include/sys/shm.h /usr/include/sys/ipc.h /usr/include/sys/types.h

• creation du segment : shmgetint shmget (mem-clef, taille, drapeau)int mem_clef int tailleint drapeau

Shmget renvoie un descripteur local identifiant la zone mémoire associé à la clef mem-clef. Si le bit IPC_CREAT est mis à 1 dans la variable drapeau ou si la clé vaut IPC_PRIVATE, alors shmget crée et initialise une zone de mémoire partageable. Sinon, il positionne simplement l'utilisateur sur cette zone de clef mem_clef.Si IPC_PRIVATE est mis à 1, alors la zone n'est vue que par le créateur et ses descendants.

IPC Système V 1.3

Interface de programmation

• Attachement : shmat

char * shmat (shmid, adresse, drapeau)int shmid char *adresseint drapeau

Shmat renvoie un pointeur sur la zone de identifiée par shmid (ce dernier est l'entier renvoyé par shmget). Adresse est un pointeur sur caractère qui indique à quelle adresse mémoire (virtuelle) l'utilisateur veut implanter cette zone, zéro veut dire que l'on charge le système de ce travail (option conseillée...).

IPC Système V 1.4

Interface de programmation

• Detachement : shmdt

int shmdt (adresse)char *adresse

Shmdt signifie que le processus n'utilise plus la zone commune. Quand le nombre d'utilisateurs de cette zone tombe à 0, elle est restituée au système.

• Opérations de contrôle : shmctlint shmctl (shmid, commande, tab)int shmid int commandestruct shmid_ds *tab

Shmctl envoie la commande commande sur la zone shmid. Suivant la commande envoyée, cette fonction renvoie des informations dans tab, ou modifie les caractéristiques de la zone.

IPC Système V 1.5

gestion système

L'administrateur système dispose de commandes :

• ipcs : pour afficher l'état du système

$ ipcs -m------ Shared Memory Segments --------key shmid owner perms bytes nattch status0x00000000 163844 gdm 777 196608 2 dest0x00000000 229381 gdm 777 196608 2 dest

$ ipcs -m -p------ Shared Memory Creator/Last-op --------shmid owner cpid lpid163844 gdm 1227 1228229381 gdm 1228 1222

• ipcrm : pour détruire un objet laissé par un processus terminé

IPC Système V 1.6

exemple 1 : traitement d'imagesmain(){

/* créer la zone de mémoire partagée et y charger l'image */id = shmget(cle, taille_image, flag);image = shmat(id, 0, flag2);charger_image(image);

/* créer les 4 fils */for(i=0; i<4; i++){PID = fork();if(PID == 0){/* traiter image */traiter_image(image+(i*taille_image/4), taille_image/4);exit(0);}}

/* attendre les 4 fils */ for(i=0; i<4; i++) wait();

/* sauvegarder le résultat */sauvegarder_image(image);

}

IPC Système V 1.7

exemple 2

• définir une application de vente de place de spectacle à 4 guichets :

– la liste des sièges de la salle et leur état courant (libre/vendu) se trouve en mémoire partagée

– 4 processus (1 par guichet) sont créés et accèdent au plan commun

– lorsqu'une place est vendue, le processus qui effectue l'opération envoie un signal aux autres pour qu'ils rafraichissent leur écran

• Ecrire le pseudo-code de cette application

IPC Système V 1.8

Sémaphores

• Introduits par Dijkstra en 1965.

• Les sémaphores sont un outil élémentaire de synchronisation qui évite l'attente active. C'est un service noyau qui manipule l'état des processus (actif, endormi)

• Un sémaphore s =– un entier e(s) ; – une file d'attente f(s) ; – deux primitives P(s) et V(s).

• Soit p1 le processus qui effectue P(s) ou V(s) :

P(s) e(s) = e(s) - 1; si e(s) < 0 alors . état(p1) = endormi; . entrer(p1, f(endormis));

V(s) e(s) = e(s) + 1; si e(s) <= 0 alors . sortir(p2, f(s)); . état(p2) = éligible; . entrer(p2, f(éligibles));

IPC Système V 1.9

Exclusion mutuelle

• But : protéger l'accès à une ressource unique (e.g. variable, imprimante, ...).

• e(s) est initialisée à 1.

• Utilisation :

P(s)< Section Critique >V(s)

• Tous les processus doivent suivre la même règle.

IPC Système V 1.10

Sémaphores de Synchronisation

• But : un processus doit en attendre un autre pour continuer (ou commencer) son exécution.

• e(s) est initialisée à 0.

• Utilisation :

Processus 1 1er travail V(s) // réveil processus 2

Processus 2 P(s) // attente processus 1 // attente ->reveil 2ème travail

IPC Système V 1.11

généralisation

• En initialisant le sémaphore à une valeur n>1, il peut servir à gérer une ressource à n entrées

– exemple : liste de n structures de données

• l'ntéret majeur est que l'attente ne se fait pas de façon "active"

• dans ce cas, P() et V() ont 2 paramètres :– P(sem, nb) : décrémenter le sémaphore sem de nb– V(sem, nb) : incrémenter le sémaphore sem de nb

IPC Système V 1.12

Exemple

Sémaphore 5

P(3) 2 P(4) 2

V(3) 5 P(4) 1 5 V(4)

Processus 1 Processus 2

Sectioncritique

Sectioncritique

Processusendormi

IPC Système V 1.13

Instructions atomiques

• Les processeurs offrent un support matériel pour la réalisation des fonctions P() et V(), sous forme d'instructions particulières :

– ex : test_and_set(adresse) retourne vrai si adresse contient 0, faux sinon si le contenu de adresse est 0, alors le met à 1

– ex : atomic_add(adresse); atomic_sub(adresse) équivalent à load adresse, R1; add 1, R1, store R1, adresse permet de se passer de sémaphore pour des compteurs

simples

IPC Système V 1.14

Files de messages

• Il existe une troisième façon de communiquer entre processus sous UNIX : les files (ou queues) de messages

• Il s'agit d'envoyer et recevoir des messages qui pourront contenir n'importe quel type de données

– excepté les pointeurs…

• les messages sont typés : – ils commencent par un entier décrivant le type des données– ce typage est défini par le programmeur

• Les files de messages sont utilisables par plusieurs processus pour lire et écrire,

– mais il n'y a pas de mécanisme d'identification du destinataire– si nécessaire, il faut utiliser le type

IPC Système V 1.15

interface de programmation

• création de la file de messagesint identMSG = msgget(key_t clef, int options)

– Comme pour les autres mecanismes IPC, le service est identifié par une clé qui doit être unique

• destruction de la file de messagesint msgctl(msqid,IPC_RMID, NULL);

• envoi de messagesint msgsnd(int identMSG, const void *adresseMessage, int longueurMessage, int options);

• par défaut, le processus est bloqué jusqu’à ce qu'il y ait de la place dans la file ou que la file soit détruite ou sur réception d’un signal

• si options contient IPC_NOWAIT, alors il n'y a pas d'attente et un code d'erreur est retourné

IPC Système V 1.16

interface de programmation

• réception de messagesint msgrcv(int identMSG, void *adresseReception, int tailleMax, long typeM, int options);

– Si typeM==0 le premier message de n'importe quel type est extrait– Si typeM > 0 le premier message de type==typeM est extrait – Si typeM < 0 le premier message de type < typeM est extrait

• si options = IPC_NOWAIT et pas de message de type typeM alorsretour code erreur

• sinon le processus est bloqué jusqu’à l'arrivée d’un message de type typeM ou

destruction de la file ou réception d’un signal

IPC Système V 1.17

Files de messages : exemple

/* creation d une file de messages et envoi message */#include <sys/types.h>#include <linux/ipc.h>#include <linux/msg.h>#define CLE 17

struct msgbuf msgp;char *msg="ceci est un message";

main(){ int msqid; /* identificateur msq */

msqid = msgget((key_t)CLE,0750+IPC_CREAT); /* creation file */ msgp.mtype=12; /* le type */ strcpy(msgp.mtext,msg); /* copie du message */

msgsnd(msqid, &msgp, strlen(msg), IPC_NOWAIT); /* envoi message */}

IPC Système V 1.18

Files de messages : exemple/* lecture message et destruction file */#include <sys/types.h>#include <linux/ipc.h>#include <linux/msg.h>#define CLE 17struct msgbuf msgp;main(){ int msqid; int x; msqid = msgget((key_t)CLE, 0); /* recup msqid */

/* lecture type 12*/ x = msgrcv (msqid, &msgp, 19, (long)12, IPC_NOWAIT); msgp.mtext[x] = 0; /* ajouter une fin de chaine de caract. */ printf ("message lu %s\n",msgp.mtext);

msgctl(msqid,IPC_RMID, NULL); /* destruction */}

IPC Système V 1.19

exécution[couveep@pegtst2 os]$ ipcs -q

------ Message Queues --------

key msqid owner perms used-bytes messages

[couveep@pegtst2 os]$ ./envoi

[couveep@pegtst2 os]$ ipcs -q------ Message Queues --------

key msqid owner perms used-bytes messages

0x00000011 131072 couveep 750 19 1[couveep@pegtst2 os]$ ./reception

message lu ceci est un message

[couveep@pegtst2 os]$ ipcs -q

------ Message Queues --------key msqid owner perms used-bytes messages

IPC Système V 1.20

Files de message : exercice

• Refaire l'implémentation du programme de surveillance de la température du système

• la communication entre le programme d'enregistrement (qui tourne en boucle infinie) et la commande d'affichage sera implémentée par des échanges de messages

• la commande d'affichage récupérera la température et l'affichera elle même

IPC Système V 1.21

Création de clés

• Pour (tenter) de créer des clés uniques, il existe une fonction ftok():

key_t ftok (const char * nom_fichier, int num)

• cette fonction crée une clé à partir d'un nom de fichier et d'un nombre.

• La probabilité de trouver 2 clés identiques est "faible"