समानांतर पायथन

Question

में साझा मूल्य मैं प्रदर्शन-महत्वपूर्ण स्क्रिप्ट विकसित करने के लिए समानांतर पाइथन का उपयोग कर रहा हूं। मैं सिस्टम पर चल रही 8 प्रक्रियाओं के बीच एक मान साझा करना चाहता हूं। कृपया छोटे उदाहरण से क्षमा करें लेकिन यह मेरे प्रश्न को दिखाता है।

def findMin(listOfElements): 
    for el in listOfElements: 
     if el < min: 
      min = el 

import pp 
min = 0 
myList = range(100000) 
job_server = pp.Server() 
f1 = job_server.submit(findMin, myList[0:25000]) 
f2 = job_server.submit(findMin, myList[25000:50000]) 
f3 = job_server.submit(findMin, myList[50000:75000]) 
f4 = job_server.submit(findMin, myList[75000:100000]) 

पीपी दस्तावेज़ प्रक्रियाओं में डेटा साझा करने के तरीके का वर्णन नहीं करते हैं। क्या यह संभव है?

यदि हां, तो क्या एक मानक लॉकिंग तंत्र (जैसे थ्रेडिंग मॉड्यूल में) है यह पुष्टि करने के लिए कि एक समय में केवल एक अपडेट किया जाता है?

l = Lock() 
if(el < min): 
    l.acquire 
    if(el < min): 
     min = el 
    l.release 

मैं समझता हूँ कि मैं मुख्य थ्रेड में एक स्थानीय मिनट रख सकता है और तुलना 4 एक बार लौट आए, लेकिन मूल्य साझा करते हुए मैं अपने BFS द्विआधारी पेड़ से कुछ बेहतर छंटाई कर सकते हैं और संभवतः पाश पुनरावृत्तियों का एक बहुत बचाने के लिए ।

धन्यवाद

जोनाथन

Answer 1

असल में, http://www.parallelpython.com/content/view/17/31/#CALLBACK पर एक उदाहरण है और वे बस थ्रेड मॉड्यूल से ताले का उपयोग करते हैं।

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

Answer 2

मैं पीपी मॉड्यूल के बारे में यकीन नहीं है लेकिन आप हमेशा एक खरोंच फ़ाइल में सबसे कम मूल्य की दुकान कर सकते हैं। मेरी एकमात्र चिंता यह होगी कि आप अपना अधिकांश समय लॉक प्राप्त करने और जारी करने में व्यतीत करेंगे। एकमात्र अपवाद होगा यदि आपका el < min ऑपरेशन समय लेने वाला है।

मैं वास्तव में कहूंगा कि आपकी "विलय" तकनीक शायद जाने का तरीका है।

और बीटीडब्ल्यू, मैं समझता हूं कि आप ब्रेवटी के लिए अपने कोड का एक सरल उदाहरण दे रहे हैं, लेकिन min का उपयोग एक परिवर्तनीय नाम के रूप में नहीं करते हैं ... यह आपको डिबगिंग के दौरान बहुत सारे सिर-दर्द का कारण बनता है।

Answer 3

आप मूल्य साझा करके किसी भी पुनरावृत्ति को सहेज नहीं पाएंगे, आपको कम से कम एक बार सूची में से प्रत्येक तत्व को पढ़ने की आवश्यकता है। इसके अलावा, यह धीमा हो जाएगा, क्योंकि जब भी आप साझा मूल्य का उपयोग करते हैं तो आपको लॉक करने की आवश्यकता होती है।

यदि आप अधिक प्रदर्शन चाहते हैं, तो आपको प्रत्येक भाग के लिए एक मिनट की गणना करनी चाहिए और इन परिणामों की तुलना मुख्य धागे में करें।

दूसरी ओर, अन्य प्रक्रियाओं में सूची उत्तीर्ण करने से एक ही पास में सूची के न्यूनतम मूल्य को खोजने से अधिक संसाधन संसाधन हो सकता है।

Answer 4

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