Сообщить об ошибке.

Различная статистика по использованию ресурсов ОС и ЦП.

Материал содержит описание функций модуля psutil с примерами, которые возвращают различные статистические данные об использовании ресурсов операционной системы и программного обеспечения, работающего в ней. Такие как: текущая загрузка ОС и ЦП, количество логических и физических процессоров, частота ЦП, процессорное время и т.д.

Содержание:


psutil.cpu_times(percpu=False):

Функция psutil.cpu_times() возвращает время работы системного процессора в виде именованного кортежа. Каждый атрибут представляет секунды, потраченные процессором в данном режиме.
Когда аргумент percpu имеет значение True, то функция возвращает список именованных кортежей для каждого логического процессора в системе. Первый элемент списка относится к первому процессору, второй элемент - ко второму процессору и так далее. Порядок списка одинаков для всех вызовов.
Пример использования psutil.cpu_times() в Linux:
>>> import psutil
>>> psutil.cpu_times()
# scputimes(user=17411.7, nice=77.99, system=3797.02, idle=51266.57, 
# iowait=732.58, irq=0.01, softirq=142.43, steal=0.0, guest=0.0, guest_nice=0.0)
Доступность атрибутов варьируется в зависимости от платформы:
  • user: время, затрачиваемое обычными процессами, выполняемыми в пользовательском режиме. В Linux оно также включает гостевое время.
  • system: время, затрачиваемое процессами, выполняющимися в режиме ядра.
  • idle: время, потраченное на простой (когда процессор ничего не делает).
Поля, специфичные для конкретной платформы:
  • nice (UNIX): время, затрачиваемое процессами с приоритетом niced, выполняющимися в пользовательском режиме. В Linux это также включает время guest_nice;
  • iowait (Linux): время, потраченное на ожидание завершения ввода-вывода. Это время не учитывается в счетчике времени простоя;
  • irq (Linux, BSD): время, затрачиваемое на обслуживание аппаратных прерываний;
  • softirq (Linux): время, затрачиваемое на обслуживание программных прерываний;
  • steal (Linux 2.6.11+): время, затрачиваемое другими операционными системами, работающими в виртуализированной среде;
  • guest (Linux 2.6.24+): время, затрачиваемое на запуск виртуального процессора для гостевых операционных систем под управлением ядра Linux;
  • guest_nice (Linux 3.2.0+): время, затраченное на запуск niced guest (виртуальный процессор для гостевых операционных систем под управлением ядра Linux);
  • interrupt (Windows): время, затрачиваемое на обслуживание аппаратных прерываний (аналогично “irq” в UNIX)
  • dpc (Windows): время, затрачиваемое на обслуживание вызовов отложенных процедур (DPC). DPC - это прерывания, которые выполняются с более низким приоритетом, чем стандартные прерывания.
Предупреждение: процессорное время всегда должно увеличиваться с течением времени или, по крайней мере, оставаться неизменным, потому что время не может идти вспять. Удивительно, но иногда это может быть не так (по крайней мере, в OC Windows и OC Linux).

psutil.cpu_percent(interval=None, percpu=False):

Функция psutil.cpu_percent() возвращает число float, представляющее текущую загрузку ЦП в масштабе всей системы в процентах.
Когда аргумент interval > 0,0, то сравнивается время системного процессора, прошедшее до и после интервала (блокировка). Когда интервал равен 0,0 или None, то сравнивается время системного процессора, прошедшее с момента последнего вызова или импорта модуля, с немедленным возвратом значения. Это означает, что при первом вызове он вернет бессмысленное значение 0.0, которое необходимо игнорировать. В этом случае для точности рекомендуется вызывать эту функцию с интервалом не менее 0,1 секунды между вызовами.
Когда аргумент percpu имеет значение True, то функция возвращает список чисел float, представляющий использование в процентах для каждого ЦП. Первый элемент списка относится к первому процессору, второй элемент - ко второму процессору и так далее. Порядок списка одинаков для всех вызовов.
Пример использования psutil.cpu_percent():
>>> import psutil
# блокирующий вызов
>>> psutil.cpu_percent(interval=1)
# 2.0

# неблокирующий вызов 
# (процент с момента последнего вызова)
>>> psutil.cpu_percent(interval=None)
# 2.9

# блокирующий вызов, загрузка на процессор
>>> psutil.cpu_percent(interval=1, percpu=True)
# [2.0, 1.0]
Предупреждение: при первом вызове этой функции с интервалом = 0,0 или None она вернет бессмысленное значение 0,0, которое нужно проигнорировать.

psutil.cpu_times_percent(interval=None, percpu=False):

Функция psutil.cpu_times_percent() возвращает то же, что и функция psutil.cpu_times(percpu=True) и предоставляет процент использования для каждого конкретного процессорного времени. Аргументы interval и percpu имеют то же значение, что и в psutil.cpu_percent(). В Linux проценты guest и guest_nice не учитываются в процентах user и user_nice.
Предупреждение: при первом вызове этой функции с интервалом, равным 0,0 или None она вернет бессмысленное значение 0,0, которое нужно игнорировать.

