फोर्क (सिस्टम कॉल)

कम्प्यूटिंग में, विशेष रूप से यूनिक्स ऑपरेटिंग सिस्टम और इसके UNIX- जैसे के संदर्भ में, फोर्क एक ऑपरेशन है जिससे एक कंप्यूटर प्रक्रिया स्वयं की एक प्रति बनाती है। यह एक इंटरफ़ेस है जो POSIX और सिंगल यूनिक्स विशिष्टता मानकों के अनुपालन के लिए आवश्यक है। यह आमतौर पर फोर्क, क्लोन या कर्नेल (ऑपरेटिंग सिस्टम) के अन्य सिस्टम कॉल के लिए C मानक लाइब्रेरी रैपर लाइब्रेरी के रूप में लागू किया जाता है। यूनिक्स जैसे ऑपरेटिंग सिस्टम पर फोर्क प्रक्रिया निर्माण की प्राथमिक विधि है।

सिंहावलोकन

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

फोर्क ऑपरेशन बच्चे के लिए एक अलग पता स्थान बनाता है। चाइल्ड प्रोसेस में जनक प्रक्रिया के सभी मेमोरी सेगमेंट की सटीक कॉपी होती है। SunOS-4.0 से आभासी मेमोरी मॉडल का पालन करने वाले आधुनिक UNIX वेरिएंट में, लिखने पर नकल सिमेंटिक्स लागू किए जाते हैं और भौतिक मेमोरी को वास्तव में कॉपी करने की आवश्यकता नहीं होती है। इसके बजाय, दोनों प्रक्रियाओं में वर्चुअल मेमोरी पेज भौतिक मेमोरी के समान पेजों को संदर्भित कर सकते हैं जब तक कि उनमें से कोई एक ऐसे पेज पर नहीं लिखता है: तब इसे कॉपी किया जाता है। यह अनुकूलन सामान्य मामले में महत्वपूर्ण है जहां एक नए प्रोग्राम को निष्पादित करने के लिए fork का उपयोग exec के संयोजन के साथ किया जाता है: आम तौर पर, बाल प्रक्रिया शुरू होने वाले कार्यक्रम के पक्ष में अपने कार्यक्रम के निष्पादन को समाप्त करने से पहले केवल क्रियाओं का एक छोटा सा सेट करती है, और इसके माता-पिता के डेटा संरचनाओं में से बहुत कम, यदि कोई हो, की आवश्यकता होती है।

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

इतिहास

1962 में प्रकाशित मेल्विन कॉनवे द्वारा ए मल्टीप्रोसेसर सिस्टम डिज़ाइन में एक कांटा अवधारणा के शुरुआती संदर्भों में से एक दिखाई दिया। कॉनवे के पेपर ने प्रोजेक्ट जिन्न|जेनी टाइम-शेयरिंग सिस्‍टम में फोर्क के एल. पीटर डिस्‍टक्‍यू द्वारा कार्यान्‍वयन को प्रेरित किया, जहां केन थॉम्पसन द्वारा इसकी शुरूआती उपस्थिति के लिए अवधारणा को उधार लिया गया था। अनुसंधान यूनिक्स में। Fork बाद में POSIX में एक मानक इंटरफ़ेस बन गया।

संचार

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

वेरिएंट

वीफोर्क

Vfork समान कॉलिंग कन्वेंशन और समान शब्दार्थ के साथ fork का एक प्रकार है, लेकिन केवल प्रतिबंधित स्थितियों में उपयोग किया जाता है। यह यूनिक्स के बर्कले सॉफ्टवेयर वितरण संस्करण में उत्पन्न हुआ, वर्चुअल मेमोरी का समर्थन करने वाला पहला यूनिक्स। इसे POSIX द्वारा मानकीकृत किया गया था, जिसने vfork को फोर्क के समान ही व्यवहार करने की अनुमति दी थी, लेकिन 2004 के संस्करण में अप्रचलित चिह्नित किया गया था। और बाद के संस्करणों में स्पॉन (कंप्यूटिंग) #POSIX स्पॉन फ़ंक्शंस|posix_spawn() (जो आमतौर पर vfork के माध्यम से कार्यान्वित किया जाता है) द्वारा प्रतिस्थापित किया गया था।

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

यूनिक्स प्रणाली वी ी ने सिस्टम वीआर 4 पेश करने से पहले इस फ़ंक्शन कॉल का समर्थन नहीं किया था, क्योंकि इसके कारण होने वाली स्मृति साझाकरण त्रुटि-प्रवण है:

Vfork does not copy page tables so it is faster than the System V fork implementation. But the child process executes in the same physical address space as the parent process (until an exec or exit) and can thus overwrite the parent's data and stack. A dangerous situation could arise if a programmer uses vfork incorrectly, so the onus for calling vfork lies with the programmer. The difference between the System V approach and the BSD approach is philosophical: Should the kernel hide idiosyncrasies of its implementation from users, or should it allow sophisticated users the opportunity to take advantage of the implementation to do a logical function more efficiently?

