शेयर्ड मेमोरी

साझा मेमोरी दो या दो से अधिक प्रक्रियाओं के बीच साझा की गई मेमोरी है। हालाँकि, हमें स्मृति या संचार के कुछ अन्य साधनों को साझा करने की आवश्यकता क्यों है?

दोहराने के लिए, प्रत्येक प्रक्रिया का अपना पता स्थान होता है, यदि कोई भी प्रक्रिया अपने स्वयं के पते स्थान से अन्य प्रक्रियाओं के लिए कुछ जानकारी के साथ संवाद करना चाहती है, तो यह केवल आईपीसी (अंतर प्रक्रिया संचार) तकनीकों के साथ संभव है। जैसा कि हम पहले से ही जानते हैं, संचार संबंधित या असंबंधित प्रक्रियाओं के बीच हो सकता है।

आमतौर पर, अंतर-संबंधित प्रक्रिया संचार पाइप या नामांकित पाइप का उपयोग करके किया जाता है। असंबंधित प्रक्रियाएं (कहते हैं कि एक टर्मिनल में चल रही एक प्रक्रिया और दूसरे टर्मिनल में एक अन्य प्रक्रिया) संचार नामांकित पाइप्स का उपयोग करके या साझा मेमोरी और संदेश क्यू की लोकप्रिय आईपीसी तकनीकों के माध्यम से किया जा सकता है।

हमने पाइप्स और नामांकित पाइपों की आईपीसी तकनीकों को देखा है और अब यह शेष आईपीसी तकनीकों को साझा करने का समय है। साझा मेमोरी, संदेश कतारें, सेमीफोरर्स, सिग्नल और मेमोरी मैपिंग।

इस अध्याय में, हम सभी साझा की गई मेमोरी के बारे में जानेंगे।

हम जानते हैं कि दो या दो से अधिक प्रक्रियाओं के बीच संवाद करने के लिए, हम साझा मेमोरी का उपयोग करते हैं लेकिन साझा मेमोरी का उपयोग करने से पहले सिस्टम कॉल के साथ क्या करना है, आइए इसे देखते हैं -

साझा मेमोरी सेगमेंट बनाएं या पहले से बनाए गए साझा मेमोरी सेगमेंट (shmget ()) का उपयोग करें
पहले से बनाए गए साझा मेमोरी सेगमेंट में प्रक्रिया संलग्न करें (shmat ())
पहले से संलग्न साझा मेमोरी सेगमेंट से प्रक्रिया को अलग करें (shmdt ())
साझा स्मृति खंड (shmctl ()) पर नियंत्रण संचालन

आइए हम साझा मेमोरी से संबंधित सिस्टम कॉल के कुछ विवरण देखें।

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

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

उपरोक्त सिस्टम कॉल सिस्टम V साझा मेमोरी सेगमेंट बनाता है या आवंटित करता है। जिन तर्कों को पारित करने की आवश्यकता है, वे इस प्रकार हैं -

first argument, key,साझा मेमोरी सेगमेंट को पहचानता है। कुंजी या तो एक मनमाना मूल्य हो सकती है या एक जो लाइब्रेरी फंक्शन ftok () से ली जा सकती है। कुंजी भी IPC_PRIVATE हो सकती है, साधन, सर्वर और क्लाइंट (माता-पिता और बच्चे के संबंध) के रूप में चल रही प्रक्रियाएं, अर्थात, अंतर-संबंधित प्रक्रिया संचार। यदि क्लाइंट इस कुंजी के साथ साझा मेमोरी का उपयोग करना चाहता है, तो यह सर्वर की एक बाल प्रक्रिया होनी चाहिए। इसके अलावा, माता-पिता द्वारा साझा स्मृति प्राप्त करने के बाद बच्चे की प्रक्रिया को बनाने की आवश्यकता होती है।

second argument, size, PAGE_SIZE के कई पर साझा किए गए साझा मेमोरी सेगमेंट का आकार है।

third argument, shmflg,IPC_CREAT (नया सेगमेंट बनाना) या IPC_EXCL (नए सेगमेंट बनाने के लिए IPC_CREAT के साथ उपयोग किया जाता है और कॉल विफल रहता है, जैसे कि यदि पहले से मौजूद है) तो आवश्यक साझा मेमोरी फ़्लैग / s निर्दिष्ट करता है। साथ ही परमिशन पास करने की जरूरत है।

