साझा-स्मृति स्थिरता

Question

के लिए लॉकिंग तंत्र मैं लिनक्स पर साझा स्मृति का उपयोग करके दो या दो से अधिक प्रक्रियाओं के बीच डेटा को इंटरचेंज करने के लिए एक तंत्र विकसित कर रहा हूं। समस्या यह है कि साझा स्मृति पर डेटा अखंडता को बनाए रखने के लिए समेकन नियंत्रण के कुछ स्तर की आवश्यकता होती है, और जैसा कि मैं देख रहा हूं कि कभी-कभी मेरी प्रक्रिया को मार/क्रैश किया जा सकता है, आम लॉक तंत्र 'काम नहीं करते क्योंकि वे स्मृति छोड़ सकते हैं एक "लॉक" स्थिति में और मरने के ठीक बाद, अन्य प्रक्रियाओं को लॉक के रिलीज के लिए इंतजार कर लटका दिया।

तो, कुछ शोध कर मैंने पाया है कि सिस्टम वी सेमफोरों में SEM_UNDO नामक ध्वज है जो प्रोग्राम विफल होने पर लॉक स्थिति को वापस कर सकता है, लेकिन यह काम करने की गारंटी नहीं है। एक और विकल्प पीआईडी ​​की उन सभी प्रक्रियाओं से निगरानी करना है जो साझा स्मृति का उपयोग कर सकते हैं और अगर कुछ बुरा होता है तो उन पर कुछ नियंत्रण होता है, लेकिन मुझे यकीन नहीं है कि यह मेरी समस्या का सही दृष्टिकोण हो सकता है।

कोई विचार ?? :)

संपादित करें: स्पष्टीकरण उद्देश्यों के लिए, हमारे ऐप को संभवतः सबसे छोटी विलंबता के साथ किसी प्रकार की आईपीसी तंत्र की आवश्यकता है। इसलिए, मैं उन तंत्रों के लिए खुला हूं जो इस आवश्यकता को भी संभाल सकते हैं।

Answer 1

मुझे यह जानकर उत्सुकता होगी कि आपने किस स्रोत का उपयोग किया था, SEM_UNDO को काम करने की गारंटी नहीं थी। मैंने पहले यह नहीं सुना है। मुझे लगता है कि सामान्य रूप से लिनक्स के एसवाईएसवी आईपीसी का दावा करने वाले लेख पढ़ने के बारे में याद आ रही थी लेकिन वह बहुत समय पहले थी। मैं सोच रहा हूं कि आपकी जानकारी सिर्फ पिछले समय की कलाकृति है।

अन्य बातों पर विचार करने के लिए (अगर मुझे सही याद है) यह है कि SYSV सेमफोरों में आपको सेमफोर ऑपरेशन करने के लिए अंतिम प्रक्रिया के पीआईडी ​​को बताने की क्षमता है। यदि आप लटकाते हैं तो आपको यह देखने में सक्षम होना चाहिए कि लॉक रखने वाली प्रक्रिया अभी भी जिंदा है या नहीं। चूंकि किसी भी प्रक्रिया (न केवल लॉक धारण करने वाला) सेमफोर के साथ खराब हो सकता है, आप इस तरह से नियंत्रण कर सकते हैं।

आखिरकार, मैं संदेश कतारों के लिए एक पिच डाल दूंगा। वे आपकी गति आवश्यकताओं के लिए उपयुक्त नहीं हो सकते हैं लेकिन वे आम तौर पर साझा स्मृति की तुलना में धीमे नहीं होते हैं। संक्षेप में वे सब कुछ कर रहे हैं जो आपको मैन्युअल रूप से एसएम के साथ करना है लेकिन ओएस इसे कवर के नीचे करता है।आपको सिंक्रनाइज़ेशन, परमाणुता, उपयोग में आसानी, और एक व्यापक रूप से परीक्षण तंत्र के साथ लगभग उतनी ही गति मिलती है।

Answer 2

केवल कुछ चीजें हैं जिन्हें एक प्रोग्राम विफल होने पर साफ़ करने की गारंटी दी जाती है। मेरे दिमाग में आने वाली एकमात्र चीज लिंक मायने रखती है। एक खुली फ़ाइल डिस्क्रिप्टर अंतर्निहित इनोड की लिंक गिनती को बढ़ाता है और एक संबंधित बंद होता है, जिसमें प्रोग्राम विफल होने पर मजबूर बंद होता है।

तो अपनी प्रक्रियाओं सब एक आम फ़ाइल (अगर यह साझा स्मृति क्षेत्रों के लिए काम करता है याद नहीं है) खोल सकते हैं और यदि गिनती, कम हो जाती है, जहां यह नहीं करना चाहिए आप अलार्म के कुछ प्रकार को चालू कर सकते। E.g एक सादा इंतजार करने की बजाय आपकी प्रक्रियाएं एक लूप में एक टाइमवेवेट (एक सेकंड के लिए) कर सकती हैं और कुछ गड़बड़ गलत होने पर लिंक गिनती के लिए मतदान को सतर्क किया जा सकता है।

Answer 3

