क्या मैं रास्पबेरी पाई के सीपीयू के सभी 4 कोर का उपयोग कर सकता हूं?

11

मैं सोच रहा था कि क्या सीपीयू के सभी 100% को "चालू" करने का एक सरल तरीका है ताकि मैं तेजी से प्रक्रियाएं चला सकूं (जैसे कि अजगर गणना)।

1) क्या यह संभव है?

2) क्या वापस सामान्य होने के लिए वापस जाने का एक आसान तरीका है?

3) यदि वांछित है तो कम सीपीयू का उपयोग करने का एक तरीका है?

मैं कमांड लाइन इंटरैक्शन की तरह सोच रहा हूं:

pi@raspberry:~ $ sudo turnOnFourCores python run.py

raspbian pi-3 cpu

— NaN
स्रोत

1

संक्षिप्त उत्तर है

— स्टीव रोबिलार्ड

16

लंबा उत्तर है "अगर यह इतना आसान था, तो यह डिफ़ॉल्ट होगा"

— छाया

18

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

— सोहकाहतो 82

13

स्पष्ट करने के लिए, मुझे लगता है कि ओपी को गलतफहमी है कि मल्टी-कोर सीपीयू कैसे काम करते हैं, और आपके उत्तर केवल उनकी गलतफहमी को मजबूत करते हैं।

— सोहकाहतो 82

6

पायथन प्रोग्राम को तेज़ बनाने का सबसे आसान तरीका है कि एक संकलित भाषा में फिर से लिखना (या कम से कम समय में महत्वपूर्ण कार्यों को एसी मॉड्यूल का उपयोग करना)।

— मिलिविएज़ नोव 22'17

21

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

अपडेट करें:

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

— lights0123
स्रोत

अद्यतन - जो सही है - बताता है कि पायथन के संबंध में उत्तर का पहला भाग गलत क्यों है। आप केवल मॉड्यूल C या कुछ संकलित भाषा लिखकर पायथन की इस सीमा के आसपास पहुँच जाते हैं, जिस बिंदु पर आप वास्तव में अब Python नहीं लिख रहे हैं। यदि प्रदर्शन महत्वपूर्ण है, तो संकलित भाषा में जाना सही उत्तर है। (मल्टीप्रोसेसिंग संसाधन उपयोग के दृष्टिकोण से समान नहीं है।)

— ईंट

4

@ ब्रिक स्पष्ट होने के लिए, संकलित भाषा निश्चित रूप से उचित इन-प्रोसेस मल्टीथ्रेडिंग की आवश्यकता नहीं है। हेक, यहां तक कि पायथन की GIL एक कार्यान्वयन विवरण है (लोकप्रिय CPython के लिए दी गई है) - ऐसे अन्य पायथन दुभाषिए हैं जो खुशी से गुणा करेंगे, जैसे कि Jython और IronPython।

— बॉब

4

भ्रम को जोड़ना, अजगर है संकलित किया था, CPython के मामले में यह CPython bytecode के लिए संकलित है जो CPython VM में चलाया जाता है। Jython के लिए, इसे Java bytecode में संकलित किया गया है जो JVM में चलाया जाता है। और अंत में, आयरनपाइथन CIL को संकलित करता है, जो .NET रनटाइम को लक्षित करता है। तो, प्रदर्शन के लिए "एक संकलित भाषा में जाना" वास्तव में कोई मतलब नहीं है;)

— 15:22 बजे मार्सेल

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

— nekomatic

13

मैं सोच रहा था कि क्या सीपीयू के सभी 100% को "चालू" करने का एक सरल तरीका है ताकि मैं तेजी से प्रक्रियाएं चला सकूं (जैसे कि अजगर गणना)।

इस अर्थ में नहीं कि मुझे लगता है कि आप आसन्न हैं। यह पीआई के लिए विशिष्ट मुद्दा नहीं है, या तो, यह एक तार्किक बाधा है।

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

