EnglishCommencer

La mémoire partagée

Un segment commun à plusieurs processus avec shm_open, ftruncate, mmap en MAP_SHARED, munmap et shm_unlink, l'absence de synchronisation et le sémaphore, puis le choix entre tube, signal et mémoire partagée.

  • 24 cartes
  • 4 thèmes
  • Gratuit
Réviser ce deck

Le programme, thème par thème

Le poids de chaque thème suit celui que lui donne l'examen.

  1. Notions
  2. Questions
  3. Ranger et relier
  4. Mises en situation

Quelques cartes du deck

  • Mémoire partagée : de quoi s'agit-il ?

    Voir la réponse

    Zone que plusieurs processus projettent dans leur espace d'adressage : ce que l'un y écrit, les autres le voient, sans copie faite par le noyau.

    C'est le moyen de communication le plus rapide entre processus d'une même machine. Mais le système n'y met aucune règle : c'est aux programmes de se coordonner.

  • Que valent a et *p affichés par le père, tous deux partis de 0 ?

    ```c
    int a = 0;
    int *p = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE,
    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    *p = 0;
    if (fork() == 0) { a = 7; *p = 7; _exit(0); }
    wait(NULL);
    printf("%d %d\n", a, *p);
    `

    • 0 7
    • 7 7
    • 0 0
    • 7 0
    Voir la réponse

    0 7

    Après fork, a existe en deux exemplaires indépendants : le fils modifie le sien. *p, lui, désigne la même page physique dans les deux processus. Programme exécuté : 0 7.

  • Un segment neuf créé par shm_open a une taille … : il faut appeler … avant de le projeter avec mmap.

    Voir la réponse

    Un segment neuf créé par shm_open a une taille nulle : il faut appeler ftruncate avant de le projeter avec mmap.

    Toucher une page au-delà de la fin du segment provoque SIGBUS. ftruncate(fd, taille) réserve la place.

  • shm_open : de quoi s'agit-il ?

    Voir la réponse

    Appel qui crée ou ouvre un segment désigné par un nom de la forme /nom, et rend un descripteur de fichier.

    Deux processus qui ouvrent le même nom obtiennent le même segment. Un segment neuf a une taille nulle : il faut ftruncate avant de le projeter pour l'utiliser.

  • Deux processus partagent un tampon en mémoire partagée : l'un écrit une structure de plusieurs champs, l'autre la lit. Le lecteur obtient parfois des structures à moitié mises à jour. Que faire ?

    • Protéger les accès par un sémaphore partagé
    • Projeter en MAP_PRIVATE pour que chacun ait sa copie à jour
    • Rappeler ftruncate pour que le segment soit assez grand
    • Appeler shm_unlink avant chaque lecture pour vider le segment
    Voir la réponse

    Protéger les accès par un sémaphore partagé

    Le lecteur passe pendant que l'écrivain n'a pas fini : rien dans la mémoire partagée n'impose d'attendre. Le sémaphore fait de l'écriture et de la lecture des sections qui ne se chevauchent pas. MAP_PRIVATE couperait la communication.

Réviser ce deck