资源监控 python

1

#!/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 10 16:59:42 2022

@author: sxj
"""

import psutil  # 获取用户登录、开机信息
import platform
import getpass
import datetime
import time
from pynvml import *

# pip install nvidia-ml-py

def physical_system_time():
    """
    获取系统启用时间，开机时间
    """
    return {"system_time": datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")}

def physical_username():
    """
    获取当前用户名
    """
    return {
        "system_user": getpass.getuser()
    }

def physical_platfrom_system():
    """
    获取当前机器系统
    """
    u_name = platform.uname()
    return {"system_name": u_name.system, "system_version": u_name.version}

def physical_cpu():
    """
    获取机器物理CPU个数
    """
    return {"system_cpu_count": psutil.cpu_count(logical=False)}

def physical_memory():
    """
    获取机器物理内存(返回字节bytes)
    """
    # return round(psutil.virtual_memory().total / (1024.0 * 1024.0 * 1024.0), 2)
    return {"system_memory": round(psutil.virtual_memory().total, 2)}

def physical_hard_disk():
    """
    获取机器硬盘信息(字节bytes)
    """
    result = []
    for disk_partition in psutil.disk_partitions():
        o_usage = psutil.disk_usage(disk_partition.device)
        result.append(
            {
                "device": disk_partition.device,
                "fstype":disk_partition.fstype,
                "opts": disk_partition.opts,
                "total": o_usage.total,
            }
        )
    return {"system_hard_disk": result}

def nvidia_info():
    """
    GPU内存 最大使用率
    """
    nvidia_dict = {
        "state": True,
        "nvidia_version": "",
        "nvidia_count": 0,
        "gpus": []
    }
    try:
        nvmlInit()
        nvidia_dict["nvidia_version"] = nvmlSystemGetDriverVersion().decode('utf-8')
        nvidia_dict["nvidia_count"] = nvmlDeviceGetCount()
        for i in range(nvidia_dict["nvidia_count"]):
            handle = nvmlDeviceGetHandleByIndex(i)
            memory_info = nvmlDeviceGetMemoryInfo(handle)
            gpu = {
                "gpu_name": nvmlDeviceGetName(handle).decode('utf-8'),
                "total": memory_info.total,
                "free": memory_info.free,
                "used": memory_info.used,
                "temperature": f"{nvmlDeviceGetTemperature(handle, 0)}℃",
                "powerStatus": nvmlDeviceGetPowerState(handle)
            }
            nvidia_dict['gpus'].append(gpu)
    except NVMLError as _:
        nvidia_dict["state"] = False
    except Exception as _:
        nvidia_dict["state"] = False
    finally:
        try:
            nvmlShutdown()
        except:
            pass
    return nvidia_dict

def merge_list2dict(info_list):
    data = {}
    for item in info_list:
        data.update(
            item()
        )
    return data

def computer_info():
    data = merge(
        [
            physical_system_time,
            physical_username,
            physical_platfrom_system,
            physical_cpu,
            physical_memory,
            physical_hard_disk,
            nvidia_info
        ]
    )
    print(data)


# 获取总cpu使用率
# interval指定的是计算cpu使用率的时间间隔，percpu则指定是选择总的使用率还是每个cpu的使用率
cpu_percent = str(psutil.cpu_percent(interval=1, percpu=False)) + '%'
print(cpu_percent)

# 获取剩余内存
memory_free = str(round(psutil.virtual_memory().free / (1024.0 * 1024.0 * 1024.0), 3)) + ' G'
print(memory_free)

# 获取物理内存使用率
memory_percent = str(round(int(psutil.virtual_memory().total - psutil.virtual_memory().free) / float(psutil.virtual_memory().total) * 100, 3)) + '%'
print(memory_percent)

print(psutil.virtual_memory())
print(psutil.net_io_counters())
# svmem(total=13195796480, available=10661654528, percent=19.2, used=2206502912, free=9784602624, active=351813632, inactive=2690920448, buffers=130834432, cached=1073856512, shared=69632, slab=230887424)
# snetio(bytes_sent=94635815, bytes_recv=198511001, packets_sent=223459, packets_recv=289173, errin=0, errout=0, dropin=0, dropout=0)

# 获取硬盘
for i in psutil.disk_partitions():
    o = psutil.disk_usage(i.device)
    print("盘的名称:", i.device)
    print("fs类型:", i.fstype)
    print("fs权限:", i.opts)
    print(f"全部:{o.total}, 已用:{o.used}, 可用:{o.free}")


if __name__ == '__main_':
    print(computer_info())

2

import sys
import time
import psutil
# get pid from args
if len(sys.argv) < 2:
	print ("missing pid arg")
	sys.exit()

# get process
pid = int(sys.argv[1])
p = psutil.Process(pid)

# monitor process and write data to file
interval = 3 # polling seconds
with open("process_monitor_" + p.name() + '_' + str(pid) + ".tsv", "a+") as f:
	f.write("time,cpu%,mem%\n") # titles
	while True:
		current_time = time.strftime('%Y%m%d-%H%M%S',time.localtime(time.time()))
		cpu_percent = p.cpu_percent() # better set interval second to calculate like:  p.cpu_percent(interval=0.5)
		mem_percent = p.memory_percent()
		line = current_time + '\t' + str(cpu_percent) + '\t' + str(mem_percent)
		print (line)
		f.write(line + "\n")
		time.sleep(interval)

3

import asyncio
import time
 
import psutil
 
 
async def monitor_io(process_id, duration):
    process = psutil.Process(process_id)
    start_time = time.time()
 
    while time.time() - start_time < duration:
        io_counters = process.io_counters()
        print(f"读取字节数: {io_counters.read_bytes / 1024 / 1024} MB")
        print(f"写入字节数: {io_counters.write_bytes / 1024 / 1024} MB")
        await asyncio.sleep(1)
 
 
async def monitor_memory(process_id, duration):
    process = psutil.Process(process_id)
    start_time = time.time()
 
    while time.time() - start_time < duration:
        memory_info = process.memory_info()
        memory_percent = process.memory_percent()
        print(f"内存使用量: {memory_info.rss / (1024 * 1024):.2f} MB")
        print(f"内存使用率: {memory_percent:.2f}%")
        await asyncio.sleep(1)
 
 
async def monitor_cpu(process_id, duration):
    process = psutil.Process(process_id)
    start_time = time.time()
 
    while time.time() - start_time < duration:
        cpu_percent = process.cpu_percent(interval=1)
        print(f"CPU 使用率: {cpu_percent}%")
        await asyncio.sleep(1)
 
 
async def monitor_run(process_id, duration):
    process_id = int(input("请输入进程ID："))
    duration = int(input("请输入监控时长（秒）："))
 
    tasks = [
        monitor_io(process_id, duration),
        monitor_memory(process_id, duration),
        monitor_cpu(process_id, duration)
    ]
 
    await asyncio.gather(*tasks)
 
 
if __name__ == "__main__":
    asyncio.run(monitor_run())

4 获取pid

#!/usr/bin/env python3.9
import os
import signal
import subprocess
import time
import psutil
import process_monitor

sub_proc = subprocess.Popen(CMD, shell=True)
# psutil.Process获取处理程序的具体信息
psu_proc = psutil.Process(sub_proc.pid)
pcs = None
# 这里不能立即得到sub_proc的子程序，我这里作延时处理
for i in range(4):
    time.sleep(1)
    print(f'尝试检测子进程-{i + 1}')
    # 获取所有子程序
    pcs = psu_proc.children(recursive=True)
    if len(pcs):
        break
if len(pcs):
    print(f'检测到子进程{len(pcs)}个')
else:
    print(f'未检测到子进程,启动失败')
proc = pcs[0]
sub_pid = proc.pid
print(proc.pid)