निम्नलिखित सरल गणित अभिव्यक्ति पर विचार करें:

(4 + 2) * 17 / (3 + 6)

इसके समानांतर गणना करने की कुछ क्षमता है, लेकिन यह तार्किक रूप से सीमित है। मैं कहूंगा कि दो से अधिक धागों का कोई मतलब नहीं है, और फिर भी यह केवल एक ही होने जा रहा है:

#1 a) 4 + 2 b) 6 * 17 c) 102 / 9
#2 a) 3 + 6

3 # 6 = 9 की गणना करके थ्रेड # 2 ने योगदान दिया है, थ्रेड # 1 द्वारा चरण C में उपयोग किया जाता है, जिससे यह एक चरण बचता है। लेकिन यह उतना ही दूर है जितना समानांतरवाद यहाँ उपयोगी होगा। जबकि थ्रेड # 2 17/9 की गणना कर सकता है जबकि # 1 6 * 17 कर रहा है, ऐसा करना व्यर्थ होगा, क्योंकि अब आपके पास एक ही लक्ष्य के लिए दो अलग-अलग रास्ते हैं जिन्हें पुन: संयोजित नहीं किया जा सकता है। यानी, # 2 काम कर सकता है:

b) 17 / 9 c) 1.888 * 6

और धागे # 1 (11.333) के रूप में एक ही परिणाम के साथ समाप्त होता है, लेकिन उन्होंने चरण ए से परे एक दूसरे की मदद नहीं की है, इसलिए उनमें से दो का इस लक्ष्य का पीछा करना समय की बर्बादी है।

(ध्यान दें कि यह उदाहरण एक शाब्दिक नहीं है; यह एक तार्किक सिद्धांत को प्रदर्शित करने का इरादा है। उपयोगकर्ता कोड में कार्य को जिस पैमाने पर पिरोया गया है वह बहुत बड़ा है, लेकिन आपको बहु-थ्रेडेड प्रोग्रामिंग में वास्तविक पाठ की आवश्यकता नहीं है। विचार को यहाँ समझें)

कई प्रोसेसरों को एक्सप्लॉइट करने के लिए कोड की आवश्यकता होती है जो इसे करने के लिए लिखा जाता है। आप बस कुछ भी नहीं ले सकते हैं और कह सकते हैं, "ओह सभी 4 कोर का उपयोग करें और इसे तेजी से करें!"। वैसा नहीं होगा। तार्किक रूप से, (.. अधिकांश) समस्याओं और कार्यों में बहुत सारे चरण शामिल हैं जो समानांतर में नहीं हो सकते हैं , उन्हें अनुक्रम में होना चाहिए।

^{1. लेकिन नीचे देखें फेलिक्स डॉमबेक की टिप्पणी; मैं एआई का विशेषज्ञ नहीं हूं। यह भी ध्यान देने योग्य हो सकता है कि पीटर कॉर्डे की टिप्पणियों के अनुसार, समसामयिक तरीके से बहुत बारीक दाने वाली चीजों को अनुकूलित करने के लिए ओएस द्वारा समकालीन निर्देश सेट और प्रोसेसर का शोषण किया जा सकता है, और हार्डवेयर पाइपलाइन भी ऐसा करती हैं, यद्यपि कोर के पार नहीं (एकल) कोर में एक से अधिक चीजें हैं, जो उनके अंतिम निष्पादन से पहले विभिन्न बिंदुओं पर निर्देशों की धारा पर काम कर रही हैं)। मैं यहां उपयोगकर्ता थ्रेड्स के विषय से चिपके रहने की कोशिश कर रहा था क्योंकि मुझे लगता है कि यह कमोबेश वही है जो आपको मिल रहा है।}

— गोल्डीलॉक्स
स्रोत

4

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

— ईंट

4

