Geteilte Erinnerung

Shared Memory ist ein Speicher, der von zwei oder mehr Prozessen gemeinsam genutzt wird. Warum müssen wir jedoch das Gedächtnis oder ein anderes Kommunikationsmittel gemeinsam nutzen?

Um es noch einmal zu wiederholen: Jeder Prozess hat seinen eigenen Adressraum. Wenn ein Prozess mit einigen Informationen aus seinem eigenen Adressraum an andere Prozesse kommunizieren möchte, ist dies nur mit IPC-Techniken (Inter Process Communication) möglich. Wie wir bereits wissen, kann die Kommunikation zwischen verwandten oder nicht verwandten Prozessen erfolgen.

Normalerweise wird die Kommunikation zwischen Prozessen über Pipes oder Named Pipes durchgeführt. Nicht verwandte Prozesse (z. B. ein Prozess, der in einem Terminal ausgeführt wird, und ein anderer Prozess in einem anderen Terminal) können über Named Pipes oder über gängige IPC-Techniken für Shared Memory und Message Queues ausgeführt werden.

Wir haben die IPC-Techniken von Pipes und Named Pipes gesehen und jetzt ist es an der Zeit, die verbleibenden IPC-Techniken zu kennen, nämlich Shared Memory, Message Queues, Semaphoren, Signale und Memory Mapping.

In diesem Kapitel erfahren Sie alles über Shared Memory.

Wir wissen, dass wir für die Kommunikation zwischen zwei oder mehr Prozessen den gemeinsam genutzten Speicher verwenden. Bevor Sie jedoch den gemeinsam genutzten Speicher verwenden, müssen Sie Folgendes sehen:

  • Erstellen Sie das Shared-Memory-Segment oder verwenden Sie ein bereits erstelltes Shared-Memory-Segment (shmget ()).

  • Hängen Sie den Prozess an das bereits erstellte Shared-Memory-Segment (shmat ()) an.

  • Trennen Sie den Prozess vom bereits angehängten gemeinsam genutzten Speichersegment (shmdt ()).

  • Steueroperationen für das gemeinsam genutzte Speichersegment (shmctl ())

Schauen wir uns einige Details der Systemaufrufe an, die sich auf den gemeinsam genutzten Speicher beziehen.

#include <sys/ipc.h>
#include <sys/shm.h>

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

Der obige Systemaufruf erstellt oder ordnet ein System V-Shared-Memory-Segment zu. Die Argumente, die übergeben werden müssen, sind wie folgt:

Das first argument, key,erkennt das gemeinsam genutzte Speichersegment. Der Schlüssel kann entweder ein beliebiger Wert sein oder von der Bibliotheksfunktion ftok () abgeleitet werden. Der Schlüssel kann auch IPC_PRIVATE sein, dh Prozesse als Server und Client (Eltern-Kind-Beziehung) ausführen, dh prozessbezogene Prozesskommunikation. Wenn der Client gemeinsam genutzten Speicher mit diesem Schlüssel verwenden möchte, muss es sich um einen untergeordneten Prozess des Servers handeln. Außerdem muss der untergeordnete Prozess erstellt werden, nachdem der übergeordnete Prozess einen gemeinsam genutzten Speicher erhalten hat.

Das second argument, size, ist die Größe des gemeinsam genutzten Speichersegments, gerundet auf ein Vielfaches von PAGE_SIZE.

Das third argument, shmflg,Gibt die erforderlichen Shorts für gemeinsam genutzten Speicher an, z. B. IPC_CREAT (Erstellen eines neuen Segments) oder IPC_EXCL (Wird mit IPC_CREAT zum Erstellen eines neuen Segments verwendet und der Aufruf schlägt fehl, wenn das Segment bereits vorhanden ist). Müssen auch die Berechtigungen übergeben.

Note - Einzelheiten zu Berechtigungen finden Sie in früheren Abschnitten.

Dieser Aufruf würde bei Erfolg eine gültige ID für den gemeinsam genutzten Speicher (die für weitere Aufrufe des gemeinsam genutzten Speichers verwendet wird) und -1 bei einem Fehler zurückgeben. Um die Fehlerursache zu ermitteln, überprüfen Sie die Funktion errno variable oder perror ().

#include <sys/types.h>
#include <sys/shm.h>

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

Der obige Systemaufruf führt eine Shared-Memory-Operation für das System-V-Shared-Memory-Segment durch, dh das Anhängen eines Shared-Memory-Segments an den Adressraum des aufrufenden Prozesses. Die Argumente, die übergeben werden müssen, sind wie folgt:

The first argument, shmid,ist die Kennung des gemeinsam genutzten Speichersegments. Diese ID ist die ID des gemeinsam genutzten Speichers. Dies ist der Rückgabewert des Systemaufrufs shmget ().

