प्रत्येक उपयोगकर्ता द्वारा उपयोग किए जाने वाले CPU कोर की संख्या को कोई कैसे प्रतिबंधित कर सकता है?

Question

हमारे पास एक कंप्यूटर है जिसके सीपीयू में 32 कोर हैं और यह कुछ अलग उपयोगकर्ताओं द्वारा प्रोग्राम चलाने के लिए उपयोग किया जा रहा है। क्या प्रत्येक उपयोगकर्ता द्वारा किसी भी समय उपयोग की जाने वाली कोर की संख्या को प्रतिबंधित करने का कोई तरीका है ताकि एक उपयोगकर्ता सभी सीपीयू शक्ति का एकाधिकार न करे?

Comments

उत्तर नहीं, केवल एक विचार है। आप कई वर्चुअल मशीन स्थापित करना चाहते हैं। प्रत्येक में केवल सीमित मात्रा में सीपीयू-एस हो सकता है। प्रत्येक उपयोगकर्ता केवल वर्चुअल मशीनों में से एक पर होगा, और उस वीएम पर उपयोगकर्ता सीपीयू उपयोग में सीमित होंगे। यह हो सकता है कि कुछ वर्चुअलाइजेशन सॉफ्टवेयर्स के पास इसके समर्थन के लिए उपकरण हों।

— १

@ghellquist आपको वह उत्तर देना चाहिए

— स्लीबेटमैन

@ghellquist: आप संभवतः लिनक्स कंटेनरों की तरह कुछ हल्का-फुल्का चाहते हैं, यदि आप चाहते हैं कि विभिन्न उपयोगकर्ता केवल कुछ सीपीयू देखें। (उदाहरण के लिए जब वे एक ओपनएमपी या अन्य प्रोग्राम शुरू करते हैं जो कोर के रूप में कई थ्रेड्स के रूप में शुरू होता है, तो यह कोर की मात्रा के लिए एक उपयुक्त संख्या शुरू करेगा जिसे आप प्रत्येक उपयोगकर्ता को वास्तव में उपयोग करने दे रहे हैं)। केवीएम की तरह पूर्ण वर्चुअलाइजेशन, वीटी-एक्स या एएमडी-वी जैसे हार्डवेयर समर्थन के साथ भी प्रदर्शन लागत होती है, जब वीएम को बाहर निकलने से बचा जाता है, तब भी पृष्ठ तालिकाओं के अतिरिक्त स्तरों से, कोड में जो किसी भी टीएलबी को बहुत सारी मेमोरी को छूने से चूक जाता है।

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

मुझे क्षमा करें, लेकिन क्या इसकी कोई आवश्यकता भी है? बहु-उपयोगकर्ता प्रणाली के रूप में, डिफ़ॉल्ट रूप से लिनक्स पहले से ही प्रीमेप्टिव मल्टीटास्किंग को लागू करता है, इसलिए ऐसी स्थिति जहां एक एकल (गैर-दुर्भावनापूर्ण) उपयोगकर्ता सिर्फ अपने लिए पूरे सिस्टम को हॉग करता है, उसे ऊपर नहीं आना चाहिए।

— घन

Answer 1

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

NAME
       nice - run a program with modified scheduling priority

SYNOPSIS
       nice [OPTION] [COMMAND [ARG]...]

DESCRIPTION
       Run  COMMAND  with an adjusted niceness, which affects process scheduling.  With
       no COMMAND, print the current niceness.  Niceness values range  from  -20  (most
       favorable to the process) to 19 (least favorable to the process).

यह एक महान उपकरण है जो एक प्रक्रिया की प्राथमिकता निर्धारित करता है। इसलिए यदि केवल एक उपयोगकर्ता कुछ चला रहा है, तो उन्हें उतना ही सीपीयू समय मिलेगा जितना उन्हें जरूरत होगी, लेकिन अगर कोई अन्य व्यक्ति अपना खुद का (भी niced) काम शुरू करता है, तो वे अच्छे होंगे और एक दूसरे के साथ साझा करेंगे। इस तरह, यदि आपके उपयोगकर्ता सभी आदेशों को लॉन्च करते हैं nice 10 command, तो कोई भी संसाधनों को हॉगिंग नहीं करेगा (और कोई भी सर्वर को अपने घुटनों पर नहीं लाएगा)।

