2013-02-26 4 views
6

मुझे 2 प्रक्रियाएं (क्लाइंट और सर्वर) मिलती हैं जो साझा स्मृति के माध्यम से संचार कर रही हैं।सी - 2 डी गतिशील ऐरे (डबल पॉइंटर) - साझा मेमोरी

मुझे एक 2 डी ऐरे बनाने की आवश्यकता है जो गतिशील (पैरामीटर के आधार पर) है। सरणी को एक स्ट्रक्चर में संग्रहीत किया जाता है और फिर साझा सेगमेंट में लिखा जाता है।

मैं साझा स्मृति में सरणी लिख सकता हूं, लेकिन इसे अन्य प्रक्रिया से पुनर्प्राप्त नहीं कर सकता।

क्लाइंट कोड:

struct shared_use_st { 
    int  written_by_you; 
    int  **PID_PRI_array; 
}; 
      /* Prepare Dynamic 2D array */ 
     data_store = malloc(/*ROWS*/ 5 * sizeof(int*)); 
     for(i=0;i<5; i++) 
      data_store[i] = malloc(/*COLS*/ 2 * sizeof(int)); 


     /* Prepare Dynamic 2D array - Shared Memory Seg */ 
     shared_stuff->PID_PRI_array = malloc(/*ROWS*/ 5 * sizeof(int*)); 
     for(i=0;i<5; i++) 
      shared_stuff->PID_PRI_array[i] = malloc(/*COLS*/ 2 * sizeof(int)); 


     /* Write PID and PRI to data_store array */ 
     data_store[0][0] = pid; 
     data_store[0][1] = 1; 

     data_store[1][0] = 12345; 
     data_store[1][1] = 2; 

     data_store[2][0] = 12346; 
     data_store[2][1] = 3; 

     data_store[3][0] = 12347; 
     data_store[3][1] = 4; 

     data_store[4][0] = 12348; 
     data_store[4][1] = 5; 

      for(i=0;i<5;i++){ 
       for(x=0;x<=1;x++){ 
        shared_stuff->PID_PRI_array[i][x] = data_store[i][x]; 
       } 
      } 

सर्वर कोड:

for(i=0;i<5;i++){ 
    printf("PID: %d, PRI:%d\n", shared_stuff->PID_PRI_array[i][0], shared_stuff->PID_PRI_array[i][1]);    
} 

मैं एक "विभाजन दोष" त्रुटि मिलती है।

धन्यवाद।

+1

साझा स्मृति पता दोनों प्रक्रियाओं में एक ही है? यदि ऐसा नहीं है, तो पॉइंटर्स काम नहीं करेंगे। –

+0

हां वे वही हैं :) –

उत्तर

5

भले ही आपकी shared_stuff ऑब्जेक्ट साझा स्मृति में है, आप साझा स्मृति में सरणी नहीं लिख रहे हैं। आप malloc के साथ अंतरिक्ष आवंटित कर रहे हैं, उस स्थान पर डेटा लिख ​​रहे हैं, और फिर उस स्थान पर पॉइंटर्स को shared_stuff में डाल रहे हैं। malloc वर्तमान प्रक्रिया के भीतर स्थान आवंटित करता है 'सामान्य पता स्थान, आपके द्वारा बनाए गए साझा मेमोरी सेगमेंट में नहीं। आपको साझा स्मृति में सरणी सामग्री लिखनी होगी।

प्रस्तुत स्मृति साझा खंड में सरणी के लिए पर्याप्त जगह है, तो आपको malloc का उपयोग न करने के लिए स्वयं को पते का प्रबंधन करना होगा। (यदि पर्याप्त स्थान नहीं है, तो आपको साझा मेमोरी सेगमेंट को बड़ा करना होगा या जानकारी को समय के साथ टुकड़ों में व्यक्त करना होगा।)

आप निम्नानुसार साझा मेमोरी सेगमेंट में एक चर-लंबाई सरणी डाल सकते हैं।

सबसे पहले, एक संरचना है कि इस तरह सरणी आकार के रूप में सभी "प्रबंधन" जानकारी की आवश्यकता, शामिल परिभाषित:

struct StuffStruct 
{ 
    size_t NumberOfRows, NumberOfColumns; 
    … Other information as desired. 
}; 

