'htop' सही CPU% नहीं दिखाता है, लेकिन 'शीर्ष' करता है

Question

mencoderधागे के साथ दौड़ते समय = 4 (एक क्वाड-कोर सीपीयू पर)। मैंने देखा है कि htopइसका सही सीपीयू उपयोग नहीं दिखता है , लेकिन topकरता है।

ऐसा लगता है कि htop केवल एक कोर पर रिपोर्टिंग कर रहा है । इस का एक बग / सीमा है htop ? यहाँ क्या हो रहा है?

वहाँ कोई अन्य प्रविष्टियों के लिए कर रहे हैं mencoder में दिखाने psया htopया top। मुझे लगता है कि 100% का मतलब है कि 1 कोर अधिकतम हो गया है, लेकिन यहां तक ​​कि यह मुझे अजीब लगता है; अन्य कोर के बारे में क्या?

अद्यतन: "सिस्टम मॉनिटर" आउटपुट जोड़ा गया

                  PID   %CPU   COMMAND                    
           "top"  1869   220   mencoder                 
          "htop"  1869    95   mencoder -noodml /media/...  
"System Monitor"  1869   220   mencoder

Comments

क्या झंडे आप htop के लिए उपयोग कर रहे हैं?

— sep332

sep332 ... मैं सिर्फ "htop" चलाता हूं ... इसलिए यह जो भी चूक है उसका मामला है।

— पीटर।

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

— पीटर।

@ पीटर.ओ: गलती से डाउनवोटेड (माउस टचपैड!)। यदि आप अपना पोस्ट संपादित करते हैं तो मैं इसे रद्द कर दूंगा।

— सब्रेवॉल्फी

Answer 1

जैसा कि आपने स्वयं कहा है, आप Hउपयोगकर्ता के धागे दिखाने के लिए हिट कर सकते हैं ।

बस भविष्य के संदर्भ के लिए (और मनोरंजन के लिए), चलो सीपीयू उपयोग की गणना करें!

पृष्ठभूमि की एक बिट:

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

कोई भी प्रक्रिया रन कतार पर "कार्य" करती है, और प्रोसेसर के तैयार होने के बाद, यह उन्हें बंद कर देता है और उन्हें निष्पादित करता है। जब कोई कार्यक्रम सो जाता है, उदाहरण के लिए, यह स्वयं को रन कतार से हटा देता है और "लाइन के अंत" पर लौट आता है, तो एक बार फिर से चलाने के लिए तैयार है।

इस कतार पर छंटनी का प्रक्रियाओं की प्राथमिकता (जिसे "अच्छा मूल्य" भी कहा जाता है - यानी प्रक्रिया संसाधन संसाधनों के बारे में अच्छा है ) के साथ करना है।

कतार की लंबाई प्रणाली के भार को निर्धारित करती है। उदाहरण के लिए 2.5 के लोड का मतलब है कि हर निर्देश के लिए 2.5 निर्देश हैं जो सीपीयू वास्तविक समय में निपट सकता है ।

लिनक्स पर, वैसे, इस लोड की गणना 10ms अंतराल (डिफ़ॉल्ट रूप से) में की जाती है।

अब CPU उपयोग के प्रतिशत मूल्यों पर:

कल्पना कीजिए कि आपके पास दो घड़ियां हैं, एक को बुलाया जाता है tऔर यह वास्तविक समय का प्रतिनिधित्व करता है । यह हर सेकंड के लिए एक सेकंड मापता है। दूसरी घड़ी जिसे हम कहते हैं c। यह केवल तभी चलता है जब करने के लिए प्रसंस्करण होता है। इसका मतलब है, केवल जब एक प्रक्रिया कुछ गणना करती है, तो घड़ी चलती है। इसे CPU टाइम भी कहा जाता है। सिस्टम पर प्रत्येक प्रक्रिया को 'उनमें से एक मिला है।

प्रोसेसर के उपयोग की गणना अब एक ही प्रक्रिया के लिए की जा सकती है:

या सभी प्रक्रियाओं के लिए:

मल्टी कोर मशीन पर, इसके परिणामस्वरूप 3.9 का मान हो सकता है, क्योंकि पूरी तरह से उपयोग किए जाने पर सीपीयू हर सेकंड गणना के चार सेकंड की गणना कर सकता है।

विकिपीडिया यह उदाहरण प्रदान करता है:

6-CPU UNIX मशीन में चलने वाला एक सॉफ्टवेयर एप्लिकेशन उपयोगकर्ता की आवश्यकता को पूरा करने के लिए तीन UNIX प्रक्रियाएँ बनाता है। इन तीन प्रक्रियाओं में से प्रत्येक दो धागे बनाते हैं। सॉफ़्टवेयर एप्लिकेशन का कार्य समान रूप से एप्लिकेशन के लिए बनाए गए निष्पादन के 6 स्वतंत्र थ्रेड्स पर वितरित किया जाता है। यदि संसाधनों के लिए कोई प्रतीक्षा शामिल नहीं है, तो कुल CPU समय छह गुना वास्तविक समय होने की उम्मीद है।

यहाँ एक छोटा अजगर स्निपेट है जो ऐसा करता है

>>> import time
>>> t = time.time()
>>> c = time.clock()
>>> # the next line will take a while to compute
>>> tuple(tuple(i**0.2 for i in range(600)) for i in range(6000))
>>> print (time.clock() / (time.time() - t)) * 100, "%"
66.9384021612 %

एक आदर्श दुनिया में, आप इससे अनुमान लगा सकते हैं कि सिस्टम लोड 100 - 66.93 = 33,1% है। (लेकिन वास्तव में I / O प्रतीक्षा जैसी जटिल चीजों के कारण गलत होगा, शेड्यूलिंग अक्षमताओं और इतने पर)

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

अब वास्तव में, उन प्रसंस्करण समय घड़ियों में से एक से अधिक है। उदाहरण के लिए I / O पर प्रतीक्षा करने के लिए एक है। इसलिए आप I / O संसाधन उपयोग की गणना भी कर सकते हैं।

यह मूल प्रश्न के बारे में उपयोगी नहीं हो सकता है, लेकिन मुझे आशा है कि यह दिलचस्प है। :)

Comments

मुझे वास्तव में अनिश्चितता वाले मूल्यों को शामिल करना चाहिए, क्योंकि इस सरल विधि का उपयोग करके, गणना संभवतः% 1% से बंद हो जाएगी, लेकिन मैं हर किसी को बहुत अधिक बोर नहीं करना चाहता था ।

— Stefano Palazzo

सबक के लिए धन्यवाद। मुझे सबसे ज्यादा पता था लेकिन कुछ चीजें जो मैंने सीखीं उससे ज्यादा विशिष्ट थीं।

— नाइटविशफैन