ध्यान दें कि एक उच्च अच्छा मूल्य का मतलब कम प्राथमिकता है। यह एक उपाय है कि हमें कितना अच्छा होना चाहिए और हम जितने अच्छे हैं, उतना ही हम साझा करते हैं।

यह भी ध्यान दें कि यह मेमोरी आवंटन को प्रबंधित करने में मदद नहीं करेगा, यह केवल CPU शेड्यूलिंग को प्रभावित करता है। इसलिए यदि कई उपयोगकर्ता कई मेमोरी-इंटेंसिव प्रक्रियाओं को लॉन्च करते हैं, तो भी आपको समस्या होगी। यदि यह एक समस्या है, तो आपको उचित कतारबद्ध प्रणालियों जैसे टोक़ में देखना चाहिए ।

Comments

आपके उत्तर के लिए धन्यवाद। कुछ "वर्कलोड मैनेजर" हैं जैसे SLURM लेकिन वे कई नोड्स वाले कंप्यूटर के लिए हैं। मुझे लगता है कि यह समझ में आता है कि लोगों ने एकल नोड कंप्यूटर के लिए समान ऐप विकसित नहीं किया है क्योंकि उतनी मांग नहीं है।

— रेजा

@ रेज़ा nice, जो आप वर्णन करते हैं , उससे बहुत अधिक वही है जो आपको चाहिए।

— टेराडॉन

@ रेज़ा: ऐसा इसलिए है क्योंकि ओएस पहले से ही ऐसा करता है। यह स्वचालित रूप से आवश्यकतानुसार उपलब्ध सीपीयू को थ्रेड / प्रक्रियाओं में समय-साझा करता है।

— ब्लूराजा - डैनी पफ्लुगुफ्ट

Answer 2

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

cgroups

लिनक्स के पास cgroupsप्रक्रियाओं के लिए उपलब्ध संसाधनों को प्रतिबंधित करने के उद्देश्य से अक्सर उपयोग किया जाता है। एक बहुत ही संक्षिप्त शोध से, आप आर्क विकी में मतलाब (एक वैज्ञानिक सॉफ्टवेयर) विन्यास के साथ एक उदाहरण पा सकते हैं /etc/cgconfig.conf:

group matlab {
    perm {
        admin {
            uid = username;
        }
        task {
            uid = username;
        }
    }

    cpuset {
        cpuset.mems="0";
        cpuset.cpus="0-5";
    }
    memory {
        memory.limit_in_bytes = 5000000000;
    }
}

इस तरह के विन्यास को प्रभावी होने के लिए, आपको प्रक्रिया को cgexecकमांड के माध्यम से चलाना होगा , जैसे एक ही विकी पेज से:

$ cgexec -g memory,cpuset:matlab /opt/MATLAB/2012b/bin/matlab -desktop

taskset

एक संबंधित सवाल पूछो Ubuntu और पर कैसे लिनक्स में एक सीपीयू कोर करने के लिए एक प्रक्रिया को सीमित करने के? यूनिक्स और लिनक्स साइट पर [डुप्लिकेट]taskset प्रक्रिया के लिए सीपीयू को सीमित करने के लिए उपयोग करने का एक उदाहरण दिखाते हैं। पहले प्रश्न में, यह किसी विशेष उपयोगकर्ता के लिए सभी प्रक्रियाओं को पार्स करने के माध्यम से हासिल किया गया है

$ ps aux | awk '/^housezet/{print $2}' | xargs -l taskset -p 0x00000001

अन्य प्रश्न में, एक प्रक्रिया अपने आप शुरू हो जाती tasksetहै:

$ taskset -c 0 mycommand --option  # start a command with the given affinity

निष्कर्ष