@Brick "आप इस तरह के व्यक्तिगत अंकगणितीय संचालन के स्तर पर समानांतर नहीं करते हैं।" -> बेशक आप नहीं हैं, लेकिन मैं इसे और अधिक स्पष्ट कर दूंगा कि यह एक सादृश्य है, नट और बोल्ट मल्टी-थ्रेड प्रोग्रामिंग पर एक सबक नहीं है।

— गोल्डीलॉक्स

4

एक उदाहरण के रूप में आपके द्वारा उपयोग की जाने वाली गणना में समानता इतनी स्थानीय है कि यह एक प्रोग्राम में निर्देश-स्तर की समानता पैदा करेगा जो इसकी गणना करता है, और सीपीयू आउट-ऑफ-ऑर्डर निष्पादन के साथ उस समानता का फायदा उठा सकता है ।

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

2

RPi3 एक इन-ऑर्डर 2-वाइड सुपरकेल्सर en.wikipedia.org/wiki/ARM_Cortex-A53 का उपयोग करता है , इसलिए सावधानीपूर्वक निर्देश के साथ एक कंपाइलर अभी भी एक add-दूसरे के बगल में दो निर्देश डालकर ILP का शोषण कर सकता है ताकि वे दोनों एक ही में चल सकें। घड़ी का चक्र। हालांकि, जैसा कि आप बताते हैं, निम्न गुणा और विभाजित आराम डेटा निर्भरता द्वारा क्रमबद्ध किया जाएगा।

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

1

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

— फेलिक्स डॉमबेक

7

अजगर के लिए नहीं।

अन्य लोग आपको थ्रेडिंग देखने के लिए सुझाव दे रहे हैं, जो अधिकांश भाषाओं के लिए एक मान्य उत्तर है, लेकिन उन्होंने इस बात पर ध्यान नहीं दिया कि आप अजगर का उपयोग कर रहे हैं।

अजगर जीआईएल आपको प्रभावी रूप से कई कोर का उपयोग करने की अनुमति नहीं देता है।

— शीघ्र
स्रोत

4

जीआईएल सभी 4 कोर का उपयोग करना थोड़ा अधिक कठिन बना देता है । किसी भी तरह से यह असंभव नहीं है, या यहां तक कि वास्तव में चुनौतीपूर्ण है।

— नकली नाम

5

कई कोर का उपयोग करने के लिए ओएस के थ्रेड-स्तरीय समानता को स्पष्ट रूप से उजागर करने की आवश्यकता होती है, जिसे आमतौर पर प्रोग्रामर को बहु-थ्रेडेड प्रोग्राम लिखने की आवश्यकता होती है। (या अलग-अलग इनपुट पर कई बार एकल-थ्रेडेड प्रोग्राम चलाने के लिए, जैसे संकलन make -j4)

कुछ भाषाओं के कंपाइलर ऑटो-समानांतरकरण का समर्थन करते हैं, हालांकि। उदाहरण के लिए, OpenMP के साथ C या C ++ एक साधारण for()लूप को एक प्रोग्राम में संकलित कर सकता है जो कई थ्रेड्स शुरू करता है।

#pragma omp parallel for
for(int i = 0; i < 1000000; ++i)
{
   A[i] = B[i] * constant + C[i];
}

लेकिन फिर भी, यह तब होता है जब आपने प्रोग्राम लिखा या संकलित किया। वर्तमान हार्डवेयर और OSes के लिए एक-पिरोया प्रोग्राम को गति देने के लिए कई कोर का उपयोग करने का कोई तरीका नहीं है।

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

उस सवाल पर मेरा जवाब कुछ विवरणों में जाता है कि आधुनिक सीपीयू कैसे ठीक-ठीक निर्देश-स्तर की समानता को पाते हैं और उसका फायदा उठाते हैं। (ज्यादातर x86 पर ध्यान केंद्रित कर रहा है)। एक ही बार में उड़ान में कई निर्देश होने से यह सामान्य सीपीयू कैसे काम करता है, इसका कुछ हिस्सा है, और कुछ ऐसा नहीं है जिसे आपको विशेष रूप से सक्षम करने की आवश्यकता है। (प्रदर्शन काउंटर हैं जो आपको यह देखने में मदद कर सकते हैं कि प्रोग्राम को निष्पादित करते समय आपका सीपीयू प्रति घड़ी कितने निर्देशों को चलाने में कामयाब रहा, हालांकि, या अन्य उपाय।)

