बहुक्रिया के साथ अजवाइन समानांतर वितरित कार्य

Question 1

मेरे पास एक सीपीयू गहन सेलेरी कार्य है। मैं इस कार्य को तेजी से पूरा करने के लिए EC2 इंस्टेंसेस के बहुत से सभी प्रोसेसिंग पॉवर (कोर) का उपयोग करना चाहता हूं (बहुविकल्पी के साथ एक अजवाइन समानांतर वितरित कार्य - मुझे लगता है ) ।

शब्द, थ्रेडिंग , मल्टीप्रोसेसिंग , वितरित कंप्यूटिंग , वितरित समानांतर प्रसंस्करण वे सभी शब्द हैं जिन्हें मैं बेहतर समझने की कोशिश कर रहा हूं।

उदाहरण कार्य:

  @app.task
  for item in list_of_millions_of_ids:
      id = item # do some long complicated equation here very CPU heavy!!!!!!! 
      database.objects(newid=id).save()

ऊपर दिए गए कोड का उपयोग करना (यदि संभव हो तो एक उदाहरण के साथ) कोई इस कार्य को वितरित करने के बारे में कैसे होगा जब यह क्लाउड में सभी उपलब्ध मशीन में सभी कंप्यूटिंग सीपीयू शक्ति का उपयोग करके इस कार्य को विभाजित करने की अनुमति देता है?

Question 2

आपके लक्ष्य हैं:

अपने काम को कई मशीनों में वितरित करें (कंप्यूटिंग / वितरित समानांतर प्रसंस्करण वितरित)
सभी सीपीयू (मल्टीप्रोसेसिंग / थ्रेडिंग) में किसी दिए गए मशीन पर काम वितरित करें

अजवाइन इन दोनों को आपके लिए काफी आसानी से कर सकता है। समझने वाली पहली बात यह है कि प्रत्येक सेलेरी कार्यकर्ता को डिफ़ॉल्ट रूप से कई कार्यों के लिए कॉन्फ़िगर किया गया है क्योंकि एक सिस्टम पर सीपीयू कोर उपलब्ध हैं:

कॉनकरीर, प्रीफ़ॉर्क वर्कर प्रक्रिया की संख्या है जो आपके कार्यों को समवर्ती रूप से संसाधित करने के लिए उपयोग की जाती है, जब ये सभी कार्य करने में व्यस्त हैं नए कार्यों को संसाधित होने से पहले समाप्त होने के लिए किसी एक कार्य के लिए इंतजार करना होगा।

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

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

उस रास्ते से, अगला कदम एक ऐसा कार्य बनाना है जो आपके कुछ सबसेट को संसाधित करने का काम करता है list_of_millions_of_ids। आपके पास यहां कुछ विकल्प हैं - एक है प्रत्येक कार्य को एक ही आईडी संभालना है, इसलिए आप एन कार्यों को चलाते हैं, जहां N == len(list_of_millions_of_ids)। यह गारंटी देगा कि काम आपके सभी कार्यों के बीच समान रूप से वितरित किया गया है, क्योंकि कभी भी ऐसा मामला नहीं होगा जहां एक कार्यकर्ता जल्दी खत्म होता है और बस इंतजार कर रहा है; अगर इसे काम की जरूरत है, तो यह कतार से एक आईडी खींच सकता है। आप एक अजवाइन का उपयोग करके ऐसा कर सकते हैं (जॉन डो द्वारा वर्णित) group।

कार्यशो:

@app.task
def process_id(item):
    id = item #long complicated equation here
    database.objects(newid=id).save()

और कार्यों को निष्पादित करने के लिए:

from celery import group
from tasks import process_id

jobs = group(process_id.s(item) for item in list_of_millions_of_ids)
result = jobs.apply_async()

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

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

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

कार्यशो:

@app.task
def process_ids(items):
    for item in items:
        id = item #long complicated equation here
        database.objects(newid=id).save() # Still adding one id at a time, but you don't have to.

और कार्य शुरू करने के लिए:

from tasks import process_ids

jobs = process_ids.chunks(list_of_millions_of_ids, 30) # break the list into 30 chunks. Experiment with what number works best here.
jobs.apply_async()

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

Question 3

वितरण की दुनिया में केवल एक चीज है जिसे आपको सबसे ऊपर याद रखना चाहिए:

सभी बुराईयो की जड़ समयपूर्व इष्टतमीकरण है। डी। नथ द्वारा

मुझे पता है कि यह स्पष्ट लगता है लेकिन दोहरे चेक को वितरित करने से पहले आप सबसे अच्छा एल्गोरिथ्म का उपयोग कर रहे हैं (यदि यह मौजूद है ...)। यह कहते हुए कि, वितरण का अनुकूलन 3 चीजों के बीच संतुलन का कार्य है:

लगातार माध्यम से डेटा लिखना / पढ़ना,
मध्यम ए से मध्यम बी तक डेटा ले जाना,
डाटा प्रोसेसिंग,

कंप्यूटर बनाये जाते हैं इसलिए आप अपनी प्रोसेसिंग यूनिट (3) के करीब पहुँच जाते हैं और तेज़ और अधिक कुशल (1) और (2) होगा। एक क्लासिक क्लस्टर में आदेश होगा: नेटवर्क हार्ड ड्राइव, स्थानीय हार्ड ड्राइव, रैम, प्रसंस्करण इकाई क्षेत्र के अंदर ... आजकल प्रोसेसर पर्याप्त परिष्कृत होते जा रहे हैं जिन्हें स्वतंत्र हार्डवेयर प्रसंस्करण इकाइयों का एक समूह माना जाता है जिन्हें आमतौर पर कोर कहा जाता है, ये कोर प्रक्रिया है। डेटा (3) थ्रेड्स (2) के माध्यम से। कल्पना करें कि आपका कोर इतना तेज़ है कि जब आप एक थ्रेड के साथ डेटा भेजते हैं, तो आप कंप्यूटर की 50% शक्ति का उपयोग कर रहे हैं, यदि कोर में 2 धागे हैं तो आप 100% का उपयोग करेंगे। प्रति कोर दो थ्रेड्स को हाइपर थ्रेडिंग कहा जाता है, और आपके ओएस को प्रति हाइपर थ्रेडेड कोर में 2 सीपीयू दिखाई देंगे।