हालांकि प्रक्रियाओं को सीमित करना निश्चित रूप से संभव है, ऐसा लगता है कि विशेष उपयोगकर्ताओं के लिए इसे प्राप्त करना इतना आसान नहीं है। लिंक्ड आस्क उबंटू पोस्ट में उदाहरण प्रत्येक उपयोगकर्ता से संबंधित प्रक्रियाओं के लिए लगातार स्कैनिंग और tasksetप्रत्येक नए पर उपयोग करने की आवश्यकता होगी। सीपीयू के गहन अनुप्रयोगों को चुनिंदा रूप से चलाने के लिए एक अधिक उचित दृष्टिकोण होगा, या तो के माध्यम से cgexecया taskset; CPUS की विशिष्ट संख्या तक सभी प्रक्रियाओं को प्रतिबंधित करने का भी कोई मतलब नहीं है, खासकर उन लोगों के लिए जो वास्तव में अपने कार्यों को तेजी से चलाने के लिए समानता और संगति का उपयोग करते हैं - उन्हें विशिष्ट संख्या में सीपीयू तक सीमित करने से प्रसंस्करण धीमा हो सकता है। इसके अतिरिक्त, टेर्डन के जवाब के रूप में यह संसाधनों की बर्बादी है

के माध्यम से आवेदन पत्र का चयन चल रहा है tasksetया cgexecउन्हें पता है कि वे क्या अनुप्रयोगों चला सकते हैं यह बताने के लिए अपने उपयोगकर्ताओं के साथ संवाद स्थापित करने की आवश्यकता है, या स्क्रिप्ट जो के माध्यम से आवेदन पत्र का चयन का शुभारंभ करेंगे आवरण बनाने taskselया cgexec।

इसके अतिरिक्त, सीपीयू की संख्या की सीमा तय करने के बजाय उपयोगकर्ता या समूह की प्रक्रियाओं की संख्या पर विचार किया जा सकता है। यह /etc/security/limits.confफ़ाइल के माध्यम से प्राप्त किया जा सकता है ।

यह सभी देखें

• किसी दिए गए प्रक्रिया के लिए संसाधन उपयोग को कैसे सीमित करें?

Comments

खैर, वहाँ cgrulesengd और cgrules.conf है जो स्वचालित रूप से cgxec के साथ अपनी प्रक्रिया चलाने वाले उपयोगकर्ताओं पर निर्भर रहने के बजाय उपयोगकर्ता / समूह के आधार पर उचित cgroup में प्रक्रियाओं को स्थानांतरित करने के लिए है। लेकिन ऐसा लगता है, उबंटू में इसे स्थापित करना कुछ गैर-तुच्छ है।

— हंस-जैकब

@ हंस-जैकब यह कुछ हद तक जटिल दिखता है, इसके अलावा GRUB में कर्नेल झंडे जोड़ने की आवश्यकता होती है। संभवतः मशीन के उद्यम स्तर के लिए, जहां आपके पास बहुत सारे उपयोगकर्ता हैं और वे सिस्टम को क्रैश नहीं करना चाहते हैं, यह संभवतः सार्थक है, लेकिन डेस्कटॉप के लिए - बहुत अधिक काम। लिंक करने के लिए धन्यवाद।

— सेर्गेई कोलोडियाज़नी

sched_setaffinity(2)आत्मीयता मुखौटा भर में संरक्षित है execve(2), और कहा कि एक बच्चे को यह विरासत में मिला है fork(2)। इसलिए यदि आप किसी उपयोगकर्ता के लिए शेल (या किसी एक्स सेशन के लिए उनका ग्राफिकल शेल) को टास्क करते हैं, तो वे जो कुछ भी उस शेल से शुरू करेंगे, डिफ़ॉल्ट रूप से, उसी आत्मीयता मास्क का उपयोग करेंगे।

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

एक संभावित नकारात्मक कार्यक्रम ऐसे प्रोग्राम हैं जो यह जांचते हैं कि कितने सीपीयू मशीन को तय करते समय कितने थ्रेड शुरू करने हैं; वे कोर की संख्या के लिए बहुत सारे थ्रेड होंगे जो वे वास्तव में अनुसूचित होंगे। क्या आपको पता चला कि क्या cgroups उस बारे में कुछ कर सकते हैं?

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

@PeterCordes स्पेलिंग खोल विचार दिलचस्प लगता है। मुझे उस पर गौर करना होगा। धन्यवाद ! दूसरी टिप्पणी के रूप में, नहीं, मैंने इस बिंदु पर cgroups पर्याप्त शोध नहीं किया है।

— सेर्गी कोलोडियाज़नी