So teilen Sie Speicher zwischen Linux-Prozessen

Shared-Memory-IPC-Prinzip

Der prozessübergreifende Kommunikationsmechanismus des gemeinsam genutzten Speichers wird hauptsächlich zum Übertragen großer Datenmengen zwischen Prozessen verwendet. Die folgende Abbildung zeigt ein schematisches Diagramm der Verwendung des gemeinsam genutzten Speichers zum Übertragen großer Datenmengen zwischen Prozessen:

Gemeinsamer Speicher ist ein Speicherplatz, der separat im Speicher geöffnet wird. Dieser Speicherplatz verfügt über eine eigene einzigartige Datenstruktur, einschließlich Zugriffsberechtigungen, Größe und aktueller Zugriffszeit. Die Datenstruktur ist wie folgt definiert:

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 */
};

Bevor zwei Prozesse diesen gemeinsam genutzten Speicherplatz nutzen, müssen sie eine Verbindung zwischen dem Prozessadressraum und dem gemeinsam genutzten Speicherplatz herstellen, dh den gemeinsam genutzten Speicherplatz in den Prozess einbinden.

Das System erlegt dem gemeinsam genutzten Speicher folgende Einschränkungen auf:

#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 */

Linux-Shared-Memory-Verwaltung

1. Gemeinsame Erinnerung schaffen

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

/*
* Der erste Parameter ist der Schlüsselwert, der im Allgemeinen von der Funktion ftok() generiert wird
* Der zweite Parameter ist die Größe des zu erstellenden Shared-Memory-Segments (in Bytes)
* Der dritte Parameter wird verwendet, um die Erstellungskennung des gemeinsam genutzten Speichersegments zu identifizieren
*/

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

2. Gemeinsame Speichersteuerung

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

/*
* Der erste Parameter ist die gemeinsam genutzte Speicherkennung, die betrieben werden soll
* Der zweite Parameter ist der auszuführende Vorgang
* Der dritte Parameter sind die temporären Shared-Memory-Variableninformationen der shmid_ds-Struktur
*/

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

3. Gemeinsam genutzte Speicherobjekte zuordnen

Die Systemaufruffunktion shmat() ordnet ein gemeinsam genutztes Speichersegment dem Datensegment des aufrufenden Prozesses zu und gibt die erste Adresse des Speicherbereichs zurück. Ihre Funktion wird wie folgt deklariert:

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

/*
* Der erste Parameter ist die gemeinsam genutzte Speicherkennung, die betrieben werden soll
* Der zweite Parameter wird verwendet, um die zugeordnete Adresse des gemeinsam genutzten Speichers anzugeben. Wenn er nicht 0 ist, wird dieser Parameter vom System zugewiesen
* Der dritte Parameter wird verwendet, um die Zugriffsberechtigungen und Zuordnungsbedingungen des gemeinsam genutzten Speichersegments anzugeben
*/

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

4. Gemeinsam genutzte Speicherobjekte trennen

Nachdem Sie den gemeinsam genutzten Speicherplatz genutzt haben, müssen Sie ihn mit dem Funktionsaufruf shmdt() vom aktuellen Prozess trennen. Die Funktionsdeklaration lautet wie folgt:

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

/*
* Der Parameter ist die erste Adresse des zugewiesenen gemeinsam genutzten Speichers
*/

int shmdt(const void *shmaddr);

Die Konvention, gefolgt von der gemeinsamen Erinnerung zwischen Eltern- und Kindprozessen

1. Nachdem Sie die Funktion fork() zum Erstellen eines untergeordneten Prozesses verwendet haben, erbt der Prozess den vom übergeordneten Prozess bereitgestellten gemeinsamen Speicher.

2. Wenn exec() aufgerufen wird, um ein neues Programm auszuführen, wird der gesamte bereitgestellte gemeinsam genutzte Speicher automatisch deaktiviert.

3. Wenn die Funktion „exit()“ in einem Prozess aufgerufen wird, wird der gesamte bereitgestellte gemeinsam genutzte Speicher vom aktuellen Prozess getrennt.

Programmbeispiel

Bewerben Sie sich für einen gemeinsam genutzten Speicher. Der übergeordnete Prozess speichert eine Ganzzahl an der ersten Adresse und der untergeordnete Prozess liest sie aus.

#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>

/* Shared Memory beantragen */

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

/* Gemeinsamen Speicher dem Prozessadressraum zuordnen */

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);

/* Zuordnung aufheben */

shmdt(ptr);

/* Gemeinsamen Speicher löschen */

shmctl(shm_id, IPC_RMID, 0);
}

return 0;
}

Ausgabeergebnis:

Das obige ist der detaillierte Inhalt vonSo teilen Sie Speicher zwischen Linux-Prozessen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!