लिनक्स में पीआईडी ​​द्वारा सी से एक प्रक्रिया के सीपीयू उपयोग की गणना कैसे करें?

Question

मैं प्रोग्रामेटिक रूप से [C] लिनक्स में दिए गए प्रोसेस ID के लिए CPU उपयोग% की गणना करना चाहता हूं।

हम किसी दिए गए प्रोसेस के लिए रियलटाइम CPU उपयोग% कैसे प्राप्त कर सकते हैं?

इसे और स्पष्ट करने के लिए:

• मैं प्रदान की गई प्रक्रिया या प्रक्रिया के लिए सीपीयू के उपयोग को निर्धारित करने में सक्षम होना चाहिए।
• प्रक्रिया बच्चे की प्रक्रिया नहीं होनी चाहिए।
• मैं 'सी' भाषा में समाधान चाहता हूं।

Comments

शीर्ष के आउटपुट (grep-ing) को पकड़ने के बारे में क्या।

— शाम 14:59

यह वास्तव में कुशल करने का सबसे अच्छा तरीका नहीं है; y

— कोडिंगफ्रीक

शायद 'टॉप' शुरू करने के लिए "महंगी" सिस्टम कॉल की आवश्यकता होगी।

— लीरन ओरवी

@ लिरन: सही कहा :)

— vpram86

चीजों को करने के इस तरीके के बारे में भूल जाइए .... C

— कोडिंगफ्रीक में

Answer 1

आपको डेटा को पार्स करने की आवश्यकता है /proc/<PID>/stat। ये पहले कुछ क्षेत्र हैं ( Documentation/filesystems/proc.txtआपके कर्नेल स्रोत से):

Table 1-3: Contents of the stat files (as of 2.6.22-rc3)
..............................................................................
 Field          Content
  pid           process id
  tcomm         filename of the executable
  state         state (R is running, S is sleeping, D is sleeping in an
                uninterruptible wait, Z is zombie, T is traced or stopped)
  ppid          process id of the parent process
  pgrp          pgrp of the process
  sid           session id
  tty_nr        tty the process uses
  tty_pgrp      pgrp of the tty
  flags         task flags
  min_flt       number of minor faults
  cmin_flt      number of minor faults with child's
  maj_flt       number of major faults
  cmaj_flt      number of major faults with child's
  utime         user mode jiffies
  stime         kernel mode jiffies
  cutime        user mode jiffies with child's
  cstime        kernel mode jiffies with child's

तुम शायद के बाद utimeऔर / या हो stime। आपको उस cpuपंक्ति को भी पढ़ना होगा /proc/stat, जो इस प्रकार है:

cpu  192369 7119 480152 122044337 14142 9937 26747 0 0

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

दोनों पढ़ें utimeऔर stimeप्रक्रिया के लिए आप में रुचि रखते हैं, और पढ़ने time_totalसे /proc/stat। फिर एक-दूसरे के लिए सो जाओ, और उन सभी को फिर से पढ़ें। अब आप नमूना समय के साथ प्रक्रिया के CPU उपयोग की गणना कर सकते हैं:

user_util = 100 * (utime_after - utime_before) / (time_total_after - time_total_before);
sys_util = 100 * (stime_after - stime_before) / (time_total_after - time_total_before);

सही बात?

Comments

एक "जिफ़ी" सीपीयू समय की एक इकाई है। वास्तव में यह दीवार-घड़ी के समय से मेल खाती है, वास्तुकला पर निर्भर करता है और आपकी कर्नेल को कैसे कॉन्फ़िगर किया गया है, लेकिन महत्वपूर्ण बात यह है कि /proc/statआपको बताता है कि सीपीयू ने कुल मिलाकर कितनी जीफिज को निष्पादित किया है, और /proc/<PID>/statआपको बताता है कि कितने जिफियों द्वारा निष्पादित किया गया है एकल प्रक्रिया।

— कैफे

@advocate: यह एक छद्म फ़ाइल है जो कर्नेल से प्रक्रिया निष्पादन आँकड़े प्राप्त करने के लिए एक इंटरफ़ेस लागू करती है।

— कैफ़े

खेतों के बारे में अधिक जानकारी के लिए लोगों की तलाश करने के लिए: man procक्या आपका दोस्त है (खोज के लिए /proc/[pid]/stat)

— RedShadow