ध्यान दें कि RPi3 एआरएम कॉर्टेक्स-ए 53 सीपीयू कोर का उपयोग करता है । प्रत्येक कोर 2-वाइड सुपरकेल्कर है (ILP की अनुमति के अनुसार प्रति घड़ी 2 निर्देश), लेकिन अधिक निर्देश-स्तरीय समानता खोजने और विलंबता को छिपाने के लिए निर्देशों को पुन: व्यवस्थित नहीं कर सकता है।

फिर भी, सीपीयू को पाइपलाइन किया जाता है, इसलिए उड़ान में निर्देशों की कुल संख्या (भ्रूण से और पाइपलाइन के अंत में राइट-बैक स्टेज के लिए सभी तरह से डिकोड होती है) महत्वपूर्ण है। जब डेटा निर्भरता चीजों को सीमित नहीं करती है, तो प्रत्येक पाइपलाइन चरण में 2 निर्देश हो सकते हैं जो सीपीयू पर काम कर रहा है, प्रत्येक घड़ी के दौरान 2 निर्देशों के माध्यम से। (यही 2-वाइड का मतलब है।)

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

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

जब आपका कोड आपकी इच्छानुसार धीमा हो जाता है, तो यह सब बहुत कम होता है। यकीन है कि एक कोर्टेक्स-ए 53 में हुड के तहत बहुत अधिक ठंडा सामान है, लेकिन कोर्टेक्स-ए 57 में हुड के नीचे और अधिक ठंडा सामान है (जैसे प्रति घड़ी 3 से अधिक निर्देशों का निष्पादन), और यहां तक कि अधिक Skylake जैसा बड़ा x86 CPU (घड़ी की गति के अंतर का उल्लेख नहीं करने के लिए)।

Cortex-A53 एक https://en.wikipedia.org/wiki/Classic_RISC_pipeline की तुलना में बहुत शानदार है , जो कि मूल MIPS की तरह है, जिनके बारे में आप कंप्यूटर-आर्किटेक्चर वर्ग में सीखेंगे, लेकिन आधुनिक मानकों से यह बहुत कम है।

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

1

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

— बिल के

@BillK निष्पक्ष होने के लिए, उस संदर्भ में "कार्यक्रम" है java, नहीं myapp.jar, और यह निश्चित रूप से एकल पिरोया नहीं है।

— गोल्डीलॉक्स

1

यह सच है, मैं केवल यह इंगित कर रहा था कि रनटाइम को "आपके द्वारा लिखा गया कोड" कैसे डिज़ाइन किया गया था, इस पर निर्भर करते हुए कि एकल थ्रेडेड, एक बहु-थ्रेडेड ऐप के रूप में स्पष्ट रूप से कोडिंग के बिना अतिरिक्त कोर का लाभ उठा सकता है। पाइथन अधिक शक्तिशाली रनटाइम की आपूर्ति कर सकता था, लेकिन यह एक तरह से व्यर्थ होगा। वैसे भी यह बहुत बड़ी छलांग नहीं है - मुझे लगता है कि यहां तक कि जावा केवल एक अतिरिक्त 1/2 कोर की तरह उपयोग करता है जो एक एकल थ्रेडेड ऐप के साथ मदद करता है।

— बिल के

" सिंगल-थ्रेडेड प्रोग्राम को गति देने के लिए कई हार्डवेयर का उपयोग करने के लिए वर्तमान हार्डवेयर और ओएस के लिए कोई रास्ता नहीं है। " और इसके तुरंत बाद आप बताते हैं कि कैसे समानांतर में निर्देश निष्पादित करते हैं।