कि संरचना करने के लिए एक सूचक बना सकते हैं और साझा स्मृति खंड को इंगित करने के लिए सेट:

struct StuffStruct *Stuff = shm; // shm contains the address from shmat, performed previously. 

स्तंभों की वांछित संख्या के साथ एक सरणी के लिए सूचक बना सकते हैं और प्रारंभिक संरचना के बाद साझा स्मृति खंड में बात करने के लिए यह सेट:

int (*data_store)[NumberOfColumns] = (int (*)[NumberOfColumns]) ((char *) Stuff + sizeof *Stuff); 

(सी purists के लिए नोट: हाँ, सी मानक गारंटी नहीं देता है कि जब आप पॉइंटर अंकगणित करते हैं तो क्या होता है। हालांकि, किसी भी कार्यान्वयन साझा स्मृति सहायता प्रदान करने सूचक अंकगणित की इस तरह के लिए समर्थन देना आवश्यक है।)

ध्यान दें कि sizeof *Stuff + NumberOfRows * NumberOfColumns * size(int) साझा स्मृति खंड के आकार से अधिक नहीं होना चाहिए। अन्यथा आप अगले चरण में साझा मेमोरी सेगमेंट को ओवरराउन कर देंगे।

अगले चरण के लिए, डेटा के साथ सरणी भरें: data_store के तत्वों को मानों को सामान्य द्वि-आयामी सरणी के रूप में असाइन करें।

सर्वर में, Stuff उसी तरह सेट करें। फिर, क्लाइंट ने साझा मेमोरी सेगमेंट लिखा है, Stuff से पंक्तियों और कॉलम की संख्या पढ़ें। फिर data_store उसी तरह सेट करें।फिर data_store से पढ़ें।

+0

क्षमा करें, उल्लेख करना भूल गया कि मेरे ऊपर यह है; 'shared_stuff = (struct shared_use_st *) shm;' कहाँ SHM Shmat का परिणाम है;
\t '/ * attatch डेटा अंतरिक्ष के लिए खंड */ \t अगर ((shm = Shmat (Shmid, शून्य, 0)) == (चार *) - 1) \t { \t \t perror (" Shmat "); \t \t _Exit (1); \t} \t printf ("[+] सेगमेंट अटैचमेंट \ n"); ' मैंने क्लाइंट में कोड का यह टेस्ट टुकड़ा लिखा है, और यह वही है जो मैं अपेक्षा करता हूं; 'printf (" टेस्ट \ n \ n "); के लिए (i = 0; i <5; i ++) printf ("पीआईडी:% d, पंचायती राज:% d \ n", shared_stuff-> PID_PRI_array [i] [0], shared_stuff-> PID_PRI_array [i] [1 ]); \t ' –

+0

आपकी टिप्पणी मेरे निदान के अनुरूप है। क्लाइंट में कोड प्रिंट करता है जो आप उम्मीद करते हैं क्योंकि डेटा क्लाइंट के पता स्थान में अपेक्षित स्थानों पर है। हालांकि, सर्वर के पता स्थान में डेटा दिखाई नहीं दे रहा है। साझा किए गए सेगमेंट में इंगित करने के लिए केवल 'shared_stuff' द्वारा निर्देशित संरचना केवल उस सेगमेंट में है, क्योंकि आपने साझा सेगमेंट को इंगित करने के लिए' shared_stuff' सेट किया है। उस संरचना के अंदर पॉइंटर्स साझा खंड से बाहर स्थानों पर इंगित करते हैं, जिन्हें 'malloc' द्वारा आवंटित किया जाता है। चूंकि वे स्थान साझा सेगमेंट के बाहर हैं, इसलिए वे सर्वर प्रक्रिया में दिखाई नहीं दे रहे हैं। –

+0

मैं देखता हूं। यदि मैं करता हूँ; 'shared_stuff-> लिखा_by_you = 1; 'यह सर्वर प्रक्रिया द्वारा दिखाई देता है, क्योंकि यह संरचना के पता स्थान के बाहर इंगित नहीं कर रहा है, है ना? मैं समस्या को हल करने के बारे में कैसे जाउंगा? धन्यवाद! –

संबंधित मुद्दे