Fork में कॉपी-ऑन-राइट कैसे लिखा जाता है?


23

विकिपीडिया के अनुसार (जो गलत हो सकता है)

जब एक कांटा () सिस्टम कॉल जारी किया जाता है, तो मूल प्रक्रिया के अनुरूप सभी पृष्ठों की एक प्रति बनाई जाती है, जिसे चाइल्ड प्रक्रिया के लिए ओएस द्वारा एक अलग मेमोरी लोकेशन में लोड किया जाता है। लेकिन कुछ खास मामलों में इसकी जरूरत नहीं है। उस स्थिति पर विचार करें जब कोई बच्चा एक " exec" सिस्टम कॉल निष्पादित करता है (जिसका उपयोग किसी C प्रोग्राम के भीतर से किसी निष्पादन योग्य फ़ाइल को निष्पादित करने के लिए किया जाता है) या इसके तुरंत बाद बाहर निकलता है fork()। जब बच्चे को माता-पिता की प्रक्रिया के लिए एक कमांड निष्पादित करने की आवश्यकता होती है, तो माता-पिता की प्रक्रिया के पृष्ठों को कॉपी करने की कोई आवश्यकता नहीं होती है, क्योंकि प्रक्रिया execका पता स्थान को बदल देता है जो इसे निष्पादित करने के लिए कमांड के साथ लागू करता है।

ऐसे मामलों में, कॉपी-ऑन-राइट (COW) नामक तकनीक का उपयोग किया जाता है। इस तकनीक के साथ, जब एक कांटा होता है, तो माता-पिता की प्रक्रिया के पृष्ठ बच्चे की प्रक्रिया के लिए कॉपी नहीं किए जाते हैं। इसके बजाय, पृष्ठ बच्चे और मूल प्रक्रिया के बीच साझा किए जाते हैं। जब भी कोई प्रक्रिया (माता-पिता या बच्चा) किसी पृष्ठ को संशोधित करता है, तो उस प्रक्रिया (माता-पिता या बच्चे) के लिए अकेले उस विशेष पृष्ठ की एक अलग प्रतिलिपि बनाई जाती है जिसने संशोधन किया। यह प्रक्रिया भविष्य के सभी संदर्भों में साझा की बजाय नए कॉपी किए गए पृष्ठ का उपयोग करेगी। अन्य प्रक्रिया (जो साझा पृष्ठ को संशोधित नहीं करती है) पृष्ठ की मूल प्रतिलिपि का उपयोग करना जारी रखती है (जो अब साझा नहीं है)। इस तकनीक को कॉपी-ऑन-राइट कहा जाता है क्योंकि पेज को कॉपी किया जाता है जब कोई प्रक्रिया इसे लिखती है।

ऐसा लगता है कि जब कोई भी प्रक्रिया पृष्ठ को लिखने की कोशिश करती है तो पृष्ठ की एक नई प्रति आवंटित हो जाती है और उस प्रक्रिया को आवंटित कर दिया जाता है जिससे पृष्ठ दोष उत्पन्न होता है। मूल पृष्ठ को बाद में चिह्नित किया जाता है।

मेरा सवाल यह है कि अगर fork()किसी प्रक्रिया को साझा पृष्ठ पर लिखने का प्रयास करने से पहले कई बार बुलाया जाता है तो क्या होता है ?


विकिपीडिया इस मामले में सही है, और अधिक उच्च स्तर पर।
दीदी कोहेन

1
हां, कॉपी-ऑन-राइट आलसी कॉपी है, बच्चे की प्रक्रिया उस पृष्ठ को कॉपी करती है जब इसे लिखने का प्रयास किया जाता है। तो मूल रूप से, एक कांटा के बाद, लगभग बच्चे की स्मृति को माता-पिता के साथ साझा किया जाता है। हालाँकि, किए गए किसी भी प्रक्रिया से पहले, प्रत्येक बच्चे की प्रक्रिया में अभी भी कुछ निजी मेमोरी होती है, जो माता-पिता या नए आवंटन से संशोधित होती है। इसका मतलब है कि किसी भी कार्रवाई के बिना कांटे की बाल प्रक्रिया में कुछ निजी मेमोरी है। हम इसे pmap -XX PIDया के साथ सत्यापित कर सकते हैं cat /proc/PID/smap
जहाँ23

के बारे में - "मूल पृष्ठ बाद में लिखने योग्य हो जाता है।", इसका मालिक कौन होगा? यहाँ दूसरी प्रक्रिया जिसने इसे लिखने की कोशिश नहीं की है?
आदिल

ये बहुत प्यारी है। चलो इसे किंडरगार्टन में पढ़ाना शुरू करते हैं
ed22

जवाबों:


18

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


सही। मुद्दा यह है कि यह बाल प्रक्रिया है जो विशेष है, यदि इसे साझा पृष्ठ पर लिखने की कोशिश की जाती है तो नकल का काम होता है। अगर सही तरीके से किया जाए तो न तो माता-पिता और न ही अन्य बच्चों को बदलाव के बारे में पता होना चाहिए।
चार्ल्स स्टीवर्ट

