Bagaimana cara mendapatkan total penggunaan CPU dari suatu aplikasi dari /proc/pid/stat?

Persiapan

Untuk menghitung penggunaan CPU untuk proses tertentu, Anda memerlukan hal berikut:

1. /proc/uptime
   • #1 waktu aktif sistem (detik)
2. /proc/[PID]/stat
   • #14 utime - Waktu CPU yang dihabiskan dalam kode pengguna, diukur dalam detik jam
   • #15 stime - Waktu CPU dihabiskan dalam kode kernel, diukur dalam kutu waktu
   • #16 cutime - Anak-anak yang ditunggu-tunggu Waktu CPU dihabiskan dalam kode pengguna (dalam kutu jam )
   • #17 cstime - Anak-anak yang ditunggu-tunggu Waktu CPU dihabiskan dalam kode kernel (dalam kutu jam )
   • #22 starttime - Waktu saat proses dimulai, diukur dalam detik jam
3. Hertz (jumlah detak jam per detik) sistem Anda.
   • Biasanya, getconf CLK_TCK dapat digunakan untuk mengembalikan jumlah detak jam.
   • sysconf(_SC_CLK_TCK) Panggilan fungsi C juga dapat digunakan untuk mengembalikan nilai hertz.

Perhitungan

Pertama, kami menentukan total waktu yang dihabiskan untuk proses tersebut:

total_time = utime + stime

Kami juga harus memutuskan apakah kami ingin memasukkan waktu dari proses anak-anak. Jika ya, maka kita tambahkan nilai tersebut ke total_time :

total_time = total_time + cutime + cstime

Selanjutnya kita mendapatkan total waktu yang berlalu dalam detik sejak proses dimulai:

seconds = uptime - (starttime / Hertz)

Terakhir, kami menghitung persentase penggunaan CPU:

cpu_usage = 100 * ((total_time / Hertz) / seconds)

Lihat juga

Atas dan ps tidak menunjukkan hasil cpu yang sama

Cara mendapatkan total penggunaan cpu di Linux (c++)

Menghitung penggunaan CPU dari suatu proses di Linux

Jika perlu menghitung berapa banyak cpu% yang digunakan oleh suatu proses dalam 10 detik terakhir

1. gettotal_time (13+14) dalam sekejap => t1starttime(22) dalam sekejap => s1

--penundaan 10 detik

total_time (13+14) dalam sekejap => t2starttime(22) dalam sekejap => s2

t2-t1 *100 / s2 - s1tidak akan memberikan % ??

Ya, bisa dibilang begitu. Anda dapat mengonversi nilai tersebut menjadi detik menggunakan rumus:

      sec = jiffies / HZ ; here - HZ = number of ticks per second

Nilai HZ dapat dikonfigurasi - dilakukan pada waktu konfigurasi kernel.

Inilah solusi sederhana saya yang ditulis dalam BASH . Ini adalah monitor sistem linux/unix dan manajer proses melalui procfs, seperti "top " atau "ps ". Ada dua versi monokrom sederhana (cepat) dan versi berwarna (sedikit lambat, tetapi berguna terutama untuk memantau keadaan proses). Saya membuat penyortiran berdasarkan penggunaan CPU.

https://github.com/AraKhachatryan/top

• utime , waktu , lucu , waktu , waktu mulai digunakan untuk mendapatkan penggunaan cpu dan diperoleh dari /proc/[pid]/stat berkas.

• negara bagian , ppid , prioritas , bagus , num_threads parameter diperoleh juga dari /proc/[pid]/stat berkas.

• penduduk dan data_and_stack parameter yang digunakan untuk mendapatkan penggunaan memori dan diperoleh dari /proc/[pid]/statm berkas.

    function my_ps
    {
        pid_array=`ls /proc | grep -E '^[0-9]+$'`
        clock_ticks=$(getconf CLK_TCK)
        total_memory=$( grep -Po '(?<=MemTotal:\s{8})(\d+)' /proc/meminfo )

        cat /dev/null > .data.ps

        for pid in $pid_array
        do
            if [ -r /proc/$pid/stat ]
            then
                stat_array=( `sed -E 's/(\([^\s)]+)\s([^)]+\))/\1_\2/g' /proc/$pid/stat` )
                uptime_array=( `cat /proc/uptime` )
                statm_array=( `cat /proc/$pid/statm` )
                comm=( `grep -Po '^[^\s\/]+' /proc/$pid/comm` )
                user_id=$( grep -Po '(?<=Uid:\s)(\d+)' /proc/$pid/status )

                user=$( id -nu $user_id )
                uptime=${uptime_array[0]}

                state=${stat_array[2]}
                ppid=${stat_array[3]}
                priority=${stat_array[17]}
                nice=${stat_array[18]}

                utime=${stat_array[13]}
                stime=${stat_array[14]}
                cutime=${stat_array[15]}
                cstime=${stat_array[16]}
                num_threads=${stat_array[19]}
                starttime=${stat_array[21]}

                total_time=$(( $utime + $stime ))
                #add $cstime - CPU time spent in user and kernel code ( can olso add $cutime - CPU time spent in user code )
                total_time=$(( $total_time + $cstime ))
                seconds=$( awk 'BEGIN {print ( '$uptime' - ('$starttime' / '$clock_ticks') )}' )
                cpu_usage=$( awk 'BEGIN {print ( 100 * (('$total_time' / '$clock_ticks') / '$seconds') )}' )

                resident=${statm_array[1]}
                data_and_stack=${statm_array[5]}
                memory_usage=$( awk 'BEGIN {print( (('$resident' + '$data_and_stack' ) * 100) / '$total_memory'  )}' )

                printf "%-6d %-6d %-10s %-4d %-5d %-4s %-4u %-7.2f %-7.2f %-18s\n" $pid $ppid $user $priority $nice $state $num_threads $memory_usage $cpu_usage $comm >> .data.ps

            fi
        done

        clear
        printf "\e[30;107m%-6s %-6s %-10s %-4s %-3s %-6s %-4s %-7s %-7s %-18s\e[0m\n" "PID" "PPID" "USER" "PR" "NI" "STATE" "THR" "%MEM" "%CPU" "COMMAND"
        sort -nr -k9 .data.ps | head -$1
        read_options
    }