Mémoire partagée. Frédéric Guinand. IUT Informatique Université du Havre.

Transcription

1 IUT Informatique Université du Havre

2 Espace d adressage d un processus lors de sa création, un processus arrive avec un espace mémoire qui lui est propre lorsque ce processus créé un nouveau processus (avec un fork() par exemple), un nouvel espace d adressage est associé à ce nouveau processus, et toutes les variables du premier processus sont copiées dans ce nouvel espace. par contre, aucune variable n est commune aux deux processus

3 Motivation et solutions les processus ne partagent pas de variables il existe deux principaux mécanismes pour communiquer : via la mémoire en échangeant des messages

4 Motivation et solutions les processus ne partagent pas de variables il existe deux principaux mécanismes pour communiquer : via la mémoire en échangeant des messages partage de données via la mémoire segment de mémoire partagée

5 Motivation et solutions les processus ne partagent pas de variables il existe deux principaux mécanismes pour communiquer : via la mémoire en échangeant des messages partage de données via la mémoire segment de mémoire partagée partage de données par échange de message sockets

6 : principe le principe de la mémoire partagée consiste à définir une zone en mémoire qui soit en dehors de la zone attribuée à chaque processus, de fait, un segment est indépendant de tout processus, quelles sont les questions à se poser pour définir cette zone?

7 intense moment de réflexion...

8 Questions 1 comment les autres processus vont-ils pouvoir accéder à cette zone? 2 de combien d octets vais-je avoir besoin? 3 avec quels droits (lecture/écriture) chaque processus peut-il accéder au segment?

9 Questions 1 comment les autres processus vont-ils pouvoir accéder à cette zone? on utilise une clef 2 de combien d octets vais-je avoir besoin? il faut indiquer la taille 3 avec quels droits (lecture/écriture) chaque processus peut-il accéder au segment? au moment de la création, il faut préciser les options de création

10 : principe lorsqu un processus créé un segment de mémoire partagée, il fait appel à une primitive de création idf = shmget(clef, taille, options de création) l appel déclenche la réservation d une zone de taille octets quelque part dans la mémoire

11 inclusion de sys/shm.h Création : shmget(clef, taille, options) la clef clef statique IPC_PRIVATE ftok() la taille est en octets : une variable simple un tableau une structure options de création : lecture et/ou écriture système de droit des fichiers Unix : 0666, 0400, etc. SHM_W, SHM_R, SHM_RDONLY création [exclusive] : IPC_CREAT [IPC_EXCL]

12 un premier bout de code avec une clef statique : 5555 un segment de la taille d un entier création et ouverture en lecture et écriture

13 un premier bout de code avec une clef statique : 5555 shmget(5555,, ) ; un segment de la taille d un entier création et ouverture en lecture et écriture

14 un premier bout de code avec une clef statique : 5555 shmget(5555,, ) ; un segment de la taille d un entier shmget(5555,sizeof(int), ) ; création et ouverture en lecture et écriture

15 un premier bout de code avec une clef statique : 5555 shmget(5555,, ) ; un segment de la taille d un entier shmget(5555,sizeof(int), ) ; création et ouverture en lecture et écriture shmget(5555,sizeof(int),ipc_creat) ;

16 un premier bout de code avec une clef statique : 5555 shmget(5555,, ) ; un segment de la taille d un entier shmget(5555,sizeof(int), ) ; création et ouverture en lecture et écriture shmget(5555,sizeof(int),0666 IPC_CREAT) ;

17 un premier bout de code #include<sys/shm.h>... int clef = 5555 ; int idf ; idf = shmget(clef, sizeof(int),0666 IPC_CREAT) ; compilez puis exécutez le programme. A la fin de l exécution, tapez ipcs vous pouvez supprimer le segment avec ipcrm -m ID où ID est l un des champs de votre segment retournés par ipcs

18 : principe (2) pour que le processus puisse accéder à cette zone il faut que l adresse du segment de mémoire partagée soit liée à son propre espace d adressage, c est l étape d attachement cet attachement se comporte comme un malloc et retourne une adresse, une fois l attachement réalisé, le processus peut accéder à la zone

19 inclusion de sys/shm.h Attachement : shmat(idf, adresse, options) idf : identifiant du segment retourné par shmget() adresse : NULL (on laisse le système choisir lui-même l adresse) options : on peut l attacher en lecture seule SHM_RDONLY ou simplement laisser 0 Détachement : shmdt(adr) à la fin du traitement, le processus peut demander à être détaché du segment adr : adresse retournée par shmat() après le détachement, le segment de mémoire partagée persiste en mémoire

20 #include<sys/shm.h>... int clef = 5555 ; int idf ; int *adresse ; un p tit bout de code idf = shmget(clef, sizeof(int),0666 IPC_CREAT) ; adresse = shmat(idf,null,0) ; *adresse = rand()%100 ; printf("valeur de adresse : %d \n", *adresse) ; shmdt(adresse) ; compilez puis exécutez le programme. A la fin de l exécution, tapez ipcs

21 Détachement après le détachement, le segment de mémoire partagée persiste en mémoire pour le vérifier, nous allons écrire un programme : création d un segment de mémoire partagée constitué d un entier en lecture et écriture attachement ajout de 1 à l entier détachement et fin du programme on lance le programme plusieurs fois de suite et on constate...

22 #include<sys/shm.h>... int clef = 5555 ; int idf ; int *adresse ; un p tit bout de code idf = shmget(clef, sizeof(int),0666 IPC_CREAT) ; adresse = shmat(idf,null,0) ; *adresse = *adresse+1 ; printf("valeur de adresse : %d \n", *adresse) ; shmdt(adresse) ; compilez puis exécutez plusieurs fois le programme. A la fin de l exécution, tapez ipcs que constatez-vous?

23 un p tit bout de code vous pouvez constater que la valeur augmente de 1 à chaque nouvelle exécution, ce qui signifie que le segment est totalement indépendant des processus et peut persister en mémoire indépendamment de l exécution de processus qui le manipulent.

24 Création exclusive on peut souhaiter éviter ce type de comportement et faire en sorte que le segment créé soit "tout neuf" dans ce cas, on ajoute IPC_EXCL aux options de création

25 un p tit bout de code int clef = 5555 ; int idf ; int *adresse ; idf = shmget(clef, sizeof(int),0666 IPC_CREAT IPC_EXCL) ; adresse = shmat(idf,null,0) ; *adresse = 12 ; printf("valeur de adresse : %d \n", *adresse) ; shmdt(adresse) ; compilez puis exécutez le programme. A la fin de l exécution, tapez ipcs vous pouvez constater que le segment persiste. Relancez l exécution du programme, que constatez-vous? Qu en déduisez-vous quant à l utilité de IPC_EXCL?

26 Suppression d un segment plutôt que de supprimer le segment à la main via le terminal, il est possible de la supprimer directement par programme il suffit d utiliser la primitive shmctl() shmctl(idf, IPC_RMID, NULL) ; Informations sur les IPC la primitive shmctl() permet d agir et d obtenir des informations sur les IPC et notamment sur les segments de mémoire partagée Synopsis : shmctl(int idf, int cmd, struct shmid_ds *toto) ; permet de détruire un segment, d obtenir des informations sur le processus créateur, sur la date de la dernière modification, du dernier attachement/détachement, etc. pour voir l ensemble des possibilités man shmctl attention : beaucoup d éléments spécifiques à Linux

27 utilisation de plusieurs processus

28 C est l histoire de deux processus qui souhaitent partager un entier. le premier créé et incrémente la valeur de l entier et le second lit la valeur. Algorithme (1/2) un processus (appelons-le père), créé un segment de mémoire partagée constitué d un entier attachement du père au segment le père initialise l entier à 1 le père créé un autre processus (appelons-le fils) avec un fork()

29 Algorithme (2/2) activités du fils : récupération de l identifiant du segment attachement lecture et affichage de l entier, dans une boucle jusqu à N (un nombre de votre choix) détachement et fin du fils activités du père : incrémente et affiche l entier, dans une boucle jusqu à N détachement attente de la fin du fils et fin du père

30 Observations qu observez-vous? si le père (resp. le fils) fait son travail d une traite avant que le fils (resp. le père) n ait le temps de commencer, ajoutez un délai aléatoire à chaque tour de boucle : int delai = rand()%3 sleep(delai) ; qu observez-vous? modifiez le programme de telle sorte que père et fils exécutent une boucle infinie dans laquelle le père incrémente l entier et le fils le décrémente de 1 (affichage par le père et par le fils de la valeur de l entier).

31 Seconde expérience Algorithme du père création d un segment tableau de N entiers attachement initialisation par des valeurs allant de 1 à N affichage du tableau création du fils (par un fork() permutation d un grand nombre de fois des éléments du tableau affichage du tableau détachement attente de la terminaison du fils

32 Seconde expérience Algorithme du fils récupération de l identifiant du segment attachement lecture et affichage du tableau lecture et affichage du tableau (une seconde fois) détachement puis fin compilez puis exécutez ce code, que constatez-vous? pouvez-vous en donner une explication?

33 réguler les accès : les sémaphores

34 Principe un sémaphore permet de délimiter une zone de code appelée section critique qui ne peut être accédée que par un processus à la fois le principe est simple, avant de rentrer dans la section critique un processus fait appel à une primitive d accès. Si la section est disponible, il rentre dans la section et effectue son traitement puis en sortant de la section critique il la libère. pendant tout le temps durant lequel le processus est dans la section critique, si un autre processus essaie d y accéder, il sera bloqué par la primitive d accès.

35 Principe un sémaphore est donc un mécanisme qui permet de synchroniser les processus, un sémaphore S est associé à une valeur entière semval positive ou nulle, lorsque cette valeur est positive, le processus peut accéder à la zone protégée par le sémaphore, lorsque cette valeur est nulle, un tel accès n est pas possible, le processus est bloqué en attendant que la valeur soit strictement positive, deux opérations sont donc définies P(S) et V(S), la première pour accéder à la ressource et la seconde pour la libérer les opérations atomiques de Dijkstra

36 Primitive P(S) Si semval = 0 alors le processus est en attente Sinon semval semval-1 suite du traitement par le processus finsi Primitive V(S) semval semval+1 débloquer le premier processus en attente

37 Mise en oeuvre de sémaphores 1 création du sémaphore 2 initialisation du sémaphore 3 modification de semval en fonction des accès des processus (correspondant aux opérations P(S) et V(S)) 4 gestion et contrôle des sémaphores (obtention d informations, destruction, etc.)

38 Mise en oeuvre de sémaphores 1 création du sémaphore semget() 2 initialisation du sémaphore semctl() 3 modification de semval en fonction des accès des processus semop() 4 gestion et contrôle des sémaphores semctl()

39 Création d un sémaphore primitive de création très proche des segments de mémoire partagée idfsem = semget(clef, nb_sem, options) ; clef est un entier nb_sem est le nombre de sémaphores que l on souhaite créer (1 nous ira très bien) options : comme pour le segment IPC_CREAT 0666 pour une création/ouverture en lecture et écriture ajoutez <sys/sem.h>, <sys/ipc.h> et <sys/types.h> aux includes Allez-y

40 Création d un sémaphore tapez la commande ipcs dans un terminal le sémaphore que vous avez créé doit apparaître pour le supprimer : ipcrm -s identifiant du sémaphore (65536 dans mon cas) T ID KEY MODE OWNER GROUP Semaphores : s x00001a0a ra-ra-ra- guinand staff

41 T ID KEY MODE OWNER GROUP Semaphores : s x00001a0a ra-ra-ra- guinand staff Destruction d un sémaphore pour supprimer un sémaphore : semctl(idf_semaphore,0,ipc_rmid,0) ; T ID KEY MODE OWNER GROUP Semaphores :

42 Initialisation du sémaphore on utilise semctl semctl(idf_sem,n,cmd,arg) ; idf_sem est l identifiant du sémaphore retourné par semget() n est le numéro du sémaphore lorsque plusieurs sémaphores ont été créé. Durant le cours nous n en utiliserons généralement qu un 0 cmd est la commande associée à semctl(). Il peut s agit d une destruction IPC_RMID ou du changement de la valeur du sémaphore SETVAL arg, il s agit des arguments qui accompagnent la commande. Pour SETVAL c est un nombre 1 semctl(idfsem,0,setval,1) ;

43 modification du sémaphore pour modifier la valeur du sémaphore, nous avons deux opérations, l incrémentation et la décrémentation, sachant que la valeur ne peut pas être négative la commande est semop(int idf, struct sembuf *op, unsigned int nb_op int idf : identifiant des sémaphores struct sembuf *op : pointeur vers un tableau qui décrit les opérations unsigned int nb_op : nombre d opérations à effectuer (correspond aux opérations contenues dans le tableau)

44 la structure sembuf l identifiant retourné par semget() peut concerner plusieurs sémaphores donc dans semop() il faut spécifier celui dont il s agit, mais il faut également spécifier l opération que l on souhaite effectuer (incrément ou décrément, ou autre) on utilise une structure struct sembuf { u_short sem_num ; /* semaphore # */ short sem_op ; /* semaphore operation */ short sem_flg ; /* operation flags */ } ;

45 pour effectuer une opération, on donne une valeur à chaque champ struct sembuf toto ; toto.sem_num = 0 ; /* premier sémaphore */ toto.sem_op = 1 ; /* incrémentation */ toto.sem_flg = 0 ; /* */

46 Primitive P() void P(int idfsem) { struct sembuf data ; data.sem_num = 0 ; // premier sémaphore du groupe data.sem_op = -1 ; // on décrémente data.sem_flg = 0 ; // pas de flags semop(idfsem, &data, 1) ; }

47 Primitive V() void V(int idfsem) { struct sembuf data ; data.sem_num = 0 ; // premier sémaphore du groupe data.sem_op = 1 ; // on incrémente data.sem_flg = 0 ; // pas de flags semop(idfsem, &data, 1) ; }

48 A votre tour en utilisant les primitives P() et V() reprenez l exercice avec les segments de mémoire partagée et faites en sorte que le fils lise les nombres produits par le père une et une seule fois reste un problème : comment faire pour que le père sache que le fils a lu effectivement la valeur produite? Une manière de faire est que le fils remette la valeur à 0

49 Affichage du fils fils : valeurs déjà lue fils : 1 fils : valeurs déjà lue fils : 2 fils : 3 fils : valeurs déjà lue fils : 4 fils : valeurs déjà lue fils : 5 fils : 6 fils : valeurs déjà lue fils : valeurs déjà lue fils : 7 fils : 8 fils : 9

50 Affichage du père père : j ai écrit la valeur 1 père : j ai écrit la valeur 2 le fils n a toujours pas lu la valeur père : j ai écrit la valeur 3 père : j ai écrit la valeur 4 père : j ai écrit la valeur 5 père : j ai écrit la valeur 6 père : j ai écrit la valeur 7 le fils n a toujours pas lu la valeur père : j ai écrit la valeur 8 le fils n a toujours pas lu la valeur père : j ai écrit la valeur 9

51 Autre application : la chaîne un programme créé n processus en boucle infinie, il ne peut y avoir plus de 1 élément dans la boîte il ne peut y avoir moins que 0 élément dans la boîte.

52 Le dîner des philosophes 5 philosophes sont à table entre chaque philosophe il y a une fourchette pour manger un philosophe a besoin de deux fourchettes simultanément au cours de leurs rencontres les philosophes, débattent, mangent puis dorment puis débattent, etc. au moins dix fois chacun donnez un algorithme en utilisant les primitives P() et V() qui permette de faire en sorte que la rencontre se passe bien