एनएलपी | निष्पादन के साथ समानांतर में प्रसंस्करण सूचियाँ

| | | | | | | | | | | | | | | | | | | |

नीचे दिए गए कोड में, पूर्णांकों को केवल दोगुना किया जाता है, कोई भी साफ गणना की जा सकती है। यह निष्पादन द्वारा निष्पादित किया जाने वाला मॉड्यूल है। यह 2 टुपल्स (i, arg) प्राप्त करता है, मानता है कि arg एक संख्या है, और वापस भेजता है (i, arg * 2)।

कोड:

<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

<कोड क्लास = "कीवर्ड"> अगर <कोड वर्ग = "सादा"> __ नाम__ <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "स्ट्रिंग"> `__channelexec__` :

< के लिए /code> (i, arg) in channel:

<कोड वर्ग = "सादा"> channel.send ((i, arg * 2 ))

उपयोग करने के लिए सूची में प्रत्येक आइटम को दोगुना करने के लिए यह मॉड्यूल, प्लिस्ट मॉड्यूल आयात करें और plists .map () पर कॉल करें। एक रिमोट_डबल मॉड्यूल और डबल करने के लिए पूर्णांकों की एक सूची।

कोड: प्लिस्ट का उपयोग करना


इंपोर्ट <कोड क्लास = "प्लेन"> प्लिस्ट, रिमोट_डबल

<कोड क्लास = "प्लेन"> प्लिस्ट। map (remote_double, range ( 10 ))

आउटपुट:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 

मानचित्र ( ) फ़ंक्शन को plists.py में परिभाषित किया गया है। यह एक शुद्ध मॉड्यूल, एक तर्क सूची, और एक वैकल्पिक दो-टुपल सूची (कल्पना, गिनती) लेता है। डिफ़ॉल्ट रूप से, विनिर्देशों का उपयोग किया जाता है [(' popen ', 2)], जिसका अर्थ है कि उपयोगकर्ता दो स्थानीय गेटवे और चैनल खोलेगा। एक बार जब ये पाइप खुल जाते हैं, तो उपयोगकर्ता उन्हें एक इटरटूल लूप में रख सकता है, जो एक अनंत इटरेटर बनाता है जो अंत तक पहुंचते ही शुरुआत में वापस चला जाता है।

अब प्रत्येक तर्क को तर्क के रूप में भेजा जा सकता है। प्रसंस्करण के लिए पाइप में, और चूंकि चैनल चक्रीय हैं, प्रत्येक चैनल को तर्कों का लगभग समान वितरण प्राप्त होता है। यहीं पर मैं आया — जिस क्रम में परिणाम लौटाए जाते हैं वह अज्ञात है, इसलिए i , सूची में प्रत्येक तर्क की अनुक्रमणिका के रूप में, चैनल को और उससे पास किया जाता है ताकि उपयोगकर्ता परिणामों को मूल क्रम में जोड़ सके . फिर मल्टीचैनल प्राप्त कतार के साथ परिणामों की प्रतीक्षा करें और उन्हें मूल तर्कों के समान लंबाई की पूर्व-पॉप्युलेटेड सूची में डालें। सभी अपेक्षित परिणाम प्राप्त करने के बाद, गेटवे से बाहर निकलें और नीचे दिए गए कोड में दिखाए अनुसार परिणाम लौटाएं —

कोड:


<कोड वर्ग = "कीवर्ड"> आयात <कोड वर्ग = "सादा"> itertools, निष्पादन

<कोड वर्ग = "कीवर्ड"> def <कोड क्लास = "फ़ंक्शंस"> मैप <कोड क्लास = "प्लेन"> (मॉड, आर्ग्स, स्पेक्स <कोड क्लास = "कीवर्ड"> = <कोड क्लास = " सादा"> [( <कोड वर्ग = "स्ट्रिंग"> `पॉपेन` <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 2 )]):

Gateway < कोड वर्ग = "कीवर्ड"> = <कोड वर्ग =" सादा "> []

कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "सादा"> चैनल <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> []

