समानांतर लूप

Question

लिखना मैं एक साधारण उदाहरण पर समानांतर पाश चलाने की कोशिश कर रहा हूं।
मैं क्या गलत कर रहा हूँ?

from joblib import Parallel, delayed 
import multiprocessing 

def processInput(i): 
     return i * i 

if __name__ == '__main__': 

    # what are your inputs, and what operation do you want to 
    # perform on each input. For example... 
    inputs = range(1000000)  

    num_cores = multiprocessing.cpu_count() 

    results = Parallel(n_jobs=4)(delayed(processInput)(i) for i in inputs) 

    print(results) 

कोड के साथ समस्या यह है कि जब अजगर 3 में Windows वातावरण के तहत निष्पादित, यह अजगर समानांतर नौकरियों पर अमल करने की num_cores उदाहरणों को खोलता है, लेकिन केवल एक ही सक्रिय है। यह मामला नहीं होना चाहिए क्योंकि प्रोसेसर की गतिविधि 14% (i7 - 8 तर्क कोर के तहत) के बजाय 100% होनी चाहिए।

अतिरिक्त उदाहरण कुछ भी क्यों नहीं कर रहे हैं?

Answer 1

आपके अनुरोध एक काम बहु कोड प्रदान करने के लिए पर जारी रखते हुए, मेरा सुझाव है कि आप pool_map का उपयोग करें (यदि देरी की कार्यक्षमता महत्वपूर्ण नहीं है), तो मैं आपको एक उदाहरण दूंगा, अगर आप python3 पर काम कर रहे हैं तो इसका उल्लेख करने के लायक है कि आप starmap का उपयोग कर सकते हैं। यह भी उल्लेखनीय है कि यदि आप लौटाए गए परिणामों के क्रम को इनपुट के क्रम से मेल नहीं खाते हैं तो आप map_sync/starmap_async का उपयोग कर सकते हैं।

import multiprocessing as mp 

def processInput(i): 
     return i * i 

if __name__ == '__main__': 

    # what are your inputs, and what operation do you want to 
    # perform on each input. For example... 
    inputs = range(1000000) 
    # removing processes argument makes the code run on all available cores 
    pool = mp.Pool(processes=4) 
    results = pool.map(processInput, inputs) 
    print(results) 

Answer 2

विंडोज पर, मल्टीप्रोसेसिंग मॉड्यूल एकाधिक पायथन दुभाषिया प्रक्रियाओं को शुरू करने के लिए 'स्पॉन' विधि का उपयोग करता है। यह अपेक्षाकृत धीमी है। समांतर कोड चलाने के बारे में स्मार्ट होने की कोशिश करता है। विशेष रूप से, यह बैच आकार को समायोजित करने का प्रयास करता है ताकि एक बैच निष्पादित करने में लगभग आधे सेकेंड लगे। (https://pythonhosted.org/joblib/parallel.html पर batch_size तर्क देखें)

आपका processInput() समारोह इतनी तेजी से कि समानांतर निर्धारित करता है कि यह कई अजगर दुभाषिए ऊपर स्पिन और समानांतर में कोड को चलाने के लिए एक से प्रोसेसर पर क्रमानुसार नौकरियों को चलाने के लिए तेजी से होता है चलाता है।

यदि आप अपने कोर को एकाधिक कोर पर चलाने के लिए मजबूर करना चाहते हैं, तो 1000 को बैच_साइज सेट करने का प्रयास करें या processInput() अधिक जटिल बनाएं ताकि इसे निष्पादित करने में अधिक समय लगे।

संपादित करें: खिड़कियों पर उदाहरण के कार्य में उपयोग में कई प्रक्रियाओं (मैं उपयोग कर रहा हूँ विंडोज 7) से पता चलता है कि:

from joblib import Parallel, delayed 
from os import getpid 

def modfib(n): 
    # print the process id to see that multiple processes are used, and 
    # re-used during the job. 
    if n%400 == 0: 
     print(getpid(), n) 

    # fibonacci sequence mod 1000000 
    a,b = 0,1 
    for i in range(n): 
     a,b = b,(a+b)%1000000 
    return b 

if __name__ == "__main__": 
    Parallel(n_jobs=-1, verbose=5)(delayed(modfib)(j) for j in range(1000, 4000))