Pamięć współdzielona

Pamięć współdzielona to pamięć współdzielona przez dwa lub więcej procesów. Dlaczego jednak musimy dzielić się pamięcią lub innymi środkami komunikacji?

Powtarzam, każdy proces ma własną przestrzeń adresową, jeśli jakikolwiek proces chce przekazać pewne informacje z własnej przestrzeni adresowej do innych procesów, jest to możliwe tylko przy użyciu technik IPC (komunikacja między procesami). Jak już wiemy, komunikacja może odbywać się między powiązanymi lub niepowiązanymi procesami.

Zwykle komunikacja między powiązanymi procesami odbywa się za pomocą potoków lub potoków nazwanych. Niepowiązane procesy (powiedzmy, że jeden proces działa w jednym terminalu, a inny proces w innym terminalu), komunikacja może być realizowana przy użyciu nazwanych potoków lub popularnych technik IPC pamięci współdzielonej i kolejek wiadomości.

Widzieliśmy techniki IPC potoków i potoków nazwanych, a teraz nadszedł czas, aby poznać pozostałe techniki IPC, a mianowicie pamięć współdzieloną, kolejki wiadomości, semafory, sygnały i mapowanie pamięci.

W tym rozdziale dowiemy się wszystkiego o pamięci współdzielonej.

Wiemy, że do komunikacji między dwoma lub więcej procesami używamy pamięci współdzielonej, ale zanim użyjemy pamięci współdzielonej, co należy zrobić z wywołaniami systemowymi, zobaczmy to -

  • Utwórz segment pamięci współdzielonej lub użyj już utworzonego segmentu pamięci współdzielonej (shmget ())

  • Dołącz proces do już utworzonego segmentu pamięci współdzielonej (shmat ())

  • Odłącz proces od już dołączonego segmentu pamięci współdzielonej (shmdt ())

  • Sterowanie operacjami na segmencie pamięci współdzielonej (shmctl ())

Przyjrzyjmy się kilku szczegółom wywołań systemowych związanych z pamięcią współdzieloną.

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

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

Powyższe wywołanie systemowe tworzy lub przydziela segment pamięci współdzielonej Systemu V. Argumenty, które należy przekazać, są następujące -

Plik first argument, key,rozpoznaje segment pamięci współdzielonej. Klucz może być dowolną wartością lub taką, która może pochodzić z funkcji bibliotecznej ftok (). Kluczem może być również IPC_PRIVATE, czyli uruchamianie procesów jako serwer i klient (relacja nadrzędna i potomna), tj. Wzajemna komunikacja procesów. Jeśli klient chce korzystać z pamięci współdzielonej z tym kluczem, musi to być proces potomny serwera. Ponadto proces potomny musi zostać utworzony po uzyskaniu przez rodzica pamięci współdzielonej.

Plik second argument, size, to rozmiar segmentu pamięci współdzielonej zaokrąglony do wielokrotności PAGE_SIZE.

Plik third argument, shmflg,określa wymagane flagi pamięci współdzielonej, takie jak IPC_CREAT (tworzenie nowego segmentu) lub IPC_EXCL (używane z IPC_CREAT do tworzenia nowego segmentu i wywołanie kończy się niepowodzeniem, jeśli segment już istnieje). Musisz również przekazać uprawnienia.

Note - Zapoznaj się z wcześniejszymi sekcjami, aby uzyskać szczegółowe informacje na temat uprawnień.

To wywołanie zwróci prawidłowy identyfikator pamięci współdzielonej (używany do dalszych wywołań pamięci współdzielonej) w przypadku sukcesu i -1 w przypadku niepowodzenia. Aby poznać przyczynę niepowodzenia, sprawdź zmienną errno lub funkcją perror ().

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

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

Powyższe wywołanie systemowe wykonuje operację pamięci współdzielonej dla segmentu pamięci współdzielonej Systemu V, tj. Dołącza segment pamięci współdzielonej do przestrzeni adresowej procesu wywołującego. Argumenty, które należy przekazać, są następujące -

The first argument, shmid,jest identyfikatorem segmentu pamięci współdzielonej. Ten identyfikator jest identyfikatorem pamięci współdzielonej, który jest wartością zwracaną przez wywołanie systemowe shmget ().

The second argument, shmaddr,jest określenie adresu dołączania. Jeśli shmaddr ma wartość NULL, system domyślnie wybiera odpowiedni adres do dołączenia segmentu. Jeśli shmaddr nie ma wartości NULL, a w shmflg określono SHM_RND, to załączenie jest równe adresowi najbliższej wielokrotności SHMLBA (Lower Boundary Address). W przeciwnym razie shmaddr musi być adresem wyrównanym do strony, pod którym występuje / uruchamia się załącznik pamięci współdzielonej.

The third argument, shmflg, określa wymagane flagi pamięci współdzielonej, takie jak SHM_RND (zaokrąglanie adresu do SHMLBA) lub SHM_EXEC (umożliwia wykonanie zawartości segmentu) lub SHM_RDONLY (dołącza segment tylko do odczytu, domyślnie jest do odczytu i zapisu) lub SHM_REMAP (zastępuje istniejące mapowanie w zakresie określonym przez shmaddr i kontynuuje do końca segmentu).

