☰

Получить загрузку процессора по ядрам в скрипте оболочки

tag-icon • tag-icon linux shell-script proc top load-average
Получить загрузку процессора по ядрам в скрипте оболочки

Мне нужно получить отчет о загрузке процессора на ядро ​​в процентах из скрипта оболочки, ноЯ не могу запустить eg mpstat в течение одной секундыtop. В принципе, я думаю, что отображение информации после нажатия 1— это то, что мне нужно, но я не могу настроить top для отображения этого в пакетном режиме (по крайней мере, я не знаю как). Я мог бы создать файл ~/.toprcс конфигурацией, но тогда я должен надеяться, что пользователи не будут вмешиваться в это.

Я посмотрел mpstatи проанализировал вывод, но он поддерживает только секунды в качестве интервала времени. Мой скрипт вызывается через SNMP, и ожидание ответа в 1 секунду приведет к таймауту, поэтому это не вариант.

Есть ли другие способы получить нагрузку процессора на ядро? Я читал о парсинге /proc/stat, но я думаю, что это скорее крайний вариант.

решение1

Существует несколько способов выполнить субсекундный опрос загрузки процессора: либо с помощью утилиты, например dstat (пример ниже), либо путем прямого опроса /proc/stat (пример также ниже).

Давайте рассмотрим плюсы и минусы обоих вариантов, прежде чем переходить к техническим примерам.

Чтобы использовать dstat, вам нужно будет запустить быстрый crontab( */1 * * * * ) и передать результат в файл статистики, который вы можете проверить. Плюс в том, что ваши тайм-ауты SNMP не будут проблемой, минус в том, что это не действительно мгновенно, и запуск crontab, когда вы на самом деле не ищете эти данные, оказывает влияние. Влияние может быть незначительным, но все же оно есть.

Чтобы использовать /proc/stat, вы должны дважды опросить содержимое /proc/stat. Содержимое /proc/stat накапливается с момента загрузки. Поэтому результаты первого и второго опроса необходимо вычесть друг из друга, а затем можно выполнить расчет текущей загрузки. Недостатком является то, что для выполнения этого расчета должна быть какая-то задержка. В примере ниже я уменьшил задержку до доли секунды. Это удовлетворит ваши потребности, однако выборки данных расположены так близко друг к другу, что я не уверен, насколько абсолютна точность.

Использование dstat; Добавьте эту строку в /etc/crontab:

*/1  *  *  *  *  root    echo $((100-`dstat -c -C0 --noheaders --nocolor 1 1 | grep -v "\-\|u" | awk 'NR == 2' | tr -s " " | cut -d \  -f 4`)) > /tmp/cpuload

Это обновляется только раз в минуту. Если вы хотите более частые обновления, добавьте вторую строку и предварите команду sleep 30, например

*/1  *  *  *  *   root    sleep 30; echo $((100-`dstat -c -C0 --noheaders --nocolor 1 1 | grep -v "\-\|u" | awk 'NR == 2' | tr -s " " | cut -d \  -f 4`)) > /tmp/cpuload

Можно использовать cron еще дальше и получать результаты менее чем за секунду, но это уже совсем другая тема.

объяснение:

dstat -c -C 0 --noheaders --nocolor 1 0

-c показывать только данные процессора

-C выберите cpu0. измените нумерацию, чтобы выбрать другой cpu

--noheaders --nocolor (подразумевается --noupdate) упрощаем то, что видим

1 задержка в одну секунду при чтении статистики

1 выход после второго прочтения статистики. Даем время успокоиться после вызова.

grep -v "-\|u"

удалить строки, не содержащие данные

awk 'НР == 2'

выберите вторую строку.

тр -с " "

обрежьте лишние пробелы, которые хорошо смотрятся на экране, но не подходят для использования в системе

вырезать -d \ -f 4

