मॉनिटर सिस्टम CPU / सिस्टम कॉल लिनक्स में

Question

मेरे पास कुछ प्रक्रियाएं हैं जो बहुत सारे सिस्टम CPU समय खा रही हैं (जैसा कि vmstat को देखकर निर्धारित किया गया है)। क्या यह पता लगाने का एक आसान तरीका है कि किस तरह के सिस्टम कॉल किए जा रहे हैं?

मुझे पता है कि स्ट्रेस है, लेकिन क्या एक तेज और आसान तरीका है? क्या सिस्टम कॉल के लिए "टॉप" जैसा कुछ मौजूद है?

Comments

स्ट्रेस इसका समाधान है।

— वार्नर

Answer 1

मुझे लगता है कि -cझंडे के साथ स्ट्रेस शायद सबसे करीबी है जिसे मैं जानता हूं। यदि आपने -cध्वज का उपयोग नहीं किया है , तो यह प्रयास करें:

$  sudo strace -c -p 12345

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

यह चलाने के बाद कि आप कितने समय के लिए डेटा एकत्र करना चाहते हैं, Ctrl-Cअपने डेटा संग्रह को रोकने और परिणामों को आउटपुट करने के लिए दबाएं । यह कुछ इस तरह का उत्पादन करेंगे:

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 31.88    0.001738         145        12           futex
 16.79    0.000915          11        80           tgkill
 12.36    0.000674          34        20           read
  9.76    0.000532         266         2           statfs
  8.42    0.000459          13        35           time
  4.38    0.000239           6        40           gettimeofday
  3.65    0.000199           4        48           sigprocmask
  2.94    0.000160          18         9           open
  2.88    0.000157          12        13           stat64
  1.32    0.000072           9         8           munmap
  0.90    0.000049           6         8           mmap2
  0.88    0.000048           3        14         7 sigreturn
  0.79    0.000043           5         9           close
  0.77    0.000042           4        10           rt_sigprocmask
  0.64    0.000035           3        12           setitimer
  0.55    0.000030           5         6         6 rt_sigsuspend
  0.53    0.000029           4         8           fstat64
  0.29    0.000016           8         2           setresuid32
  0.13    0.000007           4         2           _llseek
  0.09    0.000005           3         2           prctl
  0.04    0.000002           2         1           geteuid32
------ ----------- ----------- --------- --------- ----------------
100.00    0.005451                   341        13 total

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

Comments

लानत है तुम, व्यर्थ म्यूटेक्स! हिलाता है मुट्ठी

— गयुस

Answer 2

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

Answer 3

स्ट्रेस स्विच का प्रकार जो मैं उपयोग करता हूं वह यह है।

strace -ffttT -p pid -o /tmp/strace.out

इसका एक उदाहरण जैसा दिखेगा,

19:35:57.485493 mprotect(0x7f35e7472000, 16384, PROT_READ) = 0 <0.000037>
19:35:57.485599 mprotect(0x7f35e7692000, 4096, PROT_READ) = 0 <0.000030>
19:35:57.485697 mprotect(0x7f35e78b7000, 4096, PROT_READ) = 0 <0.000030>
19:35:57.485782 munmap(0x7f35e7896000, 129588) = 0 <0.000037>
19:35:57.485875 set_tid_address(0x7f35e78949d0) = 10730 <0.000029>
19:35:57.485960 set_robust_list(0x7f35e78949e0, 0x18) = 0 <0.000024>
19:35:57.486048 futex(0x7fff8f58628c, FUTEX_WAKE_PRIVATE, 1) = 0 <0.000025>
19:35:57.486131 futex(0x7fff8f58628c, FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME, 1,       NULL, 7f35e7894700) = -1 EAGAIN (Resource temporarily unavailable) <0.000024>

आप सिस्टम कॉल के दायीं ओर स्थित समय अंतर को दिखाते हैं कि एक सिस्टम कॉल से दूसरे में जाने में कितना समय लगा है।

यह आपको सिस्टम कॉल के बीच के समय के अंतर को पकड़ लेगा। इसलिए, जब आप देखते हैं कि अगले सिस्टम कॉल के साथ सिस्टम कॉल में कुछ सेकंड का अंतर है, तो यह कुछ शोर कर रहा है।

एक और तरीका यह है कि इसे गॉर्क के साथ coredump किया जाए। हालांकि, कि gdb के माध्यम से नेविगेट करने के लिए थोड़ा अनुभव की आवश्यकता होती है।

लेकिन, यदि धागा एक कर्नेल थ्रेड है, तो आप इसे स्ट्रेस या कॉर्डपंप नहीं कर सकते। उस मामले में, हमें कुछ अधिक जटिल का उपयोग करना होगा। आरएचईएल 5 कर्नेल में, हम अफीम का उपयोग करते हैं। RHEL6 में, हम perf का उपयोग करते हैं। मैं ऑप्रोफाइल पर परफेक्ट पसंद करता हूं। सिस्टम कॉल को दिखाने वाले प्रारूप जैसे ग्राफ के साथ परफेक्ट डेटा एकत्र किया जा सकता है जहां अधिकतम प्रतिशत सीपीयू का उपयोग किया जा रहा है।

एक परीक्षण पूर्ण के साथ, मैं इसे देखता हूं।

38.06%  swapper  [kernel.kallsyms]  [k] mwait_idle_with_hints                                                                                                               ↑

29.45%  swapper  [kernel.kallsyms]  [k] read_hpet 
4.90%  swapper  [kernel.kallsyms]  [k] acpi_os_read_port                                                                                                                   ▒
4.74%  swapper  [kernel.kallsyms]  [k] hpet_next_event   

यह कर्नेल फ़ंक्शन को दिखाता है जहां 38% CPU समय बिताया जा रहा है। अब, हम फ़ंक्शन की जांच कर सकते हैं और देख सकते हैं कि यह क्या कर रहा है और इसे क्या करना चाहिए।

कुछ उदाहरणों के साथ, यह उतना कठिन नहीं है।