Zizzu (नीचे) द्वारा प्रदान किए गए एक के साथ कैफे के समाधान की तुलना करते हुए, कैफे का समाधान सिस्टम और उपयोगकर्ता समय को अलग-अलग देता है लेकिन सीपीयू की संख्या के साथ इनमें से किसी भी मान को गुणा नहीं करता है। क्या ऐसा नहीं करना चाहिए?

— linuxfan

जाहिर तौर पर ओपी असहमत था। यहां प्रमुख अंतर्दृष्टि /procछद्म फाइल सिस्टम का उपयोग करना है: मानक सी फ़ाइल सिस्टम एक्सेस फ़ंक्शन का शिक्षण fopen()और scanf()बिंदु के बगल में है।

— कैफ़े

Answer 2

getrusage () वर्तमान प्रक्रिया या उसके बच्चे के उपयोग को निर्धारित करने में आपकी मदद कर सकता है

अद्यतन: मैं एक एपीआई याद नहीं कर सकते। लेकिन सभी विवरण / प्रोक / पीआईडी / स्टेट में होंगे, इसलिए यदि हम इसे पार्स कर सकते हैं, तो हम प्रतिशत प्राप्त कर सकते हैं।

संपादित करें: चूंकि सीपीयू% गणना के लिए सीधे आगे नहीं है, आप यहां नमूना प्रकार का उपयोग कर सकते हैं। एक समय में एक पीआईडी ​​के लिए समय और उपयोग पढ़ें और 1 सेकंड के बाद फिर से समान मान पढ़ें। अंतर खोजें और सौ से विभाजित करें। आप पिछले एक सेकंड के लिए उस प्रक्रिया का उपयोग करेंगे।

(कई प्रोसेसर होने पर अधिक जटिल हो सकते हैं)

Comments

एक प्रक्रिया के CPU उपयोग की गणना करने में getrusage () सिस्टम कॉल कैसे मदद करता है ??

— कोडिंगफ्रीक

@codingfreak। मैंने सवाल गलत समझा। अब यू अपडेट होने के बाद, यह स्पष्ट है।

— vpram86

@ एविएटर सीपीयू% = (प्रोसेसेर्टाइम + प्रोसेसकर्मल) / (सीपीयूसर्टाइम + सीपीयू कर्नेलम) मैं "प्रोसेसरटाइम" और इतने पर कैसे मान प्राप्त कर सकता हूं। ??? मुझे "/ proc / PID / स्टेट" फ़ाइल में अलग-अलग मान दिखाई देते हैं। तो कौन सा किस मूल्य से मेल खाता है ??

— कोडिंगफ्रीक

@ कोडिंगफ्रीक: सीपीयू समय की गणना करना मुश्किल है। यू सभी पीआईडी ​​आंकड़ों के माध्यम से लूप करने की आवश्यकता है जो मुझे लगता है (हालांकि निश्चित नहीं)

— vpram86

@ एविएटर ऐसा करने के लिए कोई रास्ता या अन्य होगा ... क्योंकि यहां तक ​​कि शीर्ष जैसे अनुप्रयोगों को अपने आउटपुट में दिखाने के लिए सीपीयू उपयोग की गणना करनी चाहिए

— कोडिंगफ्रीक

Answer 3

मेरे जैसे शुरुआती लोगों के लिए आसान कदम:

1. /proc/statपाने के लिए पहली पंक्ति पढ़ें total_cpu_usage1।

    sscanf(line,"%*s %llu %llu %llu %llu",&user,&nice,&system,&idle);
    total_cpu_usage1 = user + nice + system + idle;

2. सीपीयू के उपयोग को जानना चाहते हैं, इस प्रक्रिया की पीआईडी /proc/pid/statकहां pidहै, इस तरह पढ़ें :

    sscanf(line,
    "%*d %*s %*c %*d" //pid,command,state,ppid

    "%*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu"

    "%lu %lu" //usertime,systemtime

    "%*ld %*ld %*ld %*ld %*ld %*ld %*llu"

    "%*lu", //virtual memory size in bytes
    ....)

3. अब योग usertimeऔर systemtimeऔर प्राप्तproc_times1
4. अब 1 सेकंड या अधिक प्रतीक्षा करें
5. इसे फिर से करते हैं, और पाने के total_cpu_usage2औरproc_times2

सूत्र है:

(number of processors) * (proc_times2 - proc_times1) * 100 / (float) (total_cpu_usage2 - total_cpu_usage1)

आप सीपीयू की राशि प्राप्त कर सकते हैं /proc/cpuinfo।

Comments