— थॉमस वेलर

3

@ थोमसवेलर हां, लेकिन पिकी प्रोसेसर होने के लिए कई कोर का उपयोग नहीं करता है; यह एक कोर में निहित है, लेकिन यह कई अनुदेश धाराओं पर काम करने की अनुमति देता है। यानी, यह समानता का एक रूप है, लेकिन यह मल्टी-कोर थ्रेडिंग का एक रूप नहीं है।

— गोल्डीलॉक्स

4

यह सीपीयू कैसे काम करता है ... बिल्कुल नहीं है।

जैसा कि यह वर्तमान में खड़ा है, आपका सीपीयू 100% उपयोग में चलने में पूरी तरह से सक्षम है, यह मानते हुए कि यह 80 डिग्री सेल्सियस या उससे अधिक तापमान से संबंधित मुद्दों के कारण थ्रॉटल नहीं किया जा रहा है। कहा जा रहा है, आप (आम तौर पर) अपने सीपीयू को 100% आंकी नहीं देखना चाहते। यदि आप नियमित रूप से 100% CPU उपयोग करते हैं, तो आपके पास अपने प्रोसेसर को संभालने के लिए बहुत अधिक है। यह हकलाना और आम तौर पर दुखी उपयोगकर्ता अनुभव का कारण होगा।

कुछ और भौतिक चीज़ों की तुलना करने के लिए, आपका सीपीयू उपयोग कार की तरह है। कार 100 मील प्रति घंटे की रफ्तार से चलने में सक्षम है, लेकिन एक अच्छा मौका है कि आपका स्पीडोमीटर उसके नीचे कुछ महत्वपूर्ण रूप से पढ़ता है। जब शहर में, आप कभी भी 25 मील प्रति घंटे के लिए नहीं मिल सकते हैं। लेकिन यह नहीं बदलता है कि कार 100 मील प्रति घंटे जा सकती है। आप बस त्वरक पर जोर से धक्का नहीं दिया है।

यदि आप आरपीआई को अधिक काम करते हैं (त्वरक पर अधिक धक्का), तो आपको सीपीयू उपयोग आंकड़ा ऊपर जाएगा। उदाहरण के लिए, जब आप yesटर्मिनल विंडो में कमांड चलाते हैं तो सीपीयू का उपयोग देखें (याद रखें कि ctrl+cटर्मिनल कमांड समाप्त होता है)। यह आपके CPU को 25% बढ़ा देगा क्योंकि यह आपके चार CPU कोर में से एक को अधिकतम करता है।

— जैकबम001
स्रोत

5

मुझे लगता है कि यह उत्तर भ्रामक है जहां कहा जाता है कि आप आमतौर पर अपने सीपीयू को 100% उपयोग में नहीं चलाना चाहते हैं। संख्यात्मक रूप से गहन अनुप्रयोगों के बहुत सारे हैं जहाँ आप पूरी तरह से 100% उपयोग चाहते हैं क्योंकि आपने गणना के लिए मशीन (या मशीनों) को समर्पित किया है। सच्चा सुपर कंप्यूटर प्राप्त करने के लिए, आपको अक्सर यह साबित करना होगा कि ऐसा करने के लिए आपका कोड पर्याप्त रूप से अनुकूलित है, अन्यथा वे आपको संसाधनों की बर्बादी के रूप में नकार देंगे। यदि आपके पास एक Pi क्लस्टर है, तो आपको सुपर कंप्यूटर प्रदर्शन नहीं मिल रहा है, जाहिर है, लेकिन इसका उपयोग अधिक से अधिक उपयोग करने के लिए अधिक महत्वपूर्ण बना सकता है, कम नहीं!

— ब्रिक

3

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

— गोल्डीलॉक्स