Note - अनुमतियों के विवरण के लिए पहले के खंड देखें।

यह कॉल सफलता और -1 पर विफलता के मामले में एक मान्य साझा मेमोरी पहचानकर्ता (साझा मेमोरी के आगे कॉल के लिए प्रयुक्त) लौटाएगा। विफलता के कारण को जानने के लिए, गलत चर या गड़बड़ी () फ़ंक्शन के साथ जांचें।

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

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

उपरोक्त सिस्टम कॉल सिस्टम V साझा मेमोरी सेगमेंट के लिए साझा मेमोरी ऑपरेशन करता है, जो कॉलिंग प्रोसेस के एड्रेस स्पेस में एक साझा मेमोरी सेगमेंट को संलग्न करता है। जिन तर्कों को पारित करने की आवश्यकता है, वे इस प्रकार हैं -

The first argument, shmid,साझा मेमोरी सेगमेंट का पहचानकर्ता है। यह आईडी शेयर्ड मेमोरी आइडेंटिफायर है, जो shmget () सिस्टम कॉल का रिटर्न वैल्यू है।

The second argument, shmaddr,अनुलग्नक का पता निर्दिष्ट करना है। यदि shmaddr NULL है, तो सिस्टम डिफ़ॉल्ट रूप से सेगमेंट संलग्न करने के लिए उपयुक्त पता चुनता है। यदि shmaddr NULL नहीं है और SHM_RND को shmflg में निर्दिष्ट किया गया है, तो अनुलग्नक SHMLBA (लोअर बाउंड्री एड्रेस) के निकटतम कई के पते के बराबर है। अन्यथा, shmaddr एक पृष्ठ संरेखित पता होना चाहिए जिस पर साझा स्मृति अनुलग्नक होता है / शुरू होता है।

The third argument, shmflg, एसएचएम_आरएनडी (एसएचएमएलबीए के पते को बंद करना) या एसएचएम_ईएक्सईसी (खंड की सामग्री को निष्पादित करने की अनुमति देता है) या SHM_RDONLY (खंड को केवल-पढ़ने के उद्देश्य से संलग्न करता है, डिफ़ॉल्ट रूप से रीड-राइट है) या SHM_REMAP (shmaddr द्वारा निर्दिष्ट सीमा में मौजूदा मैपिंग को बदलता है और खंड के अंत तक जारी रहता है)।

यह कॉल सफलता पर संलग्न साझा मेमोरी सेगमेंट का पता लगाता है और विफलता के मामले में -1। विफलता के कारण को जानने के लिए, गलत चर या गड़बड़ी () फ़ंक्शन के साथ जांचें।

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

int shmdt(const void *shmaddr)

उपरोक्त सिस्टम कॉल, कॉलिंग प्रोसेस के एड्रेस स्पेस से साझा मेमोरी सेगमेंट को साझा करने के लिए सिस्टम V साझा मेमोरी सेगमेंट के लिए साझा मेमोरी ऑपरेशन करता है। इस तर्क को पारित करने की आवश्यकता है -

तर्क, शमाद्र, अलग किए जाने वाले साझा मेमोरी सेगमेंट का पता है। शट-टू-डिटैच्ड सेगमेंट को शमाट () सिस्टम कॉल द्वारा दिया गया पता होना चाहिए।

यह कॉल सफलता पर 0 और असफलता के मामले में -1 होगी। विफलता के कारण को जानने के लिए, गलत चर या गड़बड़ी () फ़ंक्शन के साथ जांचें।

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

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

उपरोक्त सिस्टम कॉल सिस्टम V साझा मेमोरी सेगमेंट के लिए नियंत्रण ऑपरेशन करता है। निम्नलिखित तर्कों को पारित करने की आवश्यकता है -

पहला तर्क, shmid, साझा मेमोरी सेगमेंट का पहचानकर्ता है। यह आईडी शेयर्ड मेमोरी आइडेंटिफायर है, जो shmget () सिस्टम कॉल का रिटर्न वैल्यू है।

दूसरा तर्क, cmd, साझा मेमोरी सेगमेंट पर आवश्यक नियंत्रण ऑपरेशन करने के लिए कमांड है।