आपका समाधान अच्छा है लेकिन सीपीयू की संख्या प्राप्त करने के लिए, इसे सरल बनाएं। इस आदमी को शामिल करें #include <unistd.h>और इस पद्धति को कॉल करेंint nb = sysconf(_SC_NPROCESSORS_ONLN);

— डेविड गुयोन

मुझे समझ में नहीं आता कि डेल्टा (proc_times) को संभालने वाले (प्रोसेसर की संख्या) से गुणा क्यों किया जाता है, जिस पर यह निष्पादित होता है। कारक या सीपीयू द्वारा गुणा किए बिना, यह सही होना चाहिए।

— जयबलानारोन

Answer 4

मैंने एक प्रक्रिया के उपयोगकर्ता + कर्नेल सीपीयू उपयोग की गणना करने के लिए कैफे के उत्तर पर आधारित दो छोटे सी फ़ंक्शन लिखे: https://github.com/fho/code_snippets/blob/master/c/getusage.c

Comments

क्या इसका कोई संकलित संस्करण है क्योंकि यह संकलन करते समय मुझे त्रुटि देता है और यह भी कि मैं इसका उपयोग कैसे कर सकता हूं?

— मेधात

मेरे पास एक मुख्य () फ़ंक्शन नहीं है इसलिए यह "स्टैंडअलोन" प्रोग्राम नहीं है जितना आप संकलन और निष्पादित कर सकते हैं। आपको एक मुख्य () फ़ंक्शन लिखना होगा जो getusage.c के कार्यों के साथ कुछ काम करता है

— fho

यह वास्तव में सी फ़ंक्शन का उपयोग नहीं कर रहा है। कमांड आउटपुट को पार्स करने के लिए बस एक मनमानी भाषा का उपयोग करना।

— ग्राहम

Answer 5

आप अधिक विवरण के लिए खरीद के लिए मैनपेज पढ़ सकते हैं , लेकिन सारांश में आप किसी प्रक्रिया के बारे में जानकारी प्राप्त करने के लिए / खरीद / [संख्या] / स्टेट पढ़ सकते हैं। इसका उपयोग 'ps' कमांड द्वारा भी किया जाता है।

सभी फ़ील्ड और उनके स्कैनफ़ प्रारूप के निर्दिष्टर्स को मैनपग ई में प्रलेखित किया गया है ।

यहां कॉपी किए गए मैनपेज से कुछ जानकारी दी गई है (यह काफी लंबा है):

          pid %d The process ID.

          comm %s
                 The  filename of the executable, in parentheses.  This is
                 visible whether or not the executable is swapped out.

          state %c
                 One character from the string "RSDZTW" where  R  is  runâ
                 ning,  S is sleeping in an interruptible wait, D is waitâ
                 ing in uninterruptible disk sleep,  Z  is  zombie,  T  is
                 traced or stopped (on a signal), and W is paging.

          ppid %d
                 The PID of the parent.

          pgrp %d
                 The process group ID of the process.

          session %d
                 The session ID of the process.

          tty_nr %d
                 The tty the process uses.

          tpgid %d
                 The  process group ID of the process which currently owns
                 the tty that the process is connected to.

Comments

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

— बॉम्बे

हम्म, अच्छा सवाल है, मैंने हमेशा यह मान लिया कि यह वहाँ होगा! संभवतः आपको इन चरों से इसकी गणना करने में सक्षम होना चाहिए

— आंद्रे मिलर

यदि आप शीर्ष कमांड के आउटपुट की जांच करते हैं, तो आप CPU उपयोग देख सकते हैं .... लेकिन मैं सीपीयू उपयोग की गणना करने के लिए शीर्ष आउटपुट के माध्यम से greping में इंट्रस्ट नहीं कर रहा हूं .....

— कोडिंगफ्रीक

@ कोडिंगफ्रिक: ps auxबेहतर है :)

— vpram86

@ एविएटर - मैंने पहले ही सीपीयू उपयोग% का निर्धारण करने के लिए एक शेल कमांड के उत्पादन को बढ़ाने के बारे में यू को बताया है

— कोडिंगफ्रीक

Answer 6

"पिडस्टेट" कमांड पर एक नज़र डालें, बिल्कुल वैसा ही लगता है जैसा आपको चाहिए।

Comments

@ जेम्स - मैं अपने FEDORA 9 मशीन में pidstat कमांड का उपयोग नहीं कर पा रहा हूं।

— कोडिंगफ्रीक