100% सीपीयू उपयोग आमतौर पर खराब यूएक्स का कारण नहीं बनता है। यहां तक कि 1000% काफी अच्छा हो सकता है क्योंकि अधिकांश प्रोग्राम सीपीयू द्वारा सीमित नहीं हैं, लेकिन अन्य कारकों द्वारा। केवल प्रोग्राम जो अत्यधिक सीपीयू लोड के कारण धीमा हो जाते हैं, वे प्रोग्राम हैं जो वास्तव में हर समय सीपीयू का उपयोग कर रहे हैं।

— Oskar Skog

4

अन्य उत्तर अच्छा विवरण देते हैं, लेकिन विशेष रूप से आपके प्रश्न (पते) को संबोधित नहीं करते हैं।

हां, यदि प्रोग्राम (और ऑपरेटिंग सिस्टम) कई कोर के लिए खाते में क्रमादेशित हैं। ('थ्रेडिंग' यहां प्रोग्रामिंग में शब्द है)
कार्य को पूरा करने के लिए मशीन को प्रत्येक कोर के जितना या कम उपयोग करना पड़ता है। इसलिए कुछ भी बदलने की जरूरत नहीं है।
आप अधिकतम उपयोग की सीमा निर्धारित कर सकते हैं , लेकिन सामान्य उपयोग की आवश्यकता नहीं है। यहाँ उत्तरों पर एक नज़र है: - /unix/151883/limiting-processes-to-not-exceed-more-than-10-of-cpu-usage

NB:

यदि आप समग्र रूप से पाई के प्रदर्शन में सुधार करना चाहते हैं, तो आप ओवरक्लॉकिंग में देखना चाहते हैं। यह सीपीयू को तेज दर से चलाने की अनुमति देता है। डाउनसाइड्स गर्मी उत्पादन में वृद्धि, प्रोसेसर के कम जीवनकाल, और बिजली की खपत में वृद्धि करते हैं।

— Stese
स्रोत

2

यदि संभव हो तो मैं स्क्रिप्ट को पैरामीटर करूंगा और उन्हें अलग-अलग पायथन प्रक्रियाओं में निष्पादित करूंगा। उदाहरण के लिए:

cat parameters.txt | xargs -n1 -P4 python run.py

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

— NikoNyrh
स्रोत

पहला भाग: हां, समस्या को हाथ में लेना शर्मनाक रूप से समानांतर है ।

— पीटर मोर्टेंसन

अहा सच, मैं केवल मल्टीप्रोसेसिंग के प्रसंस्करण पूल से परिचित था, mapलेकिन जाहिर है इसमें कई परिष्कृत साझा-मेमोरी निर्माण भी हैं।

— निकोनिरह

1

मुझे लगता है कि ओपी मल्टी-कोर / मल्टी-थ्रेड प्रोग्रामिंग की अवधारणाओं को पूरी तरह से नहीं समझ सकता है और जब तक कि एल्गोरिदम को एक शर्मनाक समानांतर समस्या में आसानी से नहीं बनाया जा सकता है, तब तक मल्टी-कोर के 100% का उपयोग करना कितना मुश्किल है।

अधिक जानकारी के लिए, आप प्रसिद्ध लेख शीर्षक "द फ्री लंच इज़ ओवर" http://www.gotw.ca/publications/concurrency-ddj.htm के बारे में अधिक पढ़ सकते हैं

— sonofusion82
स्रोत

0

यदि आप अपने आरपीआई का परीक्षण करना चाहते हैं। आप यहां केstress रूप में चला सकते हैं , फिर आप देख सकते हैं कि आपके सीपीयू का उपयोग कैसे किया जा रहा है htop। यह उपयोगी है क्योंकि आप देख सकते हैं कि आपका पावर स्रोत पर्याप्त है, यदि यह पर्याप्त नहीं है तो आपका आरपीआई बहुत अधिक वर्तमान (एम्परेज) का उपयोग करने की कोशिश करेगा और यह बंद हो जाएगा।