जब आपने कहा कि सेमफोरस प्रक्रियाओं को साफ तरीके से संभाल नहीं सकता है तो मैं थोड़ा आश्चर्यचकित था। उस तरह का समर्थन काफी मौलिक लगता है! मेरे यूबंटू 10.4 सिस्टम और वेब पर टीएच सेमप मैन पेज दोनों को देखकर here सुझाव देता है कि यह ठीक होना चाहिए। Hopefuly SEM_UNDO गणना को संग्रहीत करने के लिए उपयोग की जाने वाली स्मृति को कर्नेल स्पेस में संग्रहीत किया जाता है, और इसलिए गलती स्मृति लिखने से सुरक्षित होता है।

सच कहा जाता है, भले ही एक विश्वसनीय सैमफोर लॉकिंग तंत्र भी आपकी समस्या को पूरी तरह हल नहीं कर सकता है। यदि आप लेनदेन प्रसंस्करण की अनुमति देने के लिए ताले का उपयोग कर रहे हैं तो आपको उन परिस्थितियों को संभालने की भी आवश्यकता होगी जहां लेनदेन को दुर्घटनाग्रस्त होने से पहले भाग लिया जाता है, और किसी अन्य प्रोग्राम को डेटा संरचना तक पहुंचने की अनुमति मिलती है।

Answer 4

आप साझा स्मृति में एक pthread म्युटेक्स pthread_mutexattr_setpshared (http://linux.die.net/man/3/pthread_mutexattr_setpshared)

भी उपयोग कर सकते हैं तो आप सीधे http://people.redhat.com/drepper/futex.pdf और http://lxr.linux.no/#linux+v2.6.34/Documentation/robust-futexes.txt और http://www.kernel.org/doc/man-pages/online/pages/man7/futex.7.html और http://www.kernel.org/doc/man-pages/online/pages/man2/futex.2.html particularaly दूसरा एक को देखने के बाद कि जारी करने के लिए कर्नेल करने के बारे में बात करती है futexes उपयोग करने के लिए कोशिश कर सकते जब एक प्रक्रिया इसे मर जाता है।

मुझे लगता है कि पर्थ्रेड लॉक/सीवी मजबूत बनाना संभव है, जो तब से बेहतर विचार है जब से मजबूत ताले को संभालने के लिए सभी चीजें आपके लिए की जाती हैं (यहां तक ​​कि दूरस्थ रूप से आधुनिक डिस्ट्रो में इसे मजबूत फूटक्स का उपयोग करना चाहिए pthread_mutex IIRC के लिए http://lxr.linux.no/#linux+v2.6.34/Documentation/robust-futexes.txt में वर्णित है कि काफी देर के लिए कर्नेल में हो गया है, लेकिन क्या आप वाकई कुछ शोध मैं कर रही है, अपने pthread_mutex मजबूत

Answer 5

तो बनाने के लिए) कुछ भी करने की जरूरत नहीं है बनाने के लिए चाहते हो सकता है के बाद से यह पाया गया है कि सिस्टम वी सेमफोरों में SEM_UNDO नामक ध्वज होता है जो प्रोग्राम विफल होने पर लॉक स्थिति को वापस कर सकता है, लेकिन यह काम करने की गारंटी नहीं है।

SEM_UNDO प्रक्रिया क्रैश होने पर सेमफोर अनलॉक कर देगा। यदि साझा स्मृति के भ्रष्टाचार के कारण प्रक्रियाओं को दुर्घटनाग्रस्त हो जाती है, तो आपके लिए कुछ भी नहीं है। ओएस साझा स्मृति की स्थिति पूर्ववत नहीं कर सकता है।

आप साझा स्मृति का रोल वापस करने के लिए राज्य में सक्षम होने की जरूरत है, तो आप अपने दम पर कुछ को लागू करने की है। मैंने कम से कम दो मॉडल देखे हैं जो इससे निपटते हैं।

साझा स्मृति में कुछ भी संशोधित करने से पहले सबसे पहले मॉडल संरचना का एक स्नैपशॉट ले रहा था, साझा स्मृति में एक सूची में बचत। यदि कोई अन्य प्रक्रिया लॉक प्राप्त करने में सक्षम थी और सूची खाली नहीं थी, तो यह क्रैश की गई प्रक्रिया में जो भी बदलाव हो सकता है, उसे पूर्ववत कर दिया गया था।

दूसरा मॉडल स्थानीय स्मृति में shm संरचनाओं की प्रतियां बनाने और ताला पूरे लेन-देन के लिए बंद कर दिया रखने के लिए है। जब लॉक जारी करने से पहले लेनदेन किया जा रहा है, तो बस स्थानीय मेमोरी से संरचनाओं को साझा स्मृति में कॉपी करें। कॉपी के दौरान ऐप क्रैश होने की संभावना कम है और बाहरी सिग्नल द्वारा हस्तक्षेप sigprocmask() का उपयोग कर अवरुद्ध किया जा सकता है। (मामले बेहतर अच्छी तरह से डेटा पर विभाजित किया जा में लॉक करना shm में 10Mln रिकॉर्ड 4 समवर्ती प्रक्रियाओं द्वारा पहुँचा के लिए 1000 ताले के सेट के साथ जैसे मैंने देखा है परीक्षण।।)