-d \ (после пробела \ (escape) есть пробел, выделенная строка -f 4 выбирает холостой ход. да, визуально это 3, но пробел в начале строки считается полем, сбрасывая количество полей.

$ (( ))

арифметические операции bash, вычитающие время простоя системы из 100.

Использование /proc/stat;

Сохранить как cpuload.sh;

#!/bin/bash

#Calculation delay. Without a delay, there is no way to determine current 
#values. The content or /proc/stat is cumulitative from last boot.  
# in seconds; sleep must be able to support float values
dly=3

function calculate {

#load arrays
IFS=' ' read -r -a firstarr <<< "$1"
IFS=' ' read -r -a secondarr <<< "$2"

#clear name fields in array so that calculations don't get messy
firstarr[0]=0 ;
secondarr[0]=0 ;

#clear values 
firsttotcpu=0
secondtotcpu=0

#calculate the begining interrupt counts
for f in ${firstarr[@]}; 
    do 
        let firsttotcpu+=$f; 
done
firstidle=$((${firstarr[4]}+${firstarr[5]})); 

#calculate the ending interrupt counts
for l in ${secondarr[@]}; 
    do
        let secondtotcpu+=$l; 
    done; 
secondidle=$((${secondarr[4]}+${secondarr[5]})); 

#calculate the relative change counts
insttotcpu=$(( secondtotcpu - firsttotcpu ))
instidle=$(( secondidle - firstidle ))

#calculate the utilization percentage. must be done external to bash as it's a
#floating calculation
cpu_load=$( echo | awk -v tot=$insttotcpu -v idl=$instidle ' { print ( ( ( tot - idl ) / tot ) * 100 ) } ' )

echo -n $cpu_load " " 


} 
export -f calculate

#main execution

oldIFS=$IFS

IFS=$'\n' cpu_start=( $( grep cpu /proc/stat ) );

#must delay to get difference
sleep $dly

IFS=$'\n' cpu_end=( $( grep cpu /proc/stat ) );

cpucount=${#cpu_start[@]}

#uncomment this for loop to enable printing the cpu name above the percentages
#for i in ${cpu_start[@]};
#    do
#        IFS=' ' read -r -a name <<< "$i"
#        echo -n ${name[0]} " "
#done
#echo ""

for (( i=0; i<$cpucount; i++ ))
    do
        calculate "${cpu_start[$i]}" "${cpu_end[$i]}"

done

echo ""

IFS=$oldIFS

решение2

Другой способ получить необработанные значения — grep cpu0 /proc/stat. Там вы видите количество тиков в каждом состоянии. man procДля получения подробной информации об интерпретации сделайте . Если вы хотите получить процентное значение, вам нужно будет сложить их вместе и разделить, например, по линиям того, чтоДжон У. Гиллпредполагает.

решение3

Вотоснованный на bashпример сценария (используя /proc/stat) с пояснениями. Он может работать так быстро, как вам нужно. Сохраните как /tmp/cpuLoad.sh, затем "chmod +x /tmp/cpuLoad.sh" и последний запуск: /tmp/cpuLoad.sh

#!/bin/bash

interval=0.25; ##loop interval in seconds

##so settings below
lCpus=(); ##store last readings
lCount=0; ## loop counter

while :; do {

    cCpu=(); ##current cpu
    cCpus=(); ##all cpus
    values=$(grep -E "cpu[0-9]+\s" /proc/stat);
    for value in $values; do {
        if [[ $value =~ ^cpu[0-9]+ ]]; then
            if [[ ${#cCpu[@]} > 0 ]]; then
                cCpus[${cCpu[1]}]="${cCpu[@]}"
            fi

            cCpu[0]=$value; ##name
            cCpu[1]=${#cCpus[@]}; ##cpu index
            cCpu[2]=0; ##cpu idle ticks
            cCpu[3]=0; ##cpu busy ticks
            i=0; ## column index

        else
            ((i=i+1));
            if ([ $i == 4 ] || [ $i == 5 ]); then
                # position 4 is the idle, position 5 is the i/o wait (also idle introduced 2.5.41) src https://www.idnt.net/en-US/kb/941772
                ((cCpu[2]=cCpu[2] + value));
            else
                ((cCpu[3]=cCpu[3] + value));
            fi
        fi
    } done

    ##include the last cpu
    cCpus[${cCpu[1]}]="${cCpu[@]}"

    output="Loop $lCount";
    x=0;
    for cpu in "${cCpus[@]}"; do {
        if [[ $lCount > 0 ]]; then
        
            cCpu=($cpu);
            lCpu=(${lCpus[$x]});
            dTotal=$(((${cCpu[2]} + ${cCpu[3]}) - (${lCpu[2]} + ${lCpu[3]})));
            dUsed=$((dTotal - (${cCpu[2]} - ${lCpu[2]})));
            if [[ $dTotal == 0 ]]; then
                dTotal=1; ##dividing by 0 is never a good idea
            fi
            output="$output, ${cCpu[0]}: $((100 * dUsed / dTotal))%";
        fi
        ##store the reading so we can do a delta next round
        lCpus[$x]=$cpu;
        ((x=x+1));
        
    } done
    
    if [[ $lCount > 0 ]]; then
        echo $output;
    fi
    
    sleep $interval;
    ((lCount=lCount+1));
    
} done

решение4

Оказывается, некоторые из MIB, установленных на RedHat, предоставляют всю необходимую здесь информацию. Поскольку моя цель — предоставить эти значения под OID через SNMP, я могу использовать SNMP и обработать информацию.

Среднее значение по всем процессорам вычисляется следующим образом 100-idle:

function allCpuLoad {
    # get system idle value from
    # snmpget -v2c -cmdaf localhost UCD-SNMP-MIB::ssCpuIdle.0
    # UCD-SNMP-MIB::ssCpuIdle.0 = INTEGER: 93
    # and compute load by substracting it from 100.0 
    snmpget -v2c -cmdaf localhost UCD-SNMP-MIB::ssCpuIdle.0|cut -f4 -d' '| awk '{printf "%d", 100 - $1}'
}

Мы можем использовать snmpwalk, чтобы получить загрузку всех отдельных процессоров, а затем извлечь максимальное значение:

function maxCpuLoad {
    # get load of all cpus
    # snmpwalk -v2c -cmdaf localhost HOST-RESOURCES-MIB::hrProcessorLoad
    # HOST-RESOURCES-MIB::hrProcessorLoad.196608 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196609 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196610 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196611 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196612 = INTEGER: 6
    # HOST-RESOURCES-MIB::hrProcessorLoad.196613 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196614 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196615 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196616 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196617 = INTEGER: 27
    # HOST-RESOURCES-MIB::hrProcessorLoad.196618 = INTEGER: 4
    # HOST-RESOURCES-MIB::hrProcessorLoad.196619 = INTEGER: 0
    # HOST-RESOURCES-MIB::hrProcessorLoad.196620 = INTEGER: 1
    # HOST-RESOURCES-MIB::hrProcessorLoad.196621 = INTEGER: 0
    # HOST-RESOURCES-MIB::hrProcessorLoad.196622 = INTEGER: 0
    # HOST-RESOURCES-MIB::hrProcessorLoad.196623 = INTEGER: 1
    # and get maximum value only
    snmpwalk -v2c -cmdaf localhost HOST-RESOURCES-MIB::hrProcessorLoad|cut -f 4 -d' '|sort -n -r|head -n1
}

Связанный контент