— Maurice J. Bach

इसी तरह, vfork के लिए Linux मैन पेज दृढ़ता से इसके उपयोग को हतोत्साहित करता है:

It is rather unfortunate that Linux revived this specter from the past. The BSD man page states: "This system call will be eliminated when proper system sharing mechanisms are implemented. Users should not depend on the memory sharing semantics of vfork() as it will, in that case, be made synonymous to fork(2)."

साथ अन्य समस्याएं vfork गतिशील लिंकिंग के साथ इंटरेक्शन के कारण बहु-थ्रेडेड प्रोग्राम में उत्पन्न होने वाले गतिरोध शामिल हैं। के प्रतिस्थापन के रूप में vfork इंटरफ़ेस, POSIX ने पेश किया posix_spawn कार्यों का परिवार जो फोर्क और निष्पादन के कार्यों को जोड़ता है। इन कार्यों को पुस्तकालय दिनचर्या के रूप में लागू किया जा सकता है fork, जैसा Linux में किया जाता है, या के संदर्भ में vfork बेहतर प्रदर्शन के लिए, जैसा सोलारिस में किया जाता है, लेकिन POSIX विनिर्देश नोट करता है कि उन्हें सिस्टम कॉल के रूप में डिज़ाइन किया गया था, विशेष रूप से विवश हार्डवेयर और रीयल-टाइम कंप्यूटिंग | रीयल-टाइम सिस्टम पर चलने वाले ऑपरेटिंग सिस्टम के लिए। जबकि 4.4BSD कार्यान्वयन ने vfork कार्यान्वयन से छुटकारा पा लिया, जिससे vfork का व्यवहार fork के समान हो गया, इसे बाद में प्रदर्शन कारणों से NetBSD ऑपरेटिंग सिस्टम में बहाल कर दिया गया। कुछ एम्बेडेड ऑपरेटिंग सिस्टम जैसे कि uClinux फोर्क को छोड़ देते हैं और केवल vfork को लागू करते हैं, क्योंकि उन्हें उन उपकरणों पर काम करने की आवश्यकता होती है जहां मेमोरी मैनेजमेंट यूनिट की कमी के कारण कॉपी-ऑन-राइट लागू करना असंभव है।

रफर्क

यूनिक्स के डिजाइनरों द्वारा बनाई गई बेल लैब्स ऑपरेटिंग सिस्टम की योजना 9 में फोर्क शामिल है, लेकिन rfork नामक एक संस्करण भी है, जो पता स्थान सहित माता-पिता और बच्चे की प्रक्रियाओं के बीच संसाधनों के ठीक-ठाक साझा करने की अनुमति देता है (कॉल स्टैक सेगमेंट को छोड़कर, जो प्रत्येक प्रक्रिया के लिए अद्वितीय है), पर्यावरण चर और फाइलसिस्टम नेमस्पेस; यह इसे प्रक्रियाओं और उनके भीतर थ्रेड (कंप्यूटर विज्ञान) दोनों के निर्माण के लिए एक एकीकृत इंटरफ़ेस बनाता है। फ्रीबीएसडी दोनों और IRIX ने योजना 9 से rfork सिस्टम कॉल को अपनाया, बाद वाले ने इसे sproc नाम दिया।

क्लोन

clone लिनक्स कर्नेल में एक सिस्टम कॉल है जो एक चाइल्ड प्रोसेस बनाता है जो अपने निष्पादन संदर्भ (कंप्यूटिंग) के कुछ हिस्सों को माता-पिता के साथ साझा कर सकता है। FreeBSD के rfork और IRIX के स्पोक की तरह, Linux का क्लोन प्लान 9 के rfork से प्रेरित था और इसका उपयोग थ्रेड्स को लागू करने के लिए किया जा सकता है (हालाँकि एप्लिकेशन प्रोग्रामर आमतौर पर उच्च-स्तरीय इंटरफ़ेस जैसे pthreads, क्लोन के शीर्ष पर कार्यान्वित) का उपयोग करेंगे। प्लान 9 और आईआरआईएक्स से अलग स्टैक सुविधा को छोड़ दिया गया है क्योंकि (लिनस टोरवाल्ड्स के अनुसार) यह बहुत अधिक ओवरहेड का कारण बनता है।

अन्य ऑपरेटिंग सिस्टम में फोर्किंग

OpenVMS ऑपरेटिंग सिस्टम (1977) के मूल डिजाइन में, फोर्किंग के रूप में नई प्रक्रिया के लिए कुछ विशिष्ट पतों की सामग्री के बाद के उत्परिवर्तन के साथ एक कॉपी ऑपरेशन को जोखिम भरा माना जाता था। वर्तमान प्रक्रिया स्थिति में त्रुटियां चाइल्ड प्रक्रिया में कॉपी की जा सकती हैं। यहां, प्रक्रिया स्पॉनिंग के रूपक का उपयोग किया जाता है: नई प्रक्रिया के मेमोरी लेआउट के प्रत्येक घटक को खरोंच से नवनिर्मित किया जाता है। स्पॉन (कंप्यूटिंग) रूपक को बाद में माइक्रोसॉफ्ट ऑपरेटिंग सिस्टम (1993) में अपनाया गया।

वीएम/सीएमएस (ओपनएक्सटेंशन) का पॉज़िक्स-संगतता घटक फोर्क का एक बहुत ही सीमित कार्यान्वयन प्रदान करता है, जिसमें बच्चे को निष्पादित करते समय माता-पिता को निलंबित कर दिया जाता है, और बच्चे और माता-पिता एक ही पता स्थान साझा करते हैं। यह अनिवार्य रूप से एक फोर्क के रूप में लेबल किया गया एक vfork है। (यह केवल CMS अतिथि ऑपरेटिंग सिस्टम पर लागू होता है; अन्य VM अतिथि ऑपरेटिंग सिस्टम, जैसे Linux, मानक फ़ोर्क कार्यक्षमता प्रदान करते हैं।)

आवेदन उपयोग

हेलो, वर्ल्ड! का निम्न संस्करण! कार्यक्रम यांत्रिकी को प्रदर्शित करता है fork सी (प्रोग्रामिंग भाषा) प्रोग्रामिंग भाषा में सिस्टम कॉल। कार्यक्रम दो प्रक्रियाओं में बंट जाता है, प्रत्येक यह तय करता है कि फोर्क सिस्टम कॉल के रिटर्न वैल्यू के आधार पर वे किस कार्यक्षमता का प्रदर्शन करते हैं। हेडर फाइल जैसे बॉयलरप्लेट कोड को छोड़ दिया गया है।

int main(void)
{
    pid_t pid = fork();

    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    else if (pid == 0) {
        printf("Hello from the child process!\n");
        _exit(EXIT_SUCCESS);
    }
    else {
        int status;
        (void)waitpid(pid, &status, 0);
    }
    return EXIT_SUCCESS;
}

इस प्रकार इस कार्यक्रम का एक विच्छेदन है।

   pid_t pid = fork();

में पहला बयान main कॉल करता है fork निष्पादन को दो प्रक्रियाओं में विभाजित करने के लिए सिस्टम कॉल। का वापसी मूल्य fork प्रकार के एक चर में दर्ज किया गया है pid_t, जो प्रक्रिया पहचानकर्ताओं (PIDs) के लिए POSIX प्रकार है।

    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }

माइनस वन एक त्रुटि को इंगित करता है fork: कोई नई प्रक्रिया नहीं बनाई गई थी, इसलिए एक त्रुटि संदेश छपा है।

अगर fork सफल रहा, तो अब दो प्रक्रियाएँ हैं, दोनों क्रियान्वित कर रही हैं main उस बिंदु से कार्य करें जहां fork लौट आया। प्रक्रियाओं को अलग-अलग कार्य करने के लिए, प्रोग्राम को रिटर्न वैल्यू पर ब्रांच (कंप्यूटर साइंस) करना चाहिए fork यह निर्धारित करने के लिए कि क्या यह चाइल्ड प्रोसेस या पैरेंट प्रोसेस के रूप में निष्पादित हो रहा है।

   else if (pid == 0) {
      printf("Hello from the child process!\n");
      _exit(EXIT_SUCCESS);
   }

बाल प्रक्रिया में, वापसी मान शून्य के रूप में प्रकट होता है (जो एक अमान्य प्रक्रिया पहचानकर्ता है)। बाल प्रक्रिया वांछित ग्रीटिंग संदेश प्रिंट करती है, फिर बाहर निकलती है। (तकनीकी कारणों से, POSIX {{mono|_exit}सी मानक के बजाय यहां } फ़ंक्शन का उपयोग किया जाना चाहिए exit समारोह।)

   else {
      int status;
      (void)waitpid(pid, &status, 0);
   }

दूसरी प्रक्रिया, माता-पिता, से प्राप्त करता है fork बच्चे की प्रक्रिया पहचानकर्ता, जो हमेशा एक सकारात्मक संख्या होती है। मूल प्रक्रिया इस पहचानकर्ता को पास करती है waitpid बच्चे के बाहर निकलने तक निष्पादन को निलंबित करने के लिए सिस्टम कॉल। जब ऐसा हो जाता है, तो माता-पिता निष्पादन फिर से शुरू करते हैं और इसके माध्यम से बाहर निकल जाते हैं return कथन।

यह भी देखें

• कांटा बम
• कांटा-निष्पादन
• बाहर निकलें (सिस्टम कॉल)
• स्पॉन (कंप्यूटिंग)
• प्रतीक्षा करें (सिस्टम कॉल)