The second argument, shmaddr,ist die Angabe der Anhangsadresse. Wenn shmaddr NULL ist, wählt das System standardmäßig die geeignete Adresse zum Anhängen des Segments. Wenn shmaddr nicht NULL ist und SHM_RND in shmflg angegeben ist, entspricht der Anhang der Adresse des nächsten Vielfachen von SHMLBA (Lower Boundary Address). Andernfalls muss shmaddr eine seitenausgerichtete Adresse sein, an der der Shared-Memory-Anhang auftritt / startet.

The third argument, shmflg, Gibt die erforderlichen gemeinsam genutzten Speicherflags an, z. B. SHM_RND (Abrundungsadresse auf SHMLBA) oder SHM_EXEC (ermöglicht die Ausführung des Segmentinhalts) oder SHM_RDONLY (hängt das Segment schreibgeschützt an, standardmäßig schreibgeschützt). oder SHM_REMAP (ersetzt die vorhandene Zuordnung in dem von shmaddr angegebenen Bereich und wird bis zum Ende des Segments fortgesetzt).

Dieser Aufruf würde bei Erfolg die Adresse des angehängten gemeinsam genutzten Speichersegments und im Fehlerfall -1 zurückgeben. Um die Fehlerursache zu ermitteln, überprüfen Sie die Funktion errno variable oder perror ().

#include <sys/types.h>
#include <sys/shm.h>

int shmdt(const void *shmaddr)

Der obige Systemaufruf führt eine Shared-Memory-Operation für das System-V-Shared-Memory-Segment durch, indem das Shared-Memory-Segment vom Adressraum des aufrufenden Prozesses getrennt wird. Das Argument, das übergeben werden muss, ist -

Das Argument shmaddr ist die Adresse des zu trennenden gemeinsam genutzten Speichersegments. Das zu trennende Segment muss die vom Systemaufruf shmat () zurückgegebene Adresse sein.

Dieser Aufruf würde bei Erfolg 0 und bei einem Fehler -1 zurückgeben. Um die Fehlerursache zu ermitteln, überprüfen Sie die Funktion errno variable oder perror ().

#include <sys/ipc.h>
#include <sys/shm.h>

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

Der obige Systemaufruf führt eine Steueroperation für ein System V-Shared-Memory-Segment aus. Die folgenden Argumente müssen übergeben werden -

Das erste Argument, shmid, ist die Kennung des gemeinsam genutzten Speichersegments. Diese ID ist die ID des gemeinsam genutzten Speichers. Dies ist der Rückgabewert des Systemaufrufs shmget ().

Das zweite Argument, cmd, ist der Befehl zum Ausführen der erforderlichen Steueroperation für das gemeinsam genutzte Speichersegment.

Gültige Werte für cmd sind -

  • IPC_STAT- Kopiert die Informationen der aktuellen Werte jedes Mitglieds der Struktur shmid_ds in die übergebene Struktur, auf die buf zeigt. Dieser Befehl erfordert eine Leseberechtigung für das gemeinsam genutzte Speichersegment.

  • IPC_SET - Legt die Benutzer-ID, die Gruppen-ID des Eigentümers, die Berechtigungen usw. fest, auf die der Struktur-Puffer zeigt.

  • IPC_RMID- Markiert das zu zerstörende Segment. Das Segment wird erst zerstört, nachdem der letzte Prozess es getrennt hat.

  • IPC_INFO - Gibt die Informationen zu den gemeinsam genutzten Speichergrenzen und -parametern in der Struktur zurück, auf die buf zeigt.

  • SHM_INFO - Gibt eine shm_info-Struktur zurück, die Informationen zu den vom gemeinsam genutzten Speicher verbrauchten Systemressourcen enthält.

Das dritte Argument, buf, ist ein Zeiger auf die gemeinsam genutzte Speicherstruktur mit dem Namen struct shmid_ds. Die Werte dieser Struktur würden entweder für set oder get gemäß cmd verwendet.

Dieser Aufruf gibt den Wert abhängig vom übergebenen Befehl zurück. Bei Erfolg von IPC_INFO und SHM_INFO oder SHM_STAT wird der Index oder die Kennung des gemeinsam genutzten Speichersegments oder 0 für andere Operationen und -1 im Fehlerfall zurückgegeben. Um die Fehlerursache zu ermitteln, überprüfen Sie die Funktion errno variable oder perror ().

