[Concurrency] कैसे कार्यात्मक भाषाएं (विशेष रूप से एरलांग) स्केल कैसे करती हैं?



Answers

संदेश कतार प्रणाली शांत है क्योंकि यह प्रभावी रूप से "अग्नि-और-प्रतीक्षा-परिणाम-परिणाम" प्रभाव उत्पन्न करती है जो सिंक्रोनस भाग है जिसके बारे में आप पढ़ रहे हैं। यह अविश्वसनीय रूप से भयानक बनाता है कि इसका मतलब है कि लाइनों को अनुक्रमिक रूप से निष्पादित करने की आवश्यकता नहीं है। निम्नलिखित कोड पर विचार करें:

r = methodWithALotOfDiskProcessing();
x = r + 1;
y = methodWithALotOfNetworkProcessing();
w = x * y

एक पल के लिए विचार करें कि विधि WithalotOfDiskProcessing () को पूरा होने में लगभग 2 सेकंड लगते हैं और वह तरीका WithalotOfNetworkProcessing () को पूरा करने में लगभग 1 सेकंड लगते हैं। एक प्रक्रियात्मक भाषा में इस कोड को चलाने के लिए लगभग 3 सेकंड लगेंगे क्योंकि लाइनों को अनुक्रमिक रूप से निष्पादित किया जाएगा। हम एक विधि को पूरा करने के लिए समय बर्बाद कर रहे हैं जो एक संसाधन के लिए प्रतिस्पर्धा किए बिना दूसरे के साथ एक साथ चल सकता है। कोड की एक कार्यात्मक भाषा रेखाओं में जब निर्देशक उन्हें कोशिश करेगा तो निर्देश नहीं देगा। एक कार्यात्मक भाषा निम्नलिखित की तरह कुछ कोशिश करेगी:

Execute line 1 ... wait.
Execute line 2 ... wait for r value.
Execute line 3 ... wait.
Execute line 4 ... wait for x and y value.
Line 3 returned ... y value set, message line 4.
Line 1 returned ... r value set, message line 2.
Line 2 returned ... x value set, message line 4.
Line 4 returned ... done.

कितना मजेदार था वो? कोड के साथ आगे बढ़कर और केवल वांछित प्रतीक्षा करें जहां हमने प्रतीक्षा समय को स्वचालित रूप से दो सेकंड तक घटा दिया है! : डी तो हाँ, जबकि कोड तुल्यकालिक है, यह प्रक्रियात्मक भाषाओं की तुलना में एक अलग अर्थ होता है।

संपादित करें:

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

Question

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

फिर, हाल ही में मैंने Codemash स्मिथ में " Codemash स्मिथ की" मूल बातें "प्रस्तुत की।

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

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

मैं समझता हूं कि एरलंग के रचनाकारों ने जानबूझकर समेकन समस्याओं से बचने के लिए समर्थन थ्रेडिंग से परहेज किया, लेकिन मैंने सोचा कि स्केलेबिलिटी प्राप्त करने के लिए बहु थ्रेडिंग आवश्यक है।

कार्यात्मक प्रोग्रामिंग भाषाएं मूल रूप से थ्रेड-सुरक्षित कैसे हो सकती हैं, फिर भी स्केल?




पूरी तरह कार्यात्मक भाषा में, मूल्यांकन का आदेश कोई फर्क नहीं पड़ता - एक फ़ंक्शन एप्लिकेशन एफएन (arg1, .. argn) में, एन तर्कों का समानांतर में मूल्यांकन किया जा सकता है। यह एक उच्च स्तर (स्वचालित) समांतरता की गारंटी देता है।

Erlang एक प्रक्रिया मॉडेल का उपयोग करता है जहां एक प्रक्रिया एक ही वर्चुअल मशीन, या एक अलग प्रोसेसर पर चलाया जा सकता है - बताने का कोई तरीका नहीं है। यह केवल इसलिए संभव है क्योंकि प्रक्रियाओं के बीच संदेशों की प्रतिलिपि बनाई जाती है, कोई साझा (परिवर्तनीय) स्थिति नहीं है। बहु-प्रोसेसर paralellism बहु थ्रेडिंग की तुलना में बहुत दूर चला जाता है, क्योंकि धागे साझा स्मृति पर निर्भर करते हैं, यह 8-कोर CPU पर समानांतर में चलने वाले 8 थ्रेड हो सकते हैं, जबकि बहु-प्रोसेसिंग हजारों समांतर प्रक्रियाओं तक स्केल कर सकती है।







मुख्य बात जो एरलांग को स्केल करने में सक्षम करती है वह समवर्ती से संबंधित है।

एक ऑपरेटिंग सिस्टम दो तंत्र द्वारा समेकन प्रदान करता है:

  • ऑपरेटिंग सिस्टम प्रक्रियाओं
  • ऑपरेटिंग सिस्टम धागे

प्रक्रियाएं राज्य साझा नहीं करती हैं - एक प्रक्रिया डिज़ाइन द्वारा किसी अन्य को क्रैश नहीं कर सकती है।

थ्रेड्स शेयर स्टेटस - एक धागा डिज़ाइन द्वारा किसी अन्य को क्रैश कर सकता है - यह आपकी समस्या है।

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

ये Erlang प्रक्रिया संदेश भेजकर एक दूसरे से बात करते हैं (Erlang वीएम द्वारा संचालित ऑपरेटिंग सिस्टम नहीं)। Erlang प्रक्रिया एक प्रक्रिया आईडी (पीआईडी) का उपयोग कर एक-दूसरे को संबोधित करती है जिसमें तीन भाग का पता होता है <<N3.N2.N1>>

  • प्रक्रिया एन एन 1 पर
  • वीएम एन 2 चालू
  • भौतिक मशीन एन 3

एक ही वीएम पर दो प्रक्रियाएं, एक ही मशीन या दो मशीनों पर अलग-अलग वीएम पर एक ही तरीके से संवाद करती है - इसलिए आपकी स्केलिंग भौतिक मशीनों की संख्या से स्वतंत्र होती है जिसे आप अपने आवेदन पर तैनात करते हैं (पहले सन्निकटन में)।

Erlang केवल मामूली अर्थ में थ्रेडसेफ है - इसमें धागे नहीं हैं। (वह भाषा जो एसएमपी / बहु-कोर वीएम प्रति कोर एक ऑपरेटिंग सिस्टम थ्रेड का उपयोग करती है)।




Links