अगर मैं बहुत सारे बैकग्राउंड जॉब शुरू करूँ तो क्या होगा?

Question

मुझे एक उम्मीद स्क्रिप्ट का उपयोग करके 700 नेटवर्क उपकरणों पर कुछ काम करने की आवश्यकता है। मैं इसे क्रमिक रूप से पूरा कर सकता हूं, लेकिन अभी तक रनटाइम लगभग 24 घंटे है। यह ज्यादातर समय इन डिवाइस (पुराने वाले) से कनेक्शन स्थापित करने और आउटपुट में देरी के कारण होता है। मैं दो कनेक्शन स्थापित करने में सक्षम हूं और उन्हें समानांतर रूप से ठीक चलाने में सक्षम हूं, लेकिन मैं इसे कितनी दूर तक बढ़ा सकता हूं?

मुझे नहीं लगता कि मैं उनमें से सभी 700 को एक बार में कर सकता था, निश्चित रूप से नहीं के लिए कुछ सीमा है। टेलनेट कनेक्शन मेरा VM प्रबंधित कर सकता है।

अगर मैंने उनमें से 700 को किसी तरह लूप में शुरू करने की कोशिश की:

for node in `ls ~/sagLogs/`; do  
    foo &  
done

साथ में

• CPU 12 CPU x Intel (R) Xeon (R) CPU E5649 @ 2.53GHz

• मेमोरी 47.94 जीबी

मेरा सवाल यह है कि:

1. क्या सभी 700 उदाहरण संभवतः समवर्ती रूप से चल सकते हैं?
2. जब तक मेरा सर्वर अपनी सीमा तक नहीं पहुँच जाता, तब तक मैं कैसे पहुँच सकता हूँ?
3. जब वह सीमा समाप्त हो जाती है, तो क्या यह अगले यात्रा को बंद करने की प्रतीक्षा fooकरेगा या बॉक्स दुर्घटनाग्रस्त हो जाएगा?

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

Comments

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

— एडम

आपकी कार्य कतार आज 700 हो सकती है, लेकिन क्या आकार का विस्तार हो सकता है? बढ़ने के लिए स्वैप स्पेस देखें - यह संकेत है कि आप मेमोरी लिमिट तक पहुंच गए हैं। और cpu% एक अच्छा उपाय नहीं है (linux / unix के लिए), लोड औसत (रन कतार लंबाई) पर विचार करने के लिए बेहतर है।

— ChuckCottrill

हाल ही में जिस तरह से मैंने अपने स्टिल-थोड़े नए जॉब में प्रोडक्शन को तोड़ दिया, वह गलती से एक बार में एक लाख से ज्यादा शॉर्ट-बैकग्राउंड जॉब चला रहा था। उन्होंने JVMs (वेट वेट द पिचफॉर्क नीचे डाल दिया) को शामिल किया, इसलिए परिणाम सैकड़ों-हजारों त्रुटि रिपोर्ट फाइलों तक 'सीमित' थे जो थ्रेड्स शुरू नहीं हो सके।

— michaelb958 - GoFundMonica

नाइटपिक: आउटपुट को पार्स न करेंls

— l0b0

@ KuboMD और जब तक कोई और कभी भी आपके कोड का उपयोग नहीं करना चाहता।

— l0b0

Answer 1

क्या सभी 700 उदाहरण संभवतः समवर्ती रूप से चल सकते हैं?

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

जब तक मेरा सर्वर अपनी सीमा तक नहीं पहुँच जाता, तब तक मैं कैसे पहुँच सकता हूँ?

यह पूरी तरह से अधिक जानकारी के बिना संक्षिप्त जवाब देना असंभव है। बहुत ज्यादा, आपको मिलने के लिए पर्याप्त याद रखने की आवश्यकता है:

• एक नौकरी की संपूर्ण रन-टाइम मेमोरी आवश्यकताओं, 700 बार।
• कई नौकरियों के प्रबंधन के लिए बैश की मेमोरी आवश्यकताएं (इस बारे में बैश भयानक नहीं है, लेकिन जॉब कंट्रोल बिल्कुल मेमोरी कुशल नहीं है)।
• सिस्टम पर किसी भी अन्य मेमोरी आवश्यकताओं।

यह मानते हुए कि आप (केवल 50GB रैम के साथ फिर से, आप अभी भी अन्य मुद्दों से निपटने के लिए आह्वान करते हैं:

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

जब वह सीमा समाप्त हो जाती है, तो क्या यह अगले बंद को फू से शुरू करने की प्रतीक्षा करेगा या बॉक्स दुर्घटनाग्रस्त हो जाएगा?

यह इस बात पर निर्भर करता है कि कौन सी सीमा हिट है। यदि यह मेमोरी है, तो सिस्टम पर कुछ मर जाएगा (विशेष रूप से, मेमोरी को मुक्त करने के प्रयास में कर्नेल द्वारा मारा जाता है) या सिस्टम स्वयं क्रैश हो सकता है (मेमोरी से बाहर चलने पर जानबूझकर क्रैश करने के लिए सिस्टम को कॉन्फ़िगर करना असामान्य नहीं है)। यदि यह CPU समय है, तो यह बिना किसी समस्या के बस चलता रहेगा, सिस्टम पर और बहुत कुछ करना असंभव होगा। यदि यह नेटवर्क है, तो आप अन्य सिस्टम या सेवाओं को क्रैश कर सकते हैं।

---

यहां आपको वास्तव में क्या चाहिए, एक ही समय में सभी नौकरियों को चलाने के लिए नहीं है। इसके बजाय, उन्हें बैचों में विभाजित करें, और एक ही समय में एक बैच के भीतर सभी नौकरियों को चलाएं, उन्हें खत्म करने दें, फिर अगला बैच शुरू करें। GNU पैरेलल ( https://www.gnu.org/software/parallel/ ) का उपयोग इसके लिए किया जा सकता है, लेकिन यह उत्पादन के माहौल में उस पैमाने पर आदर्श से कम है (यदि आप इसके साथ जाते हैं, तो बहुत आक्रामक न हों,) जैसे मैंने कहा, आप नेटवर्क को स्वाइप कर सकते हैं और सिस्टम को प्रभावित कर सकते हैं अन्यथा आप स्पर्श नहीं करेंगे)। मैं वास्तव में Ansible ( https://www.ansible.com/) की तरह एक उचित नेटवर्क ऑर्केस्ट्रेशन टूल की तलाश करूंगा), क्योंकि यह न केवल आपके समसामयिक मुद्दों को हल करेगा (Ansible बैचिंग करता है जैसे कि मैंने ऊपर उल्लेख किया है स्वचालित रूप से), लेकिन आपको काम करने के लिए कई अन्य उपयोगी सुविधाएं भी प्रदान करती हैं (जैसे कार्यों का सुखद निष्पादन, अच्छी स्थिति रिपोर्ट और मूल एकीकरण अन्य उपकरणों की एक बहुत बड़ी संख्या)।

Comments

सीमित संख्या में बैकग्राउंड टास्क चलाने (bash, perl, python, et al) का उपयोग करने, टास्क पूरा करने के लिए मॉनिटर करने, और पूर्व कार्यों को पूरा करने के रूप में अधिक कार्य चलाने के तरीके हैं। एक सरल तरीका यह होगा कि उपनिर्देशिकाओं में फाइलों द्वारा दर्शाए गए कार्यों के बैचों को इकट्ठा किया जाए, और एक समय में एक बैच की प्रक्रिया की जाए। और भी तरीके हैं ...

— ChuckCottrill

क्या इसमें यूनिक्स जैसी प्रणाली भी शामिल है? और "GUN समानांतर" क्या है?

— बिस्वप्रियाओ

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

— ऑस्टिन हेमेलर्गरन

@Baldrickk geekz.co.uk/lovesraymond/archive/gun-linux

— पाइप

@forest हां, आप सिस्टम को क्रैश होने से बचाने के लिए रिआलिट्स का उपयोग कर सकते हैं, लेकिन उन्हें इस तरह के मामले में सही तरीके से प्राप्त करना आसान नहीं है (आपको यह जानने की आवश्यकता है कि कार्यों के लिए संसाधन की आवश्यकताएं पहले से क्या हैं) और इसकी सुरक्षा नहीं करता है। किसी भी प्रभाव से बाकी नेटवर्क इन नौकरियों का कारण बन सकते हैं (जो स्थानीय प्रणाली को क्रैश करने की तुलना में संभवतः एक बहुत बड़ा मुद्दा है)।

— ऑस्टिन हेमेलर्गरन

Answer 2

यह विशेष रूप से कहना मुश्किल है कि आपके द्वारा वर्णित तरीके से कितने उदाहरण पृष्ठभूमि नौकरियों के रूप में चलाए जा सकते हैं। लेकिन एक सामान्य सर्वर निश्चित रूप से 700 समवर्ती कनेक्शन बनाए रख सकता है जब तक आप इसे सही ढंग से करते हैं। Webservers हर समय ऐसा करते हैं।

क्या मेरा सुझाव है कि आप GNU समानांतर ( https://www.gnu.org/software/parallel/ ) का उपयोग करें या इसे पूरा करने के लिए कुछ समान है? यह आपको पृष्ठभूमि नौकरी दृष्टिकोण के लिए कई फायदे देगा:

• आप आसानी से समवर्ती सत्रों की संख्या को बदल सकते हैं।
• और यह तब तक इंतजार करेगा जब तक कि सत्र नए शुरू होने से पहले पूरा नहीं हो जाता।
• इससे गर्भपात करना आसान हो जाता है।

त्वरित शुरुआत के लिए यहां एक नज़र डालें: https://www.gnu.org/software/parallel/parallel_tutorial.html#A-single-input-source

Comments

दिलचस्प! मैं इस पर एक नज़र डालूँगा। क्या आप जानते हैं कि इस तरह के ऑपरेशन का प्रयास (समानांतर की मदद के बिना) हाइपरविजर को दुर्घटनाग्रस्त कर देगा?

— KuboMD

@ KuboMD अगर आप हाइपरविजर को किसी सांसारिक चीज से क्रैश कर सकते हैं, तो यह हाइपरविजर में एक बग है :)

— hobbs

एक तरफ के रूप में, वेब सर्वर अक्सर थ्रेडिंग या इवेंट-आधारित प्रोसेसिंग (उदाहरण: gunicorn.org ) का उपयोग करते हैं

— ChuckCottrill

Answer 3

&समानांतर प्रसंस्करण का उपयोग कुछ करते समय ठीक है, और जब आप प्रगति की निगरानी करते हैं। लेकिन अगर आप एक कॉर्पोरेट उत्पादन वातावरण में चल रहे हैं, तो आपको कुछ ऐसा चाहिए जो आपको बेहतर नियंत्रण प्रदान करे।

ls ~/sagLogs/ | parallel --delay 0.5 --memfree 1G -j0 --joblog my.log --retries 10 foo {}

यह fooप्रत्येक फ़ाइल के लिए चलेगा ~/sagLogs। यह हर 0.5 सेकंड में एक नौकरी शुरू करता है, यह समानांतर में कई नौकरियों के रूप में संभव के रूप में लंबे समय तक चलेगा जब तक कि 1 जीबी रैम मुफ्त है, लेकिन आपके सिस्टम पर सीमाओं का सम्मान करेगा (जैसे फ़ाइलों और प्रक्रियाओं की संख्या)। आमतौर पर इसका मतलब है कि आप समानांतर में 250 काम कर रहे होंगे, अगर आपने अनुमत खुली फ़ाइलों की संख्या को समायोजित नहीं किया है। यदि आप खुली फ़ाइलों की संख्या को समायोजित करते हैं, तो आपको समानांतर में 32000 चलने में कोई समस्या नहीं होनी चाहिए - जब तक आपके पास पर्याप्त मेमोरी है।

यदि कोई नौकरी विफल हो जाती है (यानी एक त्रुटि कोड के साथ रिटर्न) यह 10 बार वापस लिया जाएगा।

my.log आपको बताएगा कि क्या कोई नौकरी सफल होती है (संभवतः रिटायर होने के बाद) या नहीं।

Comments

यह बहुत ही आशाजनक लग रहा है, धन्यवाद।

— KuboMD

एक सरल परीक्षण कर रहा था cat ~/sagLogs/* >> ~/woah | parallelऔर पवित्र मोली जो तेज था। पलक झपकते ही 1,054,552 लाइनें।

— KuboMD

आपके द्वारा दी गई कमांड में दोहरी पुनर्निर्देशन है, इसलिए मुझे लगता है कि यह वही करता है जो आप इसे करने का इरादा रखते हैं। जीएनयू समानांतर में प्रति काम 10 एमएस का एक ओवरहेड है, इसलिए 1 एम नौकरियों को 3 घंटे के क्रम में लेना चाहिए।

— ओले तागे

यह बिल्कुल भी लागू नहीं होता है यदि आप सभी करना चाहते हैं तो बस फाइलों को संक्षिप्त करना है।

— ओले तांगे

@ KuboMD एक तुच्छ CPU व्यस्त लूप जैसा है, awk 'BEGIN{for(i=rand()*10000000; i<100000000;i++){}}' जिसके साथ खेलने के लिए काम करेगा। या इसे एक कार्य पर आज़माएं, यह sleep 10देखने के लिए कि यह nबहुत सीपीयू समय का उपयोग किए बिना उड़ान में नौकरी रखता है । जैसे time parallel sleep ::: {100..1}नींद को 100 से 1 सेकंड तक चलाना।

— पीटर कॉर्ड्स

Answer 4

अगर मैं बहुत सारे बैकग्राउंड जॉब शुरू करूँ तो क्या होगा?

प्रणाली धीमी और अनुत्तरदायी हो जाएगी, सबसे खराब स्थिति इतनी गैर-जिम्मेदार है कि केवल पावर बटन को धक्का देना और एक हार्ड रिबूट करना सबसे अच्छा होगा ... यह कुछ जड़ के रूप में चल रहा होगा जहां ऐसा करने का विशेषाधिकार था। यदि आपकी बैश स्क्रिप्ट नियमित उपयोगकर्ता विशेषाधिकारों के तहत चल रही है, तो पहली बात यह है कि मन में आता है /etc/security/limits.confऔर /etc/systemd/system.confउसमें मौजूद सभी चर [आदर्श रूप से बोल रहे हैं] उपयोगकर्ता को सिस्टम को ओवरलोड करने से रोकते हैं ।

• cpu = xeon E5649, यह एक 12- कोर cpu है; इसलिए आपके पास 12 प्रक्रियाओं के लिए 12 कोर हैं जो प्रत्येक में बारह कोर में से एक का उपयोग करके 100% पर चलेंगे। यदि आप 24 प्रक्रियाओं को बंद कर देते हैं, तो प्रत्येक बारह कोर पर प्रत्येक में 50% उपयोग पर चलेगा, 700 प्रक्रियाएं = 1.7% लेकिन यह एक कंप्यूटर है जब तक कि ठीक समय पर सब कुछ ठीक से पूरा हो जाता है तब = सफलता; कुशल होना हमेशा प्रासंगिक नहीं होता है।

  1. क्या सभी 700 उदाहरण संभवतः समवर्ती रूप से चल सकते हैं? निश्चित रूप से, 700 एक बड़ी संख्या नहीं है; maxprocउदाहरण के लिए मेरा /etc/security/limits.conf डिफ़ॉल्ट 4,135,275 है

  2. जब तक मेरा सर्वर अपनी सीमा तक नहीं पहुँच जाता, तब तक मैं कैसे पहुँच सकता हूँ? 700 से अधिक मैं निश्चित हूं।

  3. सीमा ... यदि उपयोगकर्ता खाते के तहत स्क्रिप्ट को बंद कर दिया जाता है तो क्या होगा [और आम तौर पर मूल रूप से limits.confबहुत अधिक हर किसी पर लागू होता है] यह है कि स्क्रिप्ट सिर्फ foo &700 बार करने की कोशिश करने के बाद बाहर निकल जाएगी ; फिर आप एक अलग पिड के साथ 700 फू प्रक्रियाओं को देखने की उम्मीद करेंगे, लेकिन आप केवल 456 (यादृच्छिक संख्या पसंद) देख सकते हैं और अन्य 244 कभी भी शुरू नहीं हुए क्योंकि वे कुछ सुरक्षा या सिस्टम की सीमा से अवरुद्ध हो गए।

मिलियन डॉलर का सवाल: यू कितने को समवर्ती रूप से चलाना चाहिए?

नेटवर्क के साथ शामिल होना और आपने कहा कि प्रत्येक टेलनेट कनेक्शन करेगा, शिक्षित अनुमान है कि आप सीपीयू और रैम सीमा के लिए नेटवर्क सीमा और ओवरहेड में चलेंगे। लेकिन मुझे नहीं पता कि आप विशेष रूप से क्या कर रहे हैं, क्या होगा संभावना है कि यू एक बार में सभी 700 को किक कर सकता है, लेकिन चीजें स्वचालित रूप से तब तक अवरुद्ध रहेंगी जब तक कि पिछली प्रक्रियाएं और नेटवर्क कनेक्शन खत्म नहीं हो जाते हैं और विभिन्न सिस्टम सीमाओं के आधार पर समाप्त हो जाते हैं, या ऐसा कुछ होता है पहले 500 बंद हो जाएंगे फिर शेष 200 नहीं होंगे क्योंकि सिस्टम या कर्नेल सीमाएं इसे रोकती हैं। लेकिन हालाँकि कई एक साथ चलते हैं, वहाँ कुछ मधुर होगाजितनी जल्दी हो सके चीजों को प्राप्त करने के लिए स्पॉट करें ... ओवरहेड को कम करना और दक्षता बढ़ाना। 12 कोर (या 24 होने के नाते अगर आपके पास 2 सीपीयू है) तो एक बार में 12 (या 24) के साथ शुरू करें और फिर उस समवर्ती बैच संख्या को 12 या 24 तक बढ़ाएं जब तक कि आप रन सुधार नहीं देखते हैं।

संकेत: Google अधिकतम टेलनेट कनेक्शन और देखें कि यह आपके सिस्टम पर कैसे लागू होता है। इसके अलावा फ़ायरवॉल के बारे में मत भूलना। इसके अलावा प्रक्रिया 700०० के अनुसार आवश्यक मेमोरी की त्वरित गणना करें; सुनिश्चित करें कि <उपलब्ध रैम (आपके मामले में लगभग 50 जीबी) अन्यथा सिस्टम SWAP का उपयोग करना शुरू कर देगा और मूल रूप से अनुत्तरदायी बन जाएगा। 12, 24, की लात तो एन एक समय और मॉनिटर रैम मुक्त पर प्रक्रियाओं, तो वृद्धि एन पहले से ही क्या हो रहा है के कुछ ज्ञान हो रही है।

डिफ़ॉल्ट रूप से, RHEL एकल होस्ट से 10 युगपत सत्रों में टेलनेट कनेक्शनों की संख्या को सीमित करता है। यह एक सुरक्षा विशेषता है ... 10, /etc/xinetd.conf पर सेट करें, "per_source" मान बदलें।