<कोड वर्ग = "अपरिभाषित रिक्त स्थान ">

< कोड वर्ग = "कीवर्ड"> के लिए

के लिए i in <कोड वर्ग = "फ़ंक्शंस"> श्रेणी <कोड वर्ग = "सादा"> (गिनती):

<कोड वर्ग = "सादा"> जीडब्ल्यू < कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> execnet.makegateway (कल्पना)

<कोड वर्ग = "सादा"> Gateway.append (gw )

channel.append (gw.remote_exec (mod))


चक्र <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> itertools.चक्र (चैनल)


कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कीवर्ड"> के लिए <कोड वर्ग = "सादा"> i, तर्क <कोड वर्ग = "कीवर्ड"> <में /कोड> <कोड वर्ग = "कार्य"> गणना करें <कोड वर्ग = "सादा"> (तर्क):

<कोड वर्ग = "अपरिभाषित स्थान"> <कोड वर्ग = "सादा"> चैनल <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "कार्य" > अगला <कोड वर्ग = "सादा"> (चक्र)

<कोड वर्ग = "सादा"> channel.send ((i, arg))

<कोड वर्ग = "सादा"> एमसीएच <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा" > execnet.MultiChannel (चैनल)

<कोड वर्ग = "सादा"> कतार <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> mch.make_receive_queue ()

<कोड वर्ग ="अपरिभाषित रिक्त स्थान"> <कोड वर्ग ="सादा "> एल <कोड वर्ग ="कीवर्ड"> = <कोड वर्ग ="functions "> len (args)

# लंबाई l की एक सूची बनाता है,

# जहां प्रत्येक तत्व कोई नहीं है

परिणाम <कोड वर्ग = "कीवर्ड"> = <सह डी क्लास = "सादा"> [ <कोड वर्ग = "रंग 1"> कोई नहीं <कोड वर्ग = "सादा">] <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> एल

<कोड वर्ग = "कीवर्ड"> के लिए <कोड वर्ग = "सादा"> मैं <कोड वर्ग = "कीवर्ड"> में <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा"> (एल):

<कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "सादा"> चैनल, (i, परिणाम) <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> कतार। प्राप्त करें ()

<कोड वर्ग = "सादा"> परिणाम [i] <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "plai n"> परिणाम

< कोड वर्ग =" अपरिभाषित रिक्त स्थान ">

<कोड वर्ग = "कीवर्ड"> के लिए <कोड वर्ग = "सादा"> जीडब्ल्यू <कोड वर्ग = "कीवर्ड"> में "> गेटवे:

<कोड वर्ग = "सादा"> gw.exit ()

< कोड वर्ग = " अपरिभाषित स्थान "> return results

तालिका>

कोड: युक्ति को बदलकर समांतरता बढ़ाएँ


<कोड वर्ग = " सादा"> plists. <कोड वर्ग = "कार्य"> नक्शा <कोड वर्ग = "सादा"> (रिमोट_डबल, <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = " प्लेन"> ( 10 ), [( `popen` ) कोड> <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 4 <कोड वर्ग = "सादा">)])

आउटपुट:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 

हालाँकि, अधिक समांतरता का अर्थ आवश्यक रूप से तेज़ प्रसंस्करण नहीं है। यह उपलब्ध संसाधनों पर निर्भर करता है, और जितने अधिक गेटवे और चैनल खुलते हैं, उतना ही अधिक ओवरहेड होता है। आदर्श रूप से, संसाधन उपयोग को अधिकतम करने के लिए प्रति सीपीयू कोर में एक गेटवे और चैनल होना चाहिए। किसी भी स्वच्छ मॉड्यूल के साथ plists.map () का उपयोग तब तक करें जब तक वह प्राप्त करता है और 2 टुपल्स वापस भेजता है, जहां i पहला तत्व है। यह पैटर्न सबसे अधिक उपयोगी होता है जब कई संख्याएं होती हैं जिन्हें जितनी जल्दी हो सके संसाधित करने के लिए संसाधित करने की आवश्यकता होती है।