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
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 - PowerPoint PPT Presentation
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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.
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.
• 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));
• 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 */
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);
• 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"