pmonitor 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

monitor/monitor_mac_vmmap.py

@@ -1,51 +1,116 @@
+import subprocess
+import threading
+import time
+import json
 import re
-import asyncio
+import os
 
 
 class VmMapMemory:
     def __init__(self):
-        self.last_nonzero_memory = None
+        """
+        初始化实时内存监控器
+        """
+        self.pids = set()  # 当前监控的 PID
+        self.current_data = {}  # 存储最新的内存数据 {pid: memory_mb}
+        self.lock = threading.Lock()  # 线程锁
+        self.running = True  # 控制线程运行状态
+        self.thread = None  # 监控线程
+        # 启动监控线程
+        self.start_monitoring()
+
+    def start_monitoring(self):
+        """启动监控线程"""
+        self.thread = threading.Thread(target=self._monitor_memory)
+        self.thread.daemon = True  # 设置为守护线程
+        self.thread.start()
+
+    def update_pids(self, new_pids):
+        """更新要监控的 PID 列表"""
+        with self.lock:
+            # 转换为字符串并更新集合
+            self.pids = set(map(str, new_pids))
+
+    def _convert_to_mb(self, mem_str):
+        """
+        将内存字符串转换为 MB
+        支持格式: 123, 123K, 123M, 123G
+        """
+        # 移除逗号（如果存在）
+        mem_str = mem_str.replace(',', '')
+
+        # 检查单位并转换
+        if 'G' in mem_str:
+            return float(mem_str.replace('G', '')) * 1024
+        elif 'M' in mem_str:
+            return float(mem_str.replace('M', ''))
+        elif 'K' in mem_str:
+            return float(mem_str.replace('K', '')) / 1024
+        else:
+            # 假设为字节
+            return float(mem_str) / (1024 * 1024)
+
+    def _monitor_memory(self):
+        """线程函数：实时监控内存使用"""
+        # macOS 专用 top 命令
+        cmd = ["top", "-stats", "pid,mem"]
+
+        # 启动 top 进程
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,  # 行缓冲
+            universal_newlines=True  # 确保文本模式
+        )
 
-    async def get_process_memory(self, pid):
-        cmd = ["top", "-l", "1", "-stats", "mem", "-pid", str(pid)]
         try:
-            # 创建子进程并设置超时
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.DEVNULL
-            )
-
-            try:
-                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=1)
-            except asyncio.TimeoutError:
-                # 超时后确保子进程被终止
-                proc.kill()
-                await proc.wait()
-                raise
-
-            if proc.returncode == 0:
-                # 解析 top 输出中的内存信息
-                lines = stdout.decode().strip().split('\n')
-                if lines:
-                    last_line = lines[-1].strip()  # 获取最后一行
-                    match = re.match(r'^([\d.]+)([GMK]?)$', last_line)
-
-                    if match:
-                        val, unit = float(match.group(1)), match.group(2)
-                        memory_value = val * {
-                            'G': 1024, 'M': 1, 'K': 1 / 1024, '': 1 / (1024 * 1024)
-                        }.get(unit, 1)
-
-                        if memory_value > 0:
-                            self.last_nonzero_memory = memory_value
-                        # 返回当前值或上一次非零值
-                        return memory_value if memory_value != 0 else self.last_nonzero_memory
+            while self.running:
+                line = process.stdout.readline()  # 逐行读取
+
+                if not line:  # 进程结束或无输出时退出
+                    break
+
+                # 匹配 PID 和内存行 (例如: "12345  123.4M")
+                match = re.match(r'^\s*(\d+)\s+([\d,.]+[KMG]?)\s*$', line.strip())
+                if match:
+                    pid = match.group(1)
+                    mem_str = match.group(2)
+
+                    # 检查是否在监控列表中
+                    with self.lock:
+                        if pid in self.pids:
+                            mem_mb = self._convert_to_mb(mem_str)
+                            # 直接更新当前数据，不保存历史
+                            self.current_data[pid] = round(mem_mb, 2)
+
         except Exception as e:
-            print(e)
+            print(f"Monitoring error: {e}")
         finally:
-            if proc and proc.returncode is None:
-                proc.kill()
-                await proc.wait()
-        # 如果未能获取到有效值，返回上一次非零值或默认值 0.0
-        return self.last_nonzero_memory if self.last_nonzero_memory is not None else 0.0
+            if process.poll() is None:  # 确保进程终止
+                process.terminate()
+
+    def get_current_data(self):
+        """
+        获取当前内存数据（线程安全）
+        只返回当前监控的 PID 的最新内存值
+        """
+        with self.lock:
+            # 只返回当前监控列表中的 PID 数据
+            return {
+                pid: self.current_data.get(pid, 0.0)
+                for pid in self.pids
+            }
+
+    def get_current_json(self):
+        """获取 JSON 格式的当前内存数据"""
+        data = self.get_current_data()
+        return json.dumps(data, indent=2)
+
+    def stop(self):
+        """停止监控"""
+        self.running = False
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=1)
+        print("Memory monitor stopped")

monitor/monitor_pids.py

@@ -25,6 +25,8 @@ class PidsPerf:
     async def get_mac_perf(self):
         current_pid = self.processUtil.find_main_process_pid(self.process_name)
         vm = VmMapMemory()
+        next_time = time.time()  # 初始化下一次执行的时间点
+        first_iteration = True  # 标志变量，用于跳过第一次循环
         while True:
             start_time = time.time()  # 记录循环开始时间
             minor_cpu_sum = 0
@@ -44,13 +46,19 @@ class PidsPerf:
 
             gpu_memory_usage, gpu_memory_total, gpu_memory_free = get_gpu_memory()
             # 使用 asyncio.gather 并发获取内存数据
-            memory_tasks = [vm.get_process_memory(process.pid) for process in pids_process]
-            memory_results = await asyncio.gather(*memory_tasks, return_exceptions=True)
-            for idx, process in enumerate(pids_process):
+            vm.update_pids(current_pids)
+
+            if first_iteration:
+                first_iteration = False  # 第一次循环后将标志置为 False
+                await asyncio.sleep(self.interval / 1000)  # 等待一段时间以确保数据稳定
+                continue  # 跳过第一次循环
+
+            for process in pids_process:
                 try:
                     cpu_percent = process.cpu_percent()
                     mem_percent = u'%.2f' % (process.memory_percent())  # 内存利用率
-                    real_mem = memory_results[idx]  # 实际内存
+                    vm_memory_data = json.loads(vm.get_current_json())
+                    real_mem = vm_memory_data.get(str(process.pid), 0)  # 默认值为 0（如果未找到对应 PID）
                     thread_count = process.num_threads()  # 线程总数
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                     cpu_percent = 0
@@ -80,7 +88,7 @@ class PidsPerf:
             #       minor_thread_count_sum)
             # 获取磁盘IO
             io_read_bytes_start, io_write_bytes_start = self.get_disk_usage()
-            time.sleep(0.1)  # 采集间隔
+            time.sleep(0.1)
             io_read_bytes_end, io_write_bytes_end = self.get_disk_usage()  # io read/write
             io_read_bytes = io_read_bytes_end - io_read_bytes_start  # io read/byte
             io_write_bytes = io_write_bytes_end - io_write_bytes_start  # io write/byte
@@ -91,9 +99,13 @@ class PidsPerf:
                     "memory_total": mem_total, "memory_available": mem_available}
             json_data = json.dumps(data)
             print(json_data)
-            elapsed = time.time() - start_time
-            remaining_time = max(0, self.interval / 1000 - elapsed)
-            await asyncio.sleep(remaining_time)
+            # 精确控制间隔
+            next_time += self.interval
+            sleep_time = next_time - time.time()
+            if sleep_time > 0:
+                await asyncio.sleep(sleep_time)
+            else:
+                next_time = time.time()  # 如果超时，重置时间点
             sys.stdout.flush()
 
     def get_disk_usage(self):
@@ -129,6 +141,7 @@ class PidsPerf:
         # 获取GPU物理内存
         computer = Computer()
         gpu_key = list(computer.gpu.keys())[0]
+        next_time = time.time()  # 初始化下一次执行的时间点
         while True:
             minor_cpu_sum = 0
             minor_workSet_mem_sum = 0
@@ -280,9 +293,13 @@ class PidsPerf:
             sys.stdout.flush()
             # 更新系统时间
             system_time_pre = system_time_post
-            # 等待以确保大约每秒更新一次
-            elapsed = time.time() - start_time
-            time.sleep(max(0, self.interval - elapsed))
+            # 精确控制间隔
+            next_time += self.interval
+            sleep_time = next_time - time.time()
+            if sleep_time > 0:
+                time.sleep(sleep_time)
+            else:
+                next_time = time.time()  # 如果超时，重置时间点v
 
     async def start_perf(self):
         if platform.system() == 'Windows':

{pmonitor-1.4.8.dist-info → pmonitor-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pmonitor
-Version: 1.4.8
+Version: 1.5.0
 Summary: pc monitor
 Home-page: UNKNOWN
 Author: cfr

{pmonitor-1.4.8.dist-info → pmonitor-1.5.0.dist-info}/RECORD

@@ -3,8 +3,8 @@ monitor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monitor/get_process_name.py,sha256=HxePo2gdrTo2Ukg4DTnYzUMdczVWywCeLCXQ-RRWyu8,3913
 monitor/mac_gpu.py,sha256=kQDPMW04lIYPBbJw772Jh1OQxj-D4JNmdjJlP6BuR4w,2320
 monitor/monitor_mac.py,sha256=OoptTTXTZQupzBwgGOfKNjyYAKBxDy-wI3l6T7XVE8s,4651
-monitor/monitor_mac_vmmap.py,sha256=Lu1AAw6auuZzuNZtASOaNBpRPOOgyzGr1jYSTErmRmo,1971
-monitor/monitor_pids.py,sha256=1Bmemd-cf1NkrcCbKwOg-56fDgxSGLXam-EGmr_5AWU,16531
+monitor/monitor_mac_vmmap.py,sha256=j_4Gl6uTnOcjbrYVsYfd_TNhhYo0ewUZf-zCpGUeEgs,3751
+monitor/monitor_pids.py,sha256=kIy8oHIN-OwSDqWHTEUlCFpqCdsvGWmX9gtU0cb0W40,17228
 monitor/monitor_win.py,sha256=xs5nzqqEPoDmJTegh3lQhVjjpPcOWnruWKK65ttqnTo,6161
 monitor/run_monitor.py,sha256=HDQXHIx47ZRN4Gp0PTr0yWKVM28n8A7-NaO--_pdgso,1577
 monitor/sys_info.py,sha256=aNultuRoQuRYPkYo397xAXVDXP07Qx5JOHtYzNmEvuc,3208
@@ -24,8 +24,8 @@ monitor/DLL/sechost.dll,sha256=1mXCrgNDRBiZ2XZk7eTpDm4oPG-x9BW4uYUVkrfvBkk,69986
 monitor/DLL/ucrtbased.dll,sha256=vtmKFPEHyr2OXkrUOu3Qs1dlbKG1dxZ8ItKCkTTU5S4,2238056
 monitor/DLL/vcruntime140.dll,sha256=AsaqDm5iRBGp8ZsDYKeGWrFZCOJgJFEOXDipwINiw1o,119888
 monitor/DLL/vcruntime140_1.dll,sha256=fdmqAuJxxoym1fGNZR0joV1yWXFa9DMmV4993ifzdjc,49640
-pmonitor-1.4.8.dist-info/METADATA,sha256=cHkAUgHDu0voEx1JNF_q1qbPo7YGVzlt6_h4J53KZRs,291
-pmonitor-1.4.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pmonitor-1.4.8.dist-info/entry_points.txt,sha256=vmlLEANgf2fZar9BeXYiKdF6GMJbVXip-SIZx5yPXDo,55
-pmonitor-1.4.8.dist-info/top_level.txt,sha256=tGkQDkVeyKgP5Rr7acpp0df83NBAnI8up0sGwRxuuQ4,8
-pmonitor-1.4.8.dist-info/RECORD,,
+pmonitor-1.5.0.dist-info/METADATA,sha256=BAZnw0kdkSDw4V3MrOBTuSW2Oc090dVpMWOLfNj2Xco,291
+pmonitor-1.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pmonitor-1.5.0.dist-info/entry_points.txt,sha256=vmlLEANgf2fZar9BeXYiKdF6GMJbVXip-SIZx5yPXDo,55
+pmonitor-1.5.0.dist-info/top_level.txt,sha256=tGkQDkVeyKgP5Rr7acpp0df83NBAnI8up0sGwRxuuQ4,8
+pmonitor-1.5.0.dist-info/RECORD,,