Содержание:
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 секунду, если она используется в разных процессах.