Cmd के लिए मान्य मान हैं -

IPC_STAT- संरचना के प्रत्येक सदस्य के मौजूदा मूल्यों की जानकारी को buf द्वारा बताए गए पास किए गए संरचना में भेज दिया जाता है। इस कमांड को साझा मेमोरी सेगमेंट को पढ़ने की अनुमति की आवश्यकता होती है।
IPC_SET - संरचना आईडी द्वारा बताई गई उपयोगकर्ता आईडी, स्वामी की समूह आईडी, अनुमतियां, आदि सेट करती हैं।
IPC_RMID- खंड को नष्ट करने के लिए चिह्नित करता है। अंतिम प्रक्रिया समाप्त होने के बाद ही यह खंड नष्ट हो जाता है।
IPC_INFO - buf द्वारा बताई गई संरचना में साझा मेमोरी सीमा और मापदंडों के बारे में जानकारी देता है।
SHM_INFO - साझा स्मृति द्वारा भस्म किए गए सिस्टम संसाधनों के बारे में जानकारी युक्त एक shm_info संरचना लौटाता है।

तीसरा तर्क, bf, शेम्पिड_डीएस नामक साझा मेमोरी संरचना का एक संकेतक है। इस संरचना के मूल्यों का उपयोग या तो सेट के लिए किया जाएगा या सेमी के अनुसार प्राप्त किया जाएगा।

यह कॉल पारित आदेश के आधार पर मान लौटाता है। IPC_INFO और SHM_INFO या SHM_STAT की सफलता पर साझा मेमोरी सेगमेंट का सूचकांक या पहचानकर्ता या अन्य ऑपरेशन के लिए 0 और विफलता के मामले में -1 लौटाता है। विफलता के कारण को जानने के लिए, गलत चर या गड़बड़ी () फ़ंक्शन के साथ जांचें।

आइए हम निम्नलिखित नमूना कार्यक्रम पर विचार करें।

दो प्रक्रियाएँ बनाएँ, एक साझा मेमोरी में लिखने के लिए है (shm_write.c) और दूसरी साझा मेमोरी से पढ़ने के लिए है (shm_read.c)
कार्यक्रम साझा मेमोरी में राइटिंग प्रोसेस (shm_write.c) और साझा मेमोरी से रीडिंग प्रोसेस (shm_read.c) पढ़कर लेखन कार्य करता है।
साझा मेमोरी में, लेखन प्रक्रिया, आकार 1K (और झंडे) की साझा मेमोरी बनाती है और साझा मेमोरी को संलग्न करती है
लेखन प्रक्रिया 1023 बाइट्स में से प्रत्येक से 5 गुना अक्षर को 'ए' से साझा मेमोरी में लिखती है। अंतिम बाइट बफर के अंत का प्रतीक है
पढ़ें प्रक्रिया साझा मेमोरी से पढ़ी जाएगी और मानक आउटपुट पर लिखेंगे
पढ़ना और लिखना प्रक्रिया क्रियाएं एक साथ की जाती हैं
लेखन के पूरा होने के बाद, लिखित प्रक्रिया अपडेट को साझा मेमोरी में पूरा करने का संकेत देने के लिए अपडेट करती है (स्ट्रक्चर शमसेग में पूर्ण चर के साथ)
रीडिंग प्रोसेस साझा मेमोरी से रीडिंग करता है और आउटपुट पर प्रदर्शित करता है जब तक कि इसे लिखने की प्रक्रिया पूरी होने का संकेत नहीं मिलता है (स्ट्रक्चर शेकेल में पूरा वैरिएबल)
सरल लूप के लिए कुछ समय के लिए पढ़ने और लिखने की प्रक्रिया करता है और अनंत लूप से बचने और प्रोग्राम को जटिल करने के लिए भी करता है

निम्नलिखित लिखने की प्रक्रिया के लिए कोड है (साझा मेमोरी में लिखना - फ़ाइल: 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;
}

संकलन और निष्पादन कदम

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

निम्नलिखित पठन प्रक्रिया के लिए कोड है (साझा मेमोरी से पढ़ना और मानक आउटपुट पर लिखना - फाइल: 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;
}

संकलन और निष्पादन कदम

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