@ कोडिंगफ्रीक - आपको इसके लिए Sysstat टूल इंस्टॉल करने की आवश्यकता है

— चिंतन पारिख

Answer 7

यह मेरा समाधान है ...

/*
this program is looking for CPU,Memory,Procs also u can look glibtop header there was a lot of usefull function have fun..
systeminfo.c
*/
#include <stdio.h>
#include <glibtop.h>
#include <glibtop/cpu.h>
#include <glibtop/mem.h>
#include <glibtop/proclist.h>



int main(){

glibtop_init();

glibtop_cpu cpu;
glibtop_mem memory;
glibtop_proclist proclist;

glibtop_get_cpu (&cpu);
glibtop_get_mem(&memory);


printf("CPU TYPE INFORMATIONS \n\n"
"Cpu Total : %ld \n"
"Cpu User : %ld \n"
"Cpu Nice : %ld \n"
"Cpu Sys : %ld \n"
"Cpu Idle : %ld \n"
"Cpu Frequences : %ld \n",
(unsigned long)cpu.total,
(unsigned long)cpu.user,
(unsigned long)cpu.nice,
(unsigned long)cpu.sys,
(unsigned long)cpu.idle,
(unsigned long)cpu.frequency);

printf("\nMEMORY USING\n\n"
"Memory Total : %ld MB\n"
"Memory Used : %ld MB\n"
"Memory Free : %ld MB\n"
"Memory Buffered : %ld MB\n"
"Memory Cached : %ld MB\n"
"Memory user : %ld MB\n"
"Memory Locked : %ld MB\n",
(unsigned long)memory.total/(1024*1024),
(unsigned long)memory.used/(1024*1024),
(unsigned long)memory.free/(1024*1024),
(unsigned long)memory.shared/(1024*1024),
(unsigned long)memory.buffer/(1024*1024),
(unsigned long)memory.cached/(1024*1024),
(unsigned long)memory.user/(1024*1024),
(unsigned long)memory.locked/(1024*1024));

int which,arg;
glibtop_get_proclist(&proclist,which,arg);
printf("%ld\n%ld\n%ld\n",
(unsigned long)proclist.number,
(unsigned long)proclist.total,
(unsigned long)proclist.size);
return 0;
}

makefile is
CC=gcc
CFLAGS=-Wall -g
CLIBS=-lgtop-2.0 -lgtop_sysdeps-2.0 -lgtop_common-2.0

cpuinfo:cpu.c
$(CC) $(CFLAGS) systeminfo.c -o systeminfo $(CLIBS)
clean:
rm -f systeminfo

Comments

Libgtop लाइब्रेरी की मदद से लगता है ..?

— कोडिंगफ्रिक

मुझे यह पसंद है - पुस्तकालय सीधा है। मुझे आश्चर्य है कि अगर कुल क्षमता का कुल% कितना है यह देखने का एक तरीका है?

— सेरा

Answer 8

जब आप निर्दिष्ट प्रक्रिया की निगरानी करना चाहते हैं, तो आमतौर पर यह स्क्रिप्टिंग द्वारा किया जाता है। यहाँ पर्ल उदाहरण है। इसने पर्केंट्स को उसी तरह से ऊपर रखा, जैसे एक सीपीयू को। फिर जब कुछ प्रक्रिया 2 थ्रेड्स के साथ सक्रिय होती है, तो सीपीयू का उपयोग 100% से अधिक हो सकता है। विशेष रूप से देखें कि सीपीयू कोर की गणना कैसे की जाती है: डी तो मुझे अपना उदाहरण दिखाने दें:

#!/usr/bin/perl

my $pid=1234; #insert here monitored process PID

#returns current process time counters or single undef if unavailable
#returns:  1. process counter  , 2. system counter , 3. total system cpu cores
sub GetCurrentLoads {
    my $pid=shift;
    my $fh;
    my $line;
    open $fh,'<',"/proc/$pid/stat" or return undef;
    $line=<$fh>;
    close $fh;
    return undef unless $line=~/^\d+ \([^)]+\) \S \d+ \d+ \d+ \d+ -?\d+ \d+ \d+ \d+ \d+ \d+ (\d+) (\d+)/;
    my $TimeApp=$1+$2;
    my $TimeSystem=0;
    my $CpuCount=0;
    open $fh,'<',"/proc/stat" or return undef;
    while (defined($line=<$fh>)) {
        if ($line=~/^cpu\s/) {
            foreach my $nr ($line=~/\d+/g) { $TimeSystem+=$nr; };
            next;
        };
        $CpuCount++ if $line=~/^cpu\d/;
    }
    close $fh;
    return undef if $TimeSystem==0;
    return $TimeApp,$TimeSystem,$CpuCount;
}