To wywołanie zwróci adres dołączonego segmentu pamięci współdzielonej w przypadku sukcesu i -1 w przypadku niepowodzenia. Aby poznać przyczynę niepowodzenia, sprawdź zmienną errno lub funkcją perror ().

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

int shmdt(const void *shmaddr)

Powyższe wywołanie systemowe wykonuje operację pamięci współdzielonej dla segmentu pamięci współdzielonej Systemu V polegającą na odłączeniu segmentu pamięci współdzielonej z przestrzeni adresowej procesu wywołującego. Argument, który należy przekazać, to -

Argument shmaddr jest adresem segmentu pamięci współdzielonej, który ma zostać odłączony. Segment, który ma zostać odłączony, musi być adresem zwróconym przez wywołanie systemowe shmat ().

To wywołanie zwróci 0 w przypadku sukcesu i -1 w przypadku niepowodzenia. Aby poznać przyczynę niepowodzenia, sprawdź zmienną errno lub funkcją perror ().

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

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

Powyższe wywołanie systemowe wykonuje operację sterującą dla segmentu pamięci współdzielonej Systemu V. Należy przekazać następujące argumenty -

Pierwszy argument, shmid, jest identyfikatorem segmentu pamięci współdzielonej. Ten identyfikator jest identyfikatorem pamięci współdzielonej, który jest wartością zwracaną przez wywołanie systemowe shmget ().

Drugi argument, cmd, to polecenie wykonania wymaganej operacji kontrolnej na segmencie pamięci współdzielonej.

Prawidłowe wartości cmd to -

  • IPC_STAT- Kopiuje informacje o bieżących wartościach każdego elementu struktury shmid_ds do przekazanej struktury wskazywanej przez buf. To polecenie wymaga uprawnień do odczytu segmentu pamięci współdzielonej.

  • IPC_SET - Ustawia identyfikator użytkownika, identyfikator grupy właściciela, uprawnienia itp. Wskazywane przez strukturę buf.

  • IPC_RMID- Zaznacza segment do zniszczenia. Segment jest niszczony dopiero po odłączeniu go przez ostatni proces.

  • IPC_INFO - Zwraca informacje o limitach i parametrach pamięci współdzielonej w strukturze wskazywanej przez buf.

  • SHM_INFO - Zwraca strukturę shm_info zawierającą informacje o zużytych zasobach systemowych przez pamięć współdzieloną.

Trzeci argument, buf, jest wskaźnikiem do struktury pamięci współdzielonej o nazwie struct shmid_ds. Wartości tej struktury będą używane do ustawiania lub pobierania zgodnie z cmd.

To wywołanie zwraca wartość zależną od przekazanego polecenia. Po pomyślnym wykonaniu IPC_INFO i SHM_INFO lub SHM_STAT zwraca indeks lub identyfikator segmentu pamięci współdzielonej lub 0 dla innych operacji i -1 w przypadku niepowodzenia. Aby poznać przyczynę niepowodzenia, sprawdź zmienną errno lub funkcją perror ().

Rozważmy następujący przykładowy program.

  • Utwórz dwa procesy, jeden służy do zapisu do pamięci współdzielonej (shm_write.c), a drugi do odczytu z pamięci współdzielonej (shm_read.c)

  • Program wykonuje zapis do pamięci współdzielonej przez proces zapisu (shm_write.c) i odczyt z pamięci współdzielonej poprzez proces odczytu (shm_read.c)

  • W pamięci współdzielonej w trakcie procesu zapisu tworzona jest pamięć współdzielona o rozmiarze 1K (i flagi) i dołączana jest pamięć współdzielona

  • Proces zapisu zapisuje 5-krotność alfabetów od „A” do „E”, każdy z 1023 bajtów do pamięci współdzielonej. Ostatni bajt oznacza koniec bufora

  • Proces odczytu czyta z pamięci współdzielonej i zapisuje na standardowe wyjście

  • Czynności procesu czytania i pisania są wykonywane jednocześnie

  • Po zakończeniu zapisu proces zapisu aktualizuje się, aby wskazać zakończenie zapisu do pamięci współdzielonej (z pełną zmienną w struct shmseg)

  • Proces odczytu wykonuje odczyt z pamięci współdzielonej i wyświetla na wyjściu, dopóki nie otrzyma wskazania zakończenia procesu zapisu (pełna zmienna w struct shmseg)

  • Wykonuje proces czytania i pisania kilka razy dla uproszczenia, a także w celu uniknięcia nieskończonych pętli i komplikowania programu

Poniżej znajduje się kod procesu zapisu (zapis do pamięci współdzielonej - plik: 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;
}

Kroki kompilacji i wykonywania

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

Poniżej znajduje się kod procesu odczytu (odczyt z pamięci współdzielonej i zapis na standardowym wyjściu - plik: 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;
}

Kroki kompilacji i wykonywania

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