प्रोसेसर में थ्रेड्स को प्रबंधित करना आमतौर पर मल्टी-थ्रेडिंग कहा जाता है। ओएस से सीपीयू को प्रबंधित करना आमतौर पर मल्टी-प्रोसेसिंग कहा जाता है। एक समूह में समवर्ती कार्यों का प्रबंधन आमतौर पर समानांतर प्रोग्रामिंग कहा जाता है। क्लस्टर में निर्भर कार्यों को प्रबंधित करना आमतौर पर वितरित प्रोग्रामिंग कहा जाता है।

तो आपकी अड़चन कहां है?

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

अजवाइन के बारे में क्या?

अजवाइन वितरित प्रोग्रामिंग के लिए एक संदेशवाहक ढांचा है, जो संचार के लिए एक ब्रोकर मॉड्यूल (2) और दृढ़ता (1) के लिए एक बैकेंड मॉड्यूल का उपयोग करेगा, इसका मतलब है कि आप सबसे अधिक अड़चनों से बचने के लिए कॉन्फ़िगरेशन को बदलकर (यदि संभव हो तो) सक्षम होंगे आपका नेटवर्क और केवल आपके नेटवर्क पर। एकल कंप्यूटर में सर्वश्रेष्ठ प्रदर्शन प्राप्त करने के लिए पहले अपना कोड प्रोफाइल करें। फिर डिफ़ॉल्ट कॉन्फ़िगरेशन और सेट के साथ अपने क्लस्टर में अजवाइन का उपयोग करें CELERY_RESULT_PERSISTENT=True:

from celery import Celery

app = Celery('tasks', 
             broker='amqp://guest@localhost//',
             backend='redis://localhost')

@app.task
def process_id(all_the_data_parameters_needed_to_process_in_this_computer):
    #code that does stuff
    return result

निष्पादन के दौरान अपने पसंदीदा निगरानी उपकरण खोलें, मैं खरगोश के लिए डिफॉल्ट का उपयोग करता हूं और अजवाइन के लिए फूल और cpus के लिए शीर्ष, आपके परिणाम आपके बैकएंड में सहेजे जाएंगे। नेटवर्क अड़चन का एक उदाहरण कार्य कतार इतनी बढ़ रही है कि वे निष्पादन में देरी करते हैं, आप मॉड्यूल या अजवाइन कॉन्फ़िगरेशन को बदलने के लिए आगे बढ़ सकते हैं, अगर आपकी अड़चन कहीं और नहीं है।

Question 4

इसके लिए groupअजवाइन के कार्य का उपयोग क्यों नहीं किया जाता है?

http://celery.readthedocs.org/en/latest/userguide/canvas.html#groups

मूल रूप से, आपको idsविखंडू (या श्रेणियों) में विभाजित करना चाहिए और उन्हें कार्यों के एक समूह में देना चाहिए group।

अधिक परिष्कृत करने के लिए, विशेष रूप से अजवाइन के कार्यों के परिणामों को एकत्र करने के लिए, मैंने chordइसी तरह के उद्देश्य के लिए सफलतापूर्वक कार्य का उपयोग किया है :

http://celery.readthedocs.org/en/latest/userguide/canvas.html#chords

settings.CELERYD_CONCURRENCYएक संख्या को बढ़ाएं जो उचित है और आप खर्च कर सकते हैं, फिर उन अजवाइन कार्यकर्ता आपके कार्यों को एक समूह या एक काम में तब तक करते रहेंगे जब तक कि काम पूरा न हो जाए।

नोट: एक बग के कारण kombu अतीत में श्रमिकों की उच्च संख्या के लिए पुन: उपयोग करने में परेशानी हुई थी, मुझे नहीं पता कि क्या यह अभी तय है। शायद यह है, लेकिन यदि नहीं, तो CELERYD_MAX_TASKS_PER_CHILD को कम करें।

मेरे द्वारा चलाए गए सरलीकृत और संशोधित कोड पर आधारित उदाहरण:

@app.task
def do_matches():
    match_data = ...
    result = chord(single_batch_processor.s(m) for m in match_data)(summarize.s())

summarizeसभी single_batch_processorकार्यों के परिणाम मिलते हैं। प्रत्येक कार्य किसी भी सेलेरी कार्यकर्ता पर चलता है, kombuवह समन्वय करता है।

अब मैं इसे प्राप्त करता हूं: single_batch_processorऔर summarizeएएलएसओ को अजवाइन के कार्य करने होते हैं, नियमित कार्य नहीं - अन्यथा निश्चित रूप से इसे समानांतर नहीं किया जाएगा (मुझे यकीन नहीं है कि कॉर्ड रचनाकार इसे स्वीकार करेगा यदि यह अजवाइन का कार्य नहीं है)।

Question 5

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

अपने प्रश्न के बारे में: आप अपने EC2 उदाहरणों पर एक और प्रक्रिया बताकर अजवाइन के कामगारों को जोड़ रहे हैं celeryd। आपको कितने श्रमिकों की आवश्यकता है इसके आधार पर और भी उदाहरण जोड़ना चाह सकते हैं।