my ($currApp,$currSys,$lastApp,$lastSys,$cores);
while () {
    ($currApp,$currSys,$cores)=GetCurrentLoads($pid);
    printf "Load is: %5.1f\%\n",($currApp-$lastApp)/($currSys-$lastSys)*$cores*100 if defined $currApp and defined $lastApp and defined $currSys and defined $lastSys;
    ($lastApp,$lastSys)=($currApp,$currSys);
    sleep 1;
}

मुझे उम्मीद है कि यह किसी भी निगरानी में आपकी मदद करेगा। बेशक आप सी स्रोत के लिए इस्तेमाल किया है किसी भी perl regexpes परिवर्तित करने के लिए scanf या अन्य C फ़ंक्शन का उपयोग करना चाहिए। बेशक नींद के लिए 1 सेकंड अनिवार्य नहीं है। आप किसी भी समय उपयोग कर सकते हैं। प्रभाव है, आपको निर्दिष्ट समय अवधि पर औसत भार मिलेगा। जब आप इसका उपयोग निगरानी के लिए करेंगे, तो निश्चित रूप से पिछले मूल्यों को आपको बाहर रखना चाहिए। इसकी आवश्यकता है, क्योंकि निगरानी आमतौर पर समय-समय पर लिपियों को बुलाती है, और स्क्रिप्ट को अपना काम समाप्त करना चाहिए।

Answer 9

स्थापित psacctया acctपैकेज। फिर saविभिन्न कमांड के लिए उपयोग किए जाने वाले CPU समय को प्रदर्शित करने के लिए कमांड का उपयोग करें । सा आदमी पेज

एक अच्छा howto nixCraft साइट से।

Answer 10

मुझे लगता है कि यह GNU "टाइम" कमांड सोर्स कोड देखने लायक है। समय यह वास्तविक बीता समय के साथ उपयोगकर्ता / सिस्टम सीपीयू समय को आउटपुट करता है। यह Wait3 / Wait4 सिस्टम कॉल (यदि उपलब्ध हो) को कॉल करता है और अन्यथा यह कई बार सिस्टम कॉल को कॉल करता है। प्रतीक्षा करें * सिस्टम कॉल रिटर्न एक "rusage" संरचना चर और समय प्रणाली कॉल रिटर्न "tms"। इसके अलावा, आप गेट्रेज सिस्टम कॉल पर एक नज़र डाल सकते हैं जो बहुत ही दिलचस्प समय की जानकारी भी लौटाता है। समय

Comments

GNU "समय" केवल "समय" की बाल प्रक्रिया के लिए है

— ग्राहम

Answer 11

बिक्री से इसे पार्स करने के बजाय, एक गेटस्ट्रेज () या घड़ी_गेटाइम () जैसे कार्यों का उपयोग कर सकता है और सीपीयू के उपयोग को एक अनुपात या वॉलकॉक समय और उस समय / सीपीयू पर उपयोग की जाने वाली प्रक्रिया / थ्रेड के रूप में गणना करता है।

Comments

getrusage clock_gettime सभी प्रक्रियाओं के लिए सीमित है,

— ग्राहम

Answer 12

एक समय अवधि तक सीपीयू के उपयोग की गणना की जाने वाली स्ट्रेस का उपयोग करें:

# top -b -n 1 -p 3889
top - 16:46:37 up  1:04,  3 users,  load average: 0.00, 0.01, 0.02
Tasks:   1 total,   0 running,   1 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  5594496 total,  5158284 free,   232132 used,   204080 buff/cache
KiB Swap:  3309564 total,  3309564 free,        0 used.  5113756 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 3889 root      20   0  162016   2220   1544 S   0.0  0.0   0:05.77 top

# strace top -b -n 1 -p 3889

.
.
.
stat("/proc/3889", {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0
open("/proc/3889/stat", O_RDONLY)       = 7
read(7, "3889 (top) S 3854 3889 3854 3481"..., 1024) = 342
.
.
.

nanosleep({0, 150000000}, NULL)         = 0
.
.
.
stat("/proc/3889", {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0
open("/proc/3889/stat", O_RDONLY)       = 7
read(7, "3889 (top) S 3854 3889 3854 3481"..., 1024) = 342
.
.
.