Betrachten wir das folgende Beispielprogramm.

  • Erstellen Sie zwei Prozesse, einen zum Schreiben in den gemeinsam genutzten Speicher (shm_write.c) und einen zum Lesen aus dem gemeinsam genutzten Speicher (shm_read.c).

  • Das Programm schreibt durch einen Schreibprozess (shm_write.c) in den gemeinsam genutzten Speicher und durch einen Lesevorgang (shm_read.c) aus dem gemeinsam genutzten Speicher.

  • Im gemeinsam genutzten Speicher erstellt der Schreibvorgang einen gemeinsam genutzten Speicher der Größe 1 KB (und Flags) und hängt den gemeinsam genutzten Speicher an

  • Der Schreibvorgang schreibt fünfmal die Alphabete von 'A' bis 'E' mit jeweils 1023 Bytes in den gemeinsam genutzten Speicher. Das letzte Byte kennzeichnet das Ende des Puffers

  • Der Lesevorgang würde aus dem gemeinsam genutzten Speicher lesen und in die Standardausgabe schreiben

  • Lese- und Schreibvorgänge werden gleichzeitig ausgeführt

  • Nach Abschluss des Schreibvorgangs wird der Schreibvorgang aktualisiert, um den Abschluss des Schreibvorgangs in den gemeinsam genutzten Speicher anzuzeigen (mit vollständiger Variable in struct shmseg).

  • Der Lesevorgang führt das Lesen aus dem gemeinsam genutzten Speicher durch und wird in der Ausgabe angezeigt, bis der Abschluss des Schreibvorgangs angezeigt wird (vollständige Variable in struct shmseg).

  • Führt zur Vereinfachung und auch zur Vermeidung von Endlosschleifen und zur Komplikation des Programms einige Male Lese- und Schreibvorgänge durch

Es folgt der Code für den Schreibvorgang (Schreiben in den gemeinsam genutzten Speicher - Datei: shm_write.c)

/* Filename: shm_write.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg {
   int cnt;
   int complete;
   char buf[BUF_SIZE];
};
int fill_buffer(char * bufptr, int size);

int main(int argc, char *argv[]) {
   int shmid, numtimes;
   struct shmseg *shmp;
   char *bufptr;
   int spaceavailable;
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }
   
   // Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }
   
   /* Transfer blocks of data from buffer to shared memory */
   bufptr = shmp->buf;
   spaceavailable = BUF_SIZE;
   for (numtimes = 0; numtimes < 5; numtimes++) {
      shmp->cnt = fill_buffer(bufptr, spaceavailable);
      shmp->complete = 0;
      printf("Writing Process: Shared Memory Write: Wrote %d bytes\n", shmp->cnt);
      bufptr = shmp->buf;
      spaceavailable = BUF_SIZE;
      sleep(3);
   }
   printf("Writing Process: Wrote %d times\n", numtimes);
   shmp->complete = 1;

   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }

   if (shmctl(shmid, IPC_RMID, 0) == -1) {
      perror("shmctl");
      return 1;
   }
   printf("Writing Process: Complete\n");
   return 0;
}

int fill_buffer(char * bufptr, int size) {
   static char ch = 'A';
   int filled_count;
   
   //printf("size is %d\n", size);
   memset(bufptr, ch, size - 1);
   bufptr[size-1] = '\0';
   if (ch > 122)
   ch = 65;
   if ( (ch >= 65) && (ch <= 122) ) {
      if ( (ch >= 91) && (ch <= 96) ) {
         ch = 65;
      }
   }
   filled_count = strlen(bufptr);
   
   //printf("buffer count is: %d\n", filled_count);
   //printf("buffer filled is:%s\n", bufptr);
   ch++;
   return filled_count;
}

Kompilierungs- und Ausführungsschritte

Writing Process: Shared Memory Write: Wrote 1023 bytes
Writing Process: Shared Memory Write: Wrote 1023 bytes
Writing Process: Shared Memory Write: Wrote 1023 bytes
Writing Process: Shared Memory Write: Wrote 1023 bytes
Writing Process: Shared Memory Write: Wrote 1023 bytes
Writing Process: Wrote 5 times
Writing Process: Complete

Es folgt der Code für den Lesevorgang (Lesen aus dem gemeinsam genutzten Speicher und Schreiben in die Standardausgabe - Datei: shm_read.c)

/* Filename: shm_read.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg {
   int cnt;
   int complete;
   char buf[BUF_SIZE];
};

int main(int argc, char *argv[]) {
   int shmid;
   struct shmseg *shmp;
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }
   
   // Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }
   
   /* Transfer blocks of data from shared memory to stdout*/
   while (shmp->complete != 1) {
      printf("segment contains : \n\"%s\"\n", shmp->buf);
      if (shmp->cnt == -1) {
         perror("read");
         return 1;
      }
      printf("Reading Process: Shared Memory: Read %d bytes\n", shmp->cnt);
      sleep(3);
   }
   printf("Reading Process: Reading Done, Detaching Shared Memory\n");
   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }
   printf("Reading Process: Complete\n");
   return 0;
}

Kompilierungs- und Ausführungsschritte

segment contains :
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
Reading Process: Shared Memory: Read 1023 bytes
segment contains :
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
Reading Process: Shared Memory: Read 1023 bytes
segment contains :
"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
Reading Process: Shared Memory: Read 1023 bytes
segment contains :
"DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"
Reading Process: Shared Memory: Read 1023 bytes
segment contains :
"EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
Reading Process: Shared Memory: Read 1023 bytes
Reading Process: Reading Done, Detaching Shared Memory
Reading Process: Complete
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved