एर्लैंग और इसकी प्रक्रियाएं

0 प्रस्तावना

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

वास्तविकता के निर्माण के लिए प्रत्येक प्रोग्रामिंग भाषा का अपना प्रतिमान होता है। कार्यात्मक भाषाओं में, कम्प्यूटेशन प्रक्रिया को फ़ंक्शन के मूल्यों की गणना के रूप में व्याख्या की जाती है, अनिवार्य भाषाओं में, इसके विपरीत, कम्प्यूटेशनल प्रक्रिया को निर्देशों के रूप में वर्णित किया जाता है जो कार्यक्रम की स्थिति को बदलते हैं।

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

1 प्रक्रियाओं के साथ काम करें

Erlang भाषा उन प्रक्रियाओं का एक हल्का मॉडल लागू करती है जो एक आभासी मशीन में चलती हैं - BEAM (बोगडान / Björn की Erlang Abstract मशीन), यह मॉडल आपको इसकी अनुमति देता है:

• जल्दी से बनाने, प्रक्रियाओं को नष्ट;
• संदेश के माध्यम से प्रक्रियाओं के बीच बातचीत का एकमात्र तरीका है;
• प्रक्रियाएं स्मृति साझा नहीं करती हैं और पूरी तरह से स्वतंत्र हैं;
• आप बड़ी संख्या में प्रक्रियाएँ बना सकते हैं;
• एसएमपी पर अनुप्रयोगों के आसान स्केलिंग।

१.१ प्रक्रिया निर्माण

निम्नलिखित कार्यों का उपयोग प्रक्रियाओं को बनाने के लिए किया जाता है (स्लैश उन तर्कों की संख्या को इंगित करता है जो फ़ंक्शन ले सकते हैं):

• एर्लांग: स्पॉन / 1/2/3/4 - एक नियमित प्रक्रिया बनाएं;
• erlang: spawn_link / 1/2/3/4 - एक प्रक्रिया बनाएं और इसे कॉलिंग प्रक्रिया के साथ संबद्ध करें;
• erlang: spawn_monitor / 1/3;
• पूल: pspawn / 3 - पूल में नोड्स (न्यूनतम लोड) में से एक पर एक प्रक्रिया बनाएं;
• पूल: pspwn_link / 3 - पिछले पैराग्राफ के समान, केवल कॉलिंग प्रक्रिया और निर्मित होने के बीच एक कनेक्शन बनाया जाता है।

इन कार्यों के अलावा, दस्तावेज़ीकरण [1] में, कोई भी कार्य करने और प्रक्रियाओं में हेरफेर करने के उद्देश्य से कई कार्यों को पा सकता है।
अब एक सरल प्रक्रिया बनाते हैं और इसे चलाते हैं। इंटरैक्टिव शेल लॉन्च करें और निम्नलिखित कमांड निष्पादित करें:

Eshell V5.8 (abort with ^G)
1> Fun = fun() -> receive after infinity -> ok end end.
#Fun<erl_eval.20.67289768>
2> Pid = spawn(Fun).
<0.33.0>
3>

पहली पंक्ति में, हम एक फ़ंक्शन बनाते हैं जो प्रक्रिया का निकाय होगा, फिर स्पॉन / 1 फ़ंक्शन का उपयोग करके प्रक्रिया स्वयं बनाएं, प्रक्रिया बनाई गई है और पहचानकर्ता <0.33.0> को इसे सौंपा गया है। अब हम फ़ंक्शन को c: i / 0 (c वह मॉड्यूल कहते हैं जिसमें Erlang शेल में संवादात्मक कार्य के लिए कार्य शामिल हैं):

3> i().
Pid Initial Call Heap Reds Msgs
Registered Current Function Stack
<0.0.0> otp_ring0:start/2 987 2581 0
...
<0.33.0> erlang:apply/2 233 18 0
erl_eval:receive_clauses/8 10

हम देखते हैं कि हमारी प्रक्रिया काम कर रही है। इसके अलावा, प्रक्रियाओं पर नजर रखने के लिए, आप पैमान ग्राफिकल उपयोगिता को चला सकते हैं:

5> pman:start().
<0.37.0>
6>

1.2 प्रक्रियाओं के बीच संचार

अब आइए सबसे सरल उदाहरण देखें कि कैसे प्रक्रियाएं एक दूसरे के साथ संवाद कर सकती हैं। ऐसा करने के लिए, हम एक छोटा मॉड्यूल लिखेंगे (एरलांग पर प्रोग्राम लिखने और डिबग करने के लिए, लेखक Emacs + Erlang मोड + डिस्टल का एक गुच्छा उपयोग करता है):

1. -मॉड्यूल (खरीद)।
2. -एक्सपोर्ट ([प्रारंभ / 0, पी / 0])।
4. start () ->
5. स्पॉन (proc, p, [])।
7. p () ->
8. प्राप्त
9. {Pid, Msg} जब is_pid (Pid) -> है
10. io: प्रारूप ( "हैलो से प्रूव: ~ पी, मेसग: ~ पी ~ एन" , [पीआईडी, एमएसजी]),
11. पीआईडी! संदेश,
12. पी ();
13. रोक ->
14. ठीक;
15. _ ->
16. io: प्रारूप ( "अज्ञात प्रकार का संदेश ~ n" , []),
17. पी ()
18. अंत।

मॉड्यूल की संरचना काफी सरल है: पहली पंक्ति मॉड्यूल के नाम का वर्णन करती है, इसे फ़ाइल के नाम से मेल खाना चाहिए (इस मामले में, फ़ाइल को proc.erl कहा जाता है), दूसरी पंक्ति में हम दो फ़ंक्शन निर्यात करते हैं, पहली प्रक्रिया बनाने के लिए है और दूसरा वर्णन करता है। शरीर का कार्य। प्रक्रिया बनाने के लिए, हम तीन तर्कों के साथ स्पॉन फ़ंक्शन के संस्करण का उपयोग करते हैं, उन्हें टपल {M, F, A} द्वारा वर्णित किया जा सकता है, जहां M वह मॉड्यूल है जिसमें फ़ंक्शन F स्थित है, तर्क A की सूची के साथ कहा जाता है (इस मामले में, फ़ंक्शन का कोई तर्क नहीं है) । निम्नलिखित संरचना का उपयोग प्रक्रिया निकाय के लिए किया जाता है:

Receive
Pattern1 when Guard1 -> exp-11,...exp-1n;
...
Pattern1 when Guard1 -> exp-m1,...exp-mn
after Time -> exp-k1,...exp-kh
End

जहां पैटर्न प्राप्त संदेश के मिलान के लिए एक टेम्पलेट है, एमएस में इंगित अतिरिक्त स्थिति, समय - टाइमर, एमएस में संकेत दिया जाता है, अगर कतार एक निर्दिष्ट समय के लिए खाली है।

अब हमारे मॉड्यूल को संकलित करें और एक प्रक्रिया बनाने का प्रयास करें।

1> c("proc").
{ok,proc}
2> Pid = proc:start().
<0.37.0>
3> Pid ! {self(), "Hello from shell"}.
Hello from proc: <0.30.0>, mesg: "Hello from shell"
{<0.30.0>,"Hello from shell"}
4> flush().
Shell got "Hello from shell"
ok
5>

पहली पंक्ति में, हम अपने मॉड्यूल को संकलित करते हैं, फिर एक प्रक्रिया बनाते हैं। चर Pid प्रक्रिया पहचानकर्ता को संग्रहीत करता है, जो ऑपरेटर का उपयोग करता है!, एक संदेश को tuple {self (), "..."} के रूप में भेजता है, जहां स्व / 0 फ़ंक्शन उस प्रक्रिया के पहचानकर्ता को वापस लौटाता है जिसमें हम - प्रक्रिया एक संवादात्मक शेल है।

एक संदेश बनाने के बाद, बनाई गई प्रक्रिया उसे कतार से बाहर ले जाती है और {Pid, Msg} के साथ इस मामले में एक टेम्पलेट के साथ तुलना करती है, जिसके बाद वह प्राप्त संदेश को वापस भेजती है। इस मामले में फ्लश / 0 फ़ंक्शन को इंटरेक्टिव शेल में भेजे गए सभी संदेशों को त्यागने की आवश्यकता है, यह आवश्यक है क्योंकि इस प्रक्रिया में एक ब्लॉक प्राप्त नहीं होता है।

एक अभ्यास के रूप में, मैं पाठकों को दो स्वतंत्र प्रक्रियाओं का निर्माण करने का सुझाव देता हूं, जो प्रक्रियाओं का आदान-प्रदान करते हैं, उदाहरण के लिए, यूरालंग शेल से कमांड पर, पहला नंबर की एक जोड़ी को दूसरे पर भेजता है, जो उन्हें रकम देता है और उन्हें वापस पहले भेजता है, और यह पहले से ही शेल में उत्तर प्रदर्शित करता है।

2 गहरी खुदाई

आइए प्रक्रियाओं से संबंधित कुछ और मुद्दों को देखें: सबसे पहले, प्रक्रिया अनुसूचक कैसे काम करता है, और दूसरी बात, यह देखें कि आप इस प्रक्रिया के बारे में क्या जानकारी सीख सकते हैं।

२.१ प्रक्रिया अनुसूचक

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