दूसरी ओर, यदि आप अजगर स्क्रिप्टिंग का उपयोग करना चाहते हैं, तो आपको यह देखना चाहिए कि joblibजब आप प्रक्रियाओं को समानांतर करना चाहते हैं, तो कौन सा महान काम करता है, और इस प्रकार आप अपने इच्छित प्रोसेसर की संख्या का उपयोग करेंगे।

— silgon
स्रोत

0

हालांकि ये सभी उत्तर अलग-अलग तरीकों से सही हैं लेकिन यह सच है कि ऑपरेटिंग सिस्टम लोड को फैलाने के लिए अलग-अलग कोर का उपयोग करेगा। आप इसे एक साधारण अजगर कार्यक्रम (temp.py कहो) के साथ देख सकते हैं

while True:
  x = 1.0

अपने आरपीआई डेस्कटॉप से एक टर्मिनल खोलें और टाइप करें $ topजो प्रोसेसर का काम दिखाएगा। फिर एक और टर्मिनल खोलें python3 temp.pyऔर आपको 100% प्रोसेसर समय के लिए एक पायथन 3 जॉब उदय दिखाई देगा। फिर एक और टर्मिनल खोलें और प्रक्रिया को दोहराएं और देखें कि आप 400% तक कैसे आगे बढ़ते हैं। इसलिए @Shadow ने एक स्तर पर टिप्पणी की कि यह सरल है और यह डिफ़ॉल्ट है। हालांकि, ऐसे प्रोग्राम डिजाइन करना जो समानांतर प्रसंस्करण का उपयोग कर सकते हैं, गैर-तुच्छ हैं जैसा कि अन्य लोगों ने समझाया है।

— paddyg
स्रोत

0

इस जवाब से हां का गुंजायमान हो रहा है! आपको सरल उन्हें पहचानने और उनका उपयोग करने के लिए अपना कार्यक्रम लिखना होगा। ऐसा करने वाले प्रोग्राम कोर का उपयोग कर सकते हैं। मैं जावा में ऐसा करने के लिए मेरा लिखता हूं और इस प्रकार मैं कर सकता हूं।

पायथन डेवलपर्स के उपरोक्त उत्तरों में इस उत्तर की एक बहुत ही सीमित अवधारणा है और इसलिए यह बहुत भ्रामक हो सकता है लेकिन उत्तर हां और केवल हां है!

— Orubel
स्रोत

क्या आप कृपया विस्तार से बता सकते हैं?

— 20

0

चूंकि ओपी ने अपने प्रश्न में अजगर को निर्दिष्ट नहीं किया था, इसलिए मैं दो और आधुनिक भाषाओं का सुझाव देना चाहूंगा जो रास्पबेरी पाई पर ठीक काम करती हैं और समवर्ती उपयोग करने के लिए बहुत आसान तरीके हैं।

मेरी वर्तमान पसंदीदा Rust भाषा है। मैंने पाई पर कार्यक्रम लिखा और संकलित किया है। जंग इस बात में अच्छी है कि यह कई प्रकार के पॉइंटर और रेस-कंडीशन बग्स को रोकता है, जो समवर्ती कोड को लिखना आसान और सुरक्षित बनाता है। Rust का इरादा एक सिस्टम प्रोग्रामिंग लैंग्वेज है, लेकिन यह C बहुत कुछ भी कर सकता है।

ऐसी ही एक अन्य भाषा है गो (जिसे गोलांग भी कहा जाता है जिससे इसे खोजना आसान हो जाता है)। Google टीम द्वारा गो बनाया गया था, और यह एक उचित रूप से परिपक्व भाषा है। गो में कोरआउट बनाना आसान है, जिसे वे "गो दिनचर्या" कहते हैं।

ये दोनों भाषाएँ रास्पबेरी पाई, यहां तक कि जीरो पर भी कोड संकलित कर सकती हैं। हालांकि, वे दोनों एक तेज कंप्यूटर से क्रॉस-संकलित किए जा सकते हैं जो बड़े कार्यक्रमों के लिए अच्छा है।

— NomadMaker
स्रोत