Comment partager de la mémoire entre les processus Linux

Principe IPC de la mémoire partagée

Le mécanisme de communication inter-processus de la mémoire partagée est principalement utilisé pour transférer de grandes quantités de données entre les processus. La figure suivante montre un diagramme schématique de l'utilisation de la mémoire partagée pour transférer de grandes quantités de données entre les processus :

La mémoire partagée est un espace mémoire ouvert séparément dans la mémoire. Cet espace mémoire possède sa propre structure de données unique, y compris les autorisations d'accès, la taille et l'heure d'accès récente. La structure des données est définie comme suit :

from /usr/include/linux/shm.h

struct shmid_ds {
struct ipc_perm shm_perm; /* operation perms 操作权限 */
int shm_segsz; /* size of segment (bytes) 段长度大小 */
__kernel_time_t shm_atime; /* last attach time 最近attach时间 */
__kernel_time_t shm_dtime; /* last detach time 最近detach时间 */
__kernel_time_t shm_ctime; /* last change time 最近change时间 */
__kernel_ipc_pid_t shm_cpid; /* pid of creator 创建者pid */
__kernel_ipc_pid_t shm_lpid; /* pid of last operator 最近操作pid */
unsigned short shm_nattch; /* no. of current attaches */
unsigned short shm_unused; /* compatibility */
void *shm_unused2; /* ditto - used by DIPC */
void *shm_unused3; /* unused */
};

Avant que deux processus n'utilisent cet espace de mémoire partagée, ils doivent établir une connexion entre l'espace d'adressage du processus et l'espace de mémoire partagée, c'est-à-dire monter l'espace de mémoire partagée dans le processus.

Le système impose les restrictions suivantes sur la mémoire partagée :

#define SHMMAX 0x2000000 /* max shared seg size (bytes) 最大共享段大小 */
#define SHMMIN 1 /* min shared seg size (bytes) 最小共享段大小 */
#define SHMMNI 4096 /* max num of segs system wide */
#define SHMALL (SHMMAX/getpagesize()*(SHMMNI/16))
#define SHMSEG SHMMNI /* max shared segs per process */

Gestion de la mémoire partagée Linux

1. Créez une mémoire partagée

#include <sys> #include <sys></sys></sys>

/*
* Le premier paramètre est la valeur clé, généralement générée par la fonction ftok()
* Le deuxième paramètre est la taille du segment de mémoire partagée à créer (en octets)
* Le troisième paramètre permet d'identifier l'identifiant de création du segment de mémoire partagée
*/

int shmget(key_t key, size_t size, int shmflg);

2. Contrôle de la mémoire partagée

#include <sys> #include <sys></sys></sys>

/*
* Le premier paramètre est l'identifiant de la mémoire partagée à exploiter
* Le deuxième paramètre est l'opération à effectuer
* Le troisième paramètre est l'information variable de mémoire partagée temporaire de la structure shmid_ds
*/

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

3. Cartographie des objets de mémoire partagée

La fonction d'appel système shmat() mappe un segment de mémoire partagée au segment de données du processus appelant et renvoie la première adresse de l'espace mémoire. Sa fonction est déclarée comme suit :

#include <sys>
#include <sys>
</sys></sys>

/*
* Le premier paramètre est l'identifiant de la mémoire partagée à exploiter
* Le deuxième paramètre est utilisé pour spécifier l'adresse mappée de la mémoire partagée. S'il n'est pas 0, ce paramètre sera alloué par le système
. * Le troisième paramètre est utilisé pour spécifier les autorisations d'accès et les conditions de mappage du segment de mémoire partagée
*/

void *shmat(int shmid, const void *shmaddr, int shmflg);

4. Détachez les objets de mémoire partagée

Après avoir utilisé l'espace mémoire partagé, vous devez utiliser l'appel de fonction shmdt() pour le séparer du processus en cours. La déclaration de la fonction est la suivante :

#include <sys>
#include <sys>
</sys></sys>

/*
* Le paramètre est la première adresse de la mémoire partagée allouée
*/

int shmdt(const void *shmaddr);

La convention suivie par la mémoire partagée entre les processus parent et enfant

1. Après avoir utilisé la fonction fork() pour créer un processus enfant, le processus hérite de la mémoire partagée montée par le processus parent.

2. Si exec() est appelé pour exécuter un nouveau programme, toute la mémoire partagée montée sera automatiquement démontée.

3. Si la fonction exit() est appelée dans un processus, toute la mémoire partagée montée sera déconnectée du processus en cours.

Exemple de programme

Demandez une mémoire partagée, le processus parent stocke un entier à la première adresse et le processus enfant le lit.

#include
#include <sys>
#include <sys>
#include <sys>
#include
#include

#define SHM_SIZE 1024

int main()
{
int shm_id, pid;
int *ptr = NULL;
</sys></sys></sys>

/* Demander une mémoire partagée */

shm_id = shmget((key_t)1004, SHM_SIZE, IPC_CREAT | 0600);

/* Mapper la mémoire partagée pour traiter l'espace d'adressage */

ptr = (int*)shmat(shm_id, 0, 0);

printf("Attach addr is %p \n", ptr);

*ptr = 1004;

printf("The Value of Parent is : %d \n", *ptr);

if((pid=fork()) == -1){
perror("fork Err");
exit(0);
}
else if(!pid){
printf("The Value of Child is : %d \n", *ptr);
exit(0);
}else{
sleep(1);

/* Démapper */

shmdt(ptr);

/* Supprimer la mémoire partagée */

shmctl(shm_id, IPC_RMID, 0);
}

return 0;
}

Résultat de sortie :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!