9
बच्चे की प्रक्रिया वह विशेष नहीं है। बच्चे और माता-पिता दोनों प्रक्रियाओं में पृष्ठों का एक ही सेट होता है, केवल कांटे के बाद। जहाँ तक इन पृष्ठों का संबंध है, पृष्ठ हैंडलिंग सममित है।
बजकर

3

कांटा () का व्यवहार इस बात पर निर्भर करता है कि * निक्स प्रणाली में एमएमयू है या नहीं। एक गैर-एमएमयू प्रणाली (जैसे प्रारंभिक पीडीपी -11 एस) पर कांटा () सिस्टम कॉल प्रत्येक बच्चे के लिए माता-पिता की सभी स्मृति की नकल करता है। एमएमयू-आधारित * निक्स प्रणाली पर कर्नेल सभी गैर-स्टैक पृष्ठों को आर / ओ के रूप में चिह्नित करता है और उन्हें माता-पिता और बच्चे के बीच साझा करता है। फिर जब कोई भी प्रक्रिया किसी भी पृष्ठ पर लिखती है, तो MMU प्रयास में फंस जाता है, कर्नेल फिर एक लेखन योग्य पृष्ठ आवंटित करता है और MMU पृष्ठ-तालिकाओं को अद्यतन करता है जो अब लेखन योग्य पृष्ठ को इंगित करता है। यह कॉपी-ऑन-राइट व्यवहार एक गति प्रदान करता है क्योंकि शुरू में केवल एक निजी स्टैक को आवंटित करने और प्रत्येक बच्चे की प्रक्रिया के लिए क्लोन करने की आवश्यकता होती है।

यदि आप प्रत्येक कांटा () कॉल के बीच कुछ पेरेंट कोड निष्पादित करते हैं, तो परिणामी बाल प्रक्रियाएं उन पेजों से भिन्न होंगी, जिन्हें माता-पिता द्वारा बदल दिया गया है। दूसरी ओर, यदि माता-पिता बस एक ही बार में कई फोर्क () कॉल, जैसे लूप जारी करते हैं, तो बच्चे की प्रक्रिया लगभग समान होगी। यदि एक स्थानीय लूप चर का उपयोग किया जाता है, तो वह प्रत्येक बच्चे के ढेर के भीतर अलग होगा।


0

जब सिस्टम एक कांटा पहले से बना देता है, तो आमतौर पर (यह कार्यान्वयन पर निर्भर हो सकता है) यह पृष्ठों को केवल-पढ़ने के लिए चिह्नित करता है, और इन पृष्ठों के मास्टर के रूप में मूल प्रक्रिया को चिह्नित करता है।
जब इन पृष्ठों को लिखने की कोशिश की जाती है, तो एक पेज फॉल्ट होता है और OS खत्म हो जाता है, पृष्ठों की पूरी सूची या बस बदले हुए लोगों (फिर से, कार्यान्वयन पर निर्भर) की नकल करता है, इसलिए लेखन प्रक्रिया में एक लिखने योग्य प्रतिलिपि होगी।
जब एक ही से कई प्रक्रियाएँ कांटेक्ट की जाती हैं, जब "मास्टर" प्रक्रिया इसे मेमोरी में लिखती है, अन्य प्रक्रियाओं को उनके समकक्ष पृष्ठों की प्रतिलिपि मिलती है।


कौन सा सिस्टम ऐसा करता है? linux एक कॉपी-ऑन-राइट
इम्प्लीमेंटेशन

यह है कि कॉपी-ऑन-राइट कैसे काम करता है ...
दीदी कोहेन

3
@DavidKohen यह नहीं है कि कैसे कॉपी-ऑन-राइट इसके किसी भी संस्करण में काम करता है जो मैंने कभी सुना है। कोई "मास्टर" प्रक्रिया नहीं है। यदि कोई एकल प्रक्रिया साझा किए गए पृष्ठों को लिखती है, तो उसकी प्रतिलिपि एक निजी से टकरा जाती है जबकि अन्य सभी प्रक्रियाएं इसे साझा करना जारी रखती हैं।
सेलडा

1
मुझे लगता है कि डेविड कोहेन किसी बिंदु पर सही हैं। यह कॉपी-ऑन-राइट को लागू करने का एक तरीका है। गिस्ट यह होगा कि इस अंकन के साथ, उस पृष्ठ पर लिखना एक पृष्ठ-दोष हैंडलर को ट्रिगर करेगा जो तब उचित कार्रवाई करेगा, यानी कॉपी-ऑन-राइट। दुर्भाग्य से यह विवरण (जो सिस्टम-विशिष्ट होगा) ज्यादातर प्रश्न के लिए अप्रासंगिक है। ध्यान रखें कि CoW के दो आयाम हैं: एक प्रक्रिया को दिखाई देता है और एक यह कि कर्नेल इसे कैसे लागू कर सकता है।
0xC0000022L
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.