ऐसे कार्य हैं जिनके साथ आप नियोजन प्रक्रिया को प्रभावित कर सकते हैं (erangang: यील्ड / 0, erlang: bump_reductions / 1), लेकिन उनका उपयोग केवल दुर्लभ मामलों में किया जाना चाहिए (जैसा कि प्रलेखन में कहा गया है [1], इन कार्यों को भविष्य के रिलीज़ में बदला या हटाया जा सकता है) )। संदेश के लिए प्रतीक्षा करने वाली एक प्रक्रिया को फिर से शेड्यूल किया जाएगा जैसे ही एक संदेश इसकी कतार में दिखाई देता है या प्राप्त ब्लॉक आग में एक टाइमर होता है, जिसके बाद इसे अनुसूचक कतार में अंतिम स्थान पर रखा जाता है।

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

प्राथमिकताओं को सामान्य और निम्न को आपस में जोड़ा जा सकता है, उदाहरण के लिए: आपके पास सामान्य के साथ सैकड़ों प्रक्रियाएं हैं और कम के साथ कई हैं, इस मामले में अनुसूचक पहले निम्न की प्राथमिकता के साथ प्रक्रियाओं को निष्पादित कर सकता है और उसके बाद ही सामान्य हो सकता है।

2.2 आंतरिक प्रक्रिया की जानकारी

प्रक्रियाओं के साथ काम करने के लिए कई कार्यों में से एक बहुत ही दिलचस्प है: erlang: process_info / 1 या erlang: process_info / 2, इस फ़ंक्शन का उपयोग करके आप प्रक्रिया शब्दकोश, कचरा संग्रहकर्ता, आकार, लिंक की गई प्रक्रियाओं और अन्य रोचक चीजों के बारे में विस्तृत जानकारी प्राप्त कर सकते हैं (पूर्ण) दस्तावेज़ में सूची देखें [1])।

फ़ंक्शन का पहला संस्करण (एक तर्क के साथ) केवल डिबगिंग उद्देश्यों के लिए उपयोग करने की सिफारिश की जाती है - यह प्रक्रिया का पूरा विनिर्देश देता है, बाकी सब के लिए दूसरे संस्करण का उपयोग करना बेहतर होता है।

आइए एक सरल फ़ंक्शन लिखें जो निम्नलिखित प्रक्रिया की जानकारी को आउटपुट करेगा: पंजीकृत नाम; वह कार्य जिसके द्वारा प्रक्रिया उत्पन्न हुई थी; लिंक की गई प्रक्रियाओं की सूची।

1. -मॉड्यूल (परीक्षण)।
2. -एक्सपोर्ट ([जानकारी / 1])।
4. जानकारी (Pid) ->
5. युक्ति = [पंजीकृत_नाम, प्रारंभिक_ लिंक, लिंक],
6. केस process_info (Pid, कल्पना)
7. अपरिभाषित ->
8. अपरिभाषित;
9. परिणाम ->
10. [{pid, Pid} | परिणाम]
11. अंत।

पंक्ति 5 में, हम एक विनिर्देश बनाते हैं जिसके अनुसार प्रक्रिया के बारे में जानकारी प्राप्त होगी। हम शेल लॉन्च करते हैं, मॉड्यूल संकलित करते हैं और इसका परीक्षण करते हैं।

3> processes().
[<0.0.0>,<0.3.0>,<0.5.0>,<0.6.0>,<0.8.0>,<0.9.0>,<0.10.0>,
<0.11.0>,<0.12.0>,<0.13.0>,<0.14.0>,<0.15.0>,<0.16.0>,
<0.17.0>,<0.18.0>,<0.19.0>,<0.20.0>,<0.21.0>,<0.23.0>,
<0.24.0>,<0.25.0>,<0.26.0>,<0.30.0>]
4> test:info(pid(0,0,0)).
[{pid,<0.0.0>},
{registered_name,init},
{initial_call,{otp_ring0,start,2}},
{links,[<0.5.0>,<0.6.0>,<0.3.0>]}]
5>

पंक्ति 3 में हमें सभी चलने वाली प्रक्रियाओं की एक सूची मिलती है, फिर हम अपने फ़ंक्शन को कॉल करते हैं, जिससे पता चलता है कि पंजीकृत प्रक्रिया का नाम <0.0.0> init है, इसे otp_ring0: start / 2 और तीन अन्य प्रक्रियाओं को इससे लिंक किया गया है।

अगले लेख में, हम प्रक्रियाओं को एक दूसरे से जोड़ने और उनकी स्थिति को ट्रैक करने के तरीके के बारे में देखेंगे।

संदर्भ

1. उत्कृष्ट ऑनलाइन प्रलेखन ।
2. प्रक्रियाओं के बारे में बुनियादी जानकारी ।
3. वर्चुअल मशीन डिजाइन में सबसे आगे ।
4. फ्रांसेस्को सेसरिनी और साइमन थॉम्पसन द्वारा ERLANG प्रोग्रामिंग
5. नियोजन प्रक्रियाओं के बारे में ।