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

interface de programmation Fichiers de description /usr/include/sys/shm.h /usr/include/sys/ipc.h /usr/include/sys/types.h creation du segment : shmget int shmget (mem-clef, taille, drapeau) int mem_clef int taille int 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.

Interface de programmation Attachement : shmat char * shmat (shmid, adresse, drapeau) int shmid char *adresse int 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...).

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 : shmctl int shmctl (shmid, commande, tab) int shmid int commande struct 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.

L'administrateur système dispose de commandes : 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 status 0x00000000 163844 gdm 777 196608 2 dest 0x00000000 229381 gdm 777 196608 2 dest $ ipcs -m -p ------ Shared Memory Creator/Last-op -------- shmid owner cpid lpid 163844 gdm 1227 1228 229381 gdm 1228 1222 ipcrm : pour détruire un objet laissé par un processus terminé

exemple 1 : traitement d'images main() { /* 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);

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

Sémaphores P(s) e(s) = e(s) - 1; si e(s) < 0 alors 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));

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.

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

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

Exemple Processus 1 Processus 2 Sémaphore 5 P(3) 2 P(4) 2 V(3) 5 P(4) endormi Section critique Section critique

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

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

interface de programmation création de la file de messages int 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 messages int msgctl(msqid,IPC_RMID, NULL); envoi de messages int 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é

interface de programmation réception de messages int 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 alors retour 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

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 */ }

Files de messages : exemple /* lecture message et destruction file */ #include <sys/types.h> #include <linux/ipc.h> #include <linux/msg.h> #define CLE 17 struct 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 */ }

exécution [couveep@pegtst2 os]$ ipcs -q ------ Message Queues -------- key msqid owner perms used-bytes messages [couveep@pegtst2 os]$ ./envoi 0x00000011 131072 couveep 750 19 1 [couveep@pegtst2 os]$ ./reception message lu ceci est un message

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

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"