psutil.cpu_count(logical=True):

Функция psutil.cpu_count() возвращает количество логических процессоров в системе (так же, как os.cpu_count) или None, если оно не определено.
"Логические процессоры" означают количество физических ядер, умноженное на количество потоков, которые могут выполняться на каждом ядре (это называется Hyper-Threading). Если для аргумента logical задано значение False, то возвращает только количество физических ядер или None, если оно не определено. В OpenBSD и NetBSD psutil.cpu_count(logical=False) всегда возвращает None.
Пример использования psutil.cpu_count() для системы с 2 ядрами + Hyper Threading:
>>> import psutil
>>> psutil.cpu_count()
# 4
>>> psutil.cpu_count(logical=False)
# 2
Обратите внимание, что psutil.cpu_count() не обязательно может быть эквивалентно фактическому количеству процессоров, которые может использовать текущий процесс. Число может измениться в случае изменения привязки процессора к процессу, использования контрольных групп Linux или (в случае Windows) в системах, использующих группы процессоров или имеющих более 64 процессоров.
Количество используемых ЦП можно получить с помощью:
>>> len(psutil.Process().cpu_affinity())
# 1

psutil.cpu_stats():

Функция psutil.cpu_stats() возвращает различную статистику ЦП в виде именованного кортежа:
  • ctx_switches: количество переключений контекста (добровольных + непроизвольных) с момента загрузки.
  • interrupts: количество прерываний с момента загрузки.
  • soft_interrupts: количество программных прерываний с момента загрузки. В Windows и SunOS всегда устанавливается значение 0.
  • syscalls: количество системных вызовов с момента загрузки. В Linux всегда устанавливается в 0.
Пример использования psutil.cpu_stats() для Linux:
>>> import psutil
>>> psutil.cpu_stats()
# scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)

psutil.cpu_freq(percpu=False):

Функция psutil.cpu_freq() возвращает частоту ЦП в виде именованного кортежа, включая текущую, минимальную и максимальную частоты, выраженные в МГц.
В Linux текущая частота сообщает значение в реальном времени, на всех других платформах значение представляет собой номинальное "фиксированное" значение (никогда не меняющееся). Если аргумент percpu имеет значение True и система поддерживает получение частоты для каждого процессора (только Linux), то возвращается список частот для каждого процессора, если не поддерживает, то возвращается список с одним элементом. Если минимальные и максимальные значения не могут быть определены, то они устанавливаются равными 0,0.
Пример использования psutil.cpu_freq() для Linux:
>>> import psutil
>>> psutil.cpu_freq()
# scpufreq(current=931.42925, min=800.0, max=3500.0)
>>> psutil.cpu_freq(percpu=True)
# [scpufreq(current=2394.945, min=800.0, max=3500.0),
#  scpufreq(current=2236.812, min=800.0, max=3500.0),
#  scpufreq(current=1703.609, min=800.0, max=3500.0),
#  scpufreq(current=1754.289, min=800.0, max=3500.0)]
Доступность: Linux, macOS, Windows, FreeBSD, OpenBSD

psutil.getloadavg():

Функция psutil.getloadavg() возвращает среднюю загрузку системы за последние 1, 5 и 15 минут в виде кортежа. "Нагрузка" представляет собой процессы, находящиеся в состоянии готовности к выполнению, либо использующие ЦП, либо ожидающие использования ЦП (например, ожидающие дискового ввода-вывода).
В системах UNIX это зависит от os.getloadavg. В Windows это эмулируется с помощью Windows API, который порождает поток, который продолжает работать в фоновом режиме и обновляет результаты каждые 5 секунд, имитируя поведение UNIX. Таким образом, в Windows при первом вызове и в течение следующих 5 секунд он будет возвращать бессмысленный кортеж (0.0, 0.0, 0.0).
Возвращаемые числа имеют смысл только в том случае, если они связаны с количеством ядер ЦП, установленных в системе. Так, например, значение 3,14 в системе с 10 логическими ЦП означает, что загрузка системы за последние N минут составила 31,4%.
Пример использования psutil.getloadavg():
>>> import psutil
>>> psutil.getloadavg()
# (3.14, 3.89, 4.67)
>>> psutil.cpu_count()
# 10

# процентное представление загрузки системы
>>> [x / psutil.cpu_count() * 100 for x in psutil.getloadavg()]
# [31.4, 38.9, 46.7]
Доступность: Unix, Windows

psutil.boot_time():

Функция psutil.boot_time() возвращает время загрузки системы, выраженное в секундах с начала эпохи.
Пример использования psutil.boot_time():
>>> import psutil, datetime
>>> psutil.boot_time()
# 1389563460.0
>>> datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
# '2014-01-12 22:51:00'
Обратите внимание, что в Windows эта функция может возвращать время, которое отличается на 1 секунду, если она используется в разных процессах.