ipc système v 1.1 segments de mémoire partagée les processus unix, même issus d'un même...
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.
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 : shmctl
int 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 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é
IPC Système V 1.16
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
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 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 */
}
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"