""" VR性能监控子系统 负责VR应用的性能监控、GPU计时、管线统计和性能诊断 """ import sys import gc import time # 可选依赖 try: import psutil PSUTIL_AVAILABLE = True except ImportError: PSUTIL_AVAILABLE = False try: import GPUtil GPUTIL_AVAILABLE = True except ImportError: GPUTIL_AVAILABLE = False try: import pynvml PYNVML_AVAILABLE = True except ImportError: PYNVML_AVAILABLE = False class VRPerformanceMonitor: """VR性能监控系统 功能： - 实时性能监控（CPU、内存、GPU） - GPU渲染时间统计 - 渲染管线分析 - 性能诊断和优化建议 """ def __init__(self, vr_manager): """初始化性能监控系统 Args: vr_manager: VRManager实例的引用 """ self.vr_manager = vr_manager # ===== 性能计数器 ===== self.frame_count = 0 self.last_fps_check = 0 self.last_fps_time = 0 self.vr_fps = 0 self.submit_failures = 0 self.pose_failures = 0 # ===== 性能监控配置 ===== self.performance_monitoring = False # 是否启用性能监控 self.debug_output_enabled = False # 是否启用调试输出 self.debug_mode = 'detailed' # 'brief' 或 'detailed' self.cpu_usage = 0.0 self.memory_usage = 0.0 self.gpu_usage = 0.0 self.gpu_memory_usage = 0.0 self.frame_times = [] # 存储最近帧时间 self.max_frame_time_history = 60 # 保存60帧的历史 self.last_performance_check = 0 self.performance_check_interval = 0.5 # 每0.5秒更新一次性能数据 # ===== 渲染管线监控 ===== self.enable_pipeline_monitoring = True # 是否启用管线监控 self.performance_mode_enabled = False # 性能优化模式（禁用监控以减少对象创建） self.performance_mode_trigger_frame = 600 # 第600帧后启用性能模式 self.wait_poses_time = 0.0 # waitGetPoses耗时 self.left_render_time = 0.0 # 左眼渲染耗时 self.right_render_time = 0.0 # 右眼渲染耗时 self.submit_time = 0.0 # 纹理提交耗时 self.left_render_count = 0 # 左眼渲染次数计数 self.right_render_count = 0 # 右眼渲染次数计数 self.total_frame_time = 0.0 # 总帧时间 self.vr_sync_wait_time = 0.0 # VR同步等待时间 # ===== 时间监控历史 ===== self.wait_poses_times = [] self.render_times = [] self.submit_times = [] self.sync_wait_times = [] self.pipeline_history_size = 30 # ===== GPU渲染时间监控 ===== self.enable_gpu_timing = False # 是否启用GPU时间监控（默认关闭） self.gpu_scene_render_ms = 0.0 # GPU场景渲染时间 self.gpu_pre_submit_ms = 0.0 # 提交前GPU时间 self.gpu_post_submit_ms = 0.0 # 提交后GPU时间 self.gpu_total_render_ms = 0.0 # GPU总渲染时间 self.gpu_compositor_render_ms = 0.0 # GPU合成器渲染时间 self.gpu_client_frame_interval_ms = 0.0 # 客户端帧间隔 self.gpu_timing_history = [] # GPU时间历史记录 self.gpu_timing_history_size = 30 # GPU时间历史记录大小 self.gpu_timing_failure_count = 0 # GPU时间获取失败次数 # ===== VR系统信息 ===== self.current_eye_resolution = (0, 0) self.recommended_eye_resolution = (0, 0) self.vr_display_frequency = 0.0 self.vr_vsync_enabled = True self.vsync_to_photons_ms = 0.0 # VSync到光子的延迟 self.target_frame_time_ms = 0.0 # 目标帧时间 self.vsync_window_ms = 0.0 # VSync时间窗口 self.async_reprojection_enabled = False # 异步重投影状态 self.motion_smoothing_enabled = False # 运动平滑状态 # ===== 性能报告间隔 ===== self.performance_report_interval = 1800 # 默认1800帧（30秒@60fps） # ===== 内部状态 ===== self._last_frame_time = None # 用于帧时间计算 # 初始化性能监控库 self._init_performance_monitoring() # ========== 性能报告方法 ========== def _print_performance_report(self): """输出VR性能报告""" if not self.performance_monitoring or not self.debug_output_enabled: return stats = self.get_performance_stats() # 简短模式输出 if self.debug_mode == 'brief': self._print_brief_performance_report(stats) return print("📊 ======= VR性能监控报告 =======") # 帧率和帧时间信息 print(f"🎯 渲染性能:") print(f" VR帧率: {stats['vr_fps']:.1f} FPS") print(f" 平均帧时间: {stats['frame_time_avg']:.2f} ms") print(f" 最小帧时间: {stats['frame_time_min']:.2f} ms") print(f" 最大帧时间: {stats['frame_time_max']:.2f} ms") print(f" 95%帧时间: {stats['frame_time_95th']:.2f} ms") # 系统性能 print(f"💻 系统性能:") print(f" CPU使用率: {stats['cpu_usage']:.1f}%") print(f" 内存使用率: {stats['memory_usage']:.1f}%") # GPU性能 print(f"🎮 GPU性能:") if self.gputil_available or self.nvidia_ml_available: print(f" GPU使用率: {stats['gpu_usage']:.1f}%") print(f" 显存使用率: {stats['gpu_memory_usage']:.1f}%") else: print(f" GPU监控: 不可用 (需要安装 GPUtil 或 pynvml)") print(f" 安装命令: pip install GPUtil nvidia-ml-py") # GPU渲染时间（OpenVR Frame Timing） if self.enable_gpu_timing: print(f"⚡ GPU渲染时间:") pipeline_stats = self._get_pipeline_stats() gpu_stats = pipeline_stats.get('gpu_timing', {}) gpu_current = pipeline_stats.get('current', {}) # 检查是否有可用的GPU时间数据 has_gpu_data = any( gpu_current.get(field, 0) > 0 for field in ['gpu_scene_render', 'gpu_total_render', 'gpu_pre_submit', 'gpu_post_submit', 'gpu_compositor_render'] ) if has_gpu_data: # 显示GPU时间统计（最近30帧平均） scene_render = gpu_stats.get('scene_render', {'avg': 0}) total_render = gpu_stats.get('total_render', {'avg': 0}) pre_submit = gpu_stats.get('pre_submit', {'avg': 0}) post_submit = gpu_stats.get('post_submit', {'avg': 0}) compositor = gpu_stats.get('compositor_render', {'avg': 0}) if scene_render['avg'] > 0: print(f" GPU场景渲染: {scene_render['avg']:.2f}ms (min:{scene_render['min']:.1f}, max:{scene_render['max']:.1f})") if total_render['avg'] > 0: print(f" GPU总渲染时间: {total_render['avg']:.2f}ms (min:{total_render['min']:.1f}, max:{total_render['max']:.1f})") if pre_submit['avg'] > 0: print(f" GPU提交前时间: {pre_submit['avg']:.2f}ms (min:{pre_submit['min']:.1f}, max:{pre_submit['max']:.1f})") if post_submit['avg'] > 0: print(f" GPU提交后时间: {post_submit['avg']:.2f}ms (min:{post_submit['min']:.1f}, max:{post_submit['max']:.1f})") if compositor['avg'] > 0: print(f" GPU合成器时间: {compositor['avg']:.2f}ms (min:{compositor['min']:.1f}, max:{compositor['max']:.1f})") # 显示当前帧GPU时间 print(f"🔍 当前帧GPU时间:") if gpu_current.get('gpu_scene_render', 0) > 0: print(f" 场景渲染: {gpu_current['gpu_scene_render']:.2f}ms") if gpu_current.get('gpu_total_render', 0) > 0: print(f" 总渲染: {gpu_current['gpu_total_render']:.2f}ms") if gpu_current.get('gpu_compositor_render', 0) > 0: print(f" 合成器: {gpu_current['gpu_compositor_render']:.2f}ms") # GPU时间瓶颈分析 current_total = gpu_current.get('gpu_total_render', 0) current_scene = gpu_current.get('gpu_scene_render', 0) if current_total > 12.0: # 假设72fps目标，留出一些余量 print(f" ⚠️ GPU总渲染时间过长: {current_total:.1f}ms") elif current_scene > 8.0: print(f" ⚠️ GPU场景渲染时间偏高: {current_scene:.1f}ms") else: print(f" GPU渲染时间: 暂无数据") if self.gpu_timing_failure_count > 0: print(f" 获取失败次数: {self.gpu_timing_failure_count}") else: print(f" 等待OpenVR Frame Timing数据...") else: print(f"⚡ GPU渲染时间: 已禁用") # VR特定指标 print(f"🥽 VR指标:") print(f" 总帧数: {stats['frame_count']}") print(f" 提交失败: {stats['submit_failures']}") print(f" 姿态失败: {stats['pose_failures']}") # 计算失败率 if stats['frame_count'] > 0: submit_fail_rate = (stats['submit_failures'] / stats['frame_count']) * 100 pose_fail_rate = (stats['pose_failures'] / stats['frame_count']) * 100 print(f" 提交失败率: {submit_fail_rate:.2f}%") print(f" 姿态失败率: {pose_fail_rate:.2f}%") # 渲染管线监控 target_frame_time = 13.9 # 默认目标帧时间(72Hz) if self.enable_pipeline_monitoring: pipeline_stats = self._get_pipeline_stats() print(f"⚙️ 渲染管线分析:") print(f" 当前分辨率: {pipeline_stats['vr_info']['eye_resolution'][0]}x{pipeline_stats['vr_info']['eye_resolution'][1]}") print(f" 推荐分辨率: {pipeline_stats['vr_info']['recommended_resolution'][0]}x{pipeline_stats['vr_info']['recommended_resolution'][1]}") print(f" 显示频率: {pipeline_stats['vr_info']['display_frequency']:.1f} Hz") # VSync和时序信息 if pipeline_stats['vr_info']['target_frame_time_ms'] > 0: print(f"🎯 VSync时序:") print(f" 目标帧时间: {pipeline_stats['vr_info']['target_frame_time_ms']:.2f}ms") print(f" VSync到光子: {pipeline_stats['vr_info']['vsync_to_photons_ms']:.2f}ms") print(f" VSync窗口: ±{pipeline_stats['vr_info']['vsync_window_ms']:.2f}ms") print(f" 异步重投影: {'启用' if pipeline_stats['vr_info']['async_reprojection'] else '禁用'}") print(f" 运动平滑: {'启用' if pipeline_stats['vr_info']['motion_smoothing'] else '禁用'}") # 分析帧时间是否在目标范围内 current_frame_time = stats['frame_time_avg'] target_frame_time = pipeline_stats['vr_info']['target_frame_time_ms'] if current_frame_time > 0 and target_frame_time > 0: frame_time_ratio = current_frame_time / target_frame_time if frame_time_ratio > 1.1: print(f" ⚠️ 帧时间超标: {current_frame_time:.1f}ms (目标:{target_frame_time:.1f}ms)") elif frame_time_ratio < 0.9: print(f" ✅ 帧时间充裕: {current_frame_time:.1f}ms (目标:{target_frame_time:.1f}ms)") else: print(f" ✓ 帧时间正常: {current_frame_time:.1f}ms (目标:{target_frame_time:.1f}ms)") # 🔧 性能优化诊断 print(f"🔧 优化诊断:") current = pipeline_stats.get('current', {}) if self.enable_pipeline_monitoring else {} # 🔍 渲染回调诊断 - 新增 self._print_render_callback_diagnostics() # waitGetPoses时序分析 wait_poses_time = current.get('wait_poses', 0) if wait_poses_time > 10: print(f" ⚠️ waitGetPoses时间过长: {wait_poses_time:.1f}ms") print(f" 可能原因: 错过VSync窗口，建议调整预测时间") elif wait_poses_time > 5: print(f" ⚠️ waitGetPoses时间偏高: {wait_poses_time:.1f}ms") else: print(f" ✓ waitGetPoses时间正常: {wait_poses_time:.1f}ms") # CPU-GPU并行度分析 - 增强诊断 gpu_total = current.get('gpu_total_render', 0) cpu_render_left = self.left_render_time cpu_render_right = self.right_render_time cpu_render_total = cpu_render_left + cpu_render_right print(f" 真实渲染时间对比:") print(f" CPU左眼: {cpu_render_left:.2f}ms") print(f" CPU右眼: {cpu_render_right:.2f}ms") print(f" CPU总计: {cpu_render_total:.2f}ms") print(f" GPU总计: {gpu_total:.2f}ms") if cpu_render_total < 1.0: print(f" ⚠️ CPU渲染时间异常短: {cpu_render_total:.2f}ms") print(f" 可能原因: 渲染回调未正确执行或渲染被跳过") elif gpu_total > 0 and cpu_render_total > 0: ratio = gpu_total / cpu_render_total if ratio > 10: print(f" ⚠️ GPU严重等待CPU: 比例{ratio:.1f}:1") print(f" 建议: 检查OpenGL命令提交时机和渲染状态") elif ratio > 3: print(f" ⚠️ GPU等待CPU: 比例{ratio:.1f}:1") print(f" 建议: 检查OpenGL命令提交是否及时") else: print(f" ✓ CPU-GPU时间匹配: 比例{ratio:.1f}:1") # 预测时间诊断 current_prediction = self.vr_manager.use_prediction_time * 1000 print(f" 预测时间设置: {current_prediction:.1f}ms") if current_prediction > 15: print(f" 建议: 预测时间较高，可能增加waitGetPoses延迟") elif current_prediction < 8: print(f" 注意: 预测时间较低，可能影响姿态准确性") else: print(f" ✓ 预测时间在合理范围内") # 优化状态总结 optimization_score = 0 if wait_poses_time < 8: optimization_score += 1 if stats['vr_fps'] > 60: optimization_score += 1 if stats.get('frame_time_avg', 0) < target_frame_time * 1.1: optimization_score += 1 if optimization_score >= 2: print(f" ✅ 优化效果良好 ({optimization_score}/3)") else: print(f" ⚠️ 仍有优化空间 ({optimization_score}/3)") # 显示详细统计信息（仅当管线监控启用时） if self.enable_pipeline_monitoring: print(f"🕐 各阶段耗时 (最近{self.pipeline_history_size}帧平均):") print(f" waitGetPoses: {pipeline_stats['wait_poses']['avg']:.2f}ms (min:{pipeline_stats['wait_poses']['min']:.1f}, max:{pipeline_stats['wait_poses']['max']:.1f})") print(f" 渲染总计: {pipeline_stats['render']['avg']:.2f}ms (min:{pipeline_stats['render']['min']:.1f}, max:{pipeline_stats['render']['max']:.1f})") print(f" 纹理提交: {pipeline_stats['submit']['avg']:.2f}ms (min:{pipeline_stats['submit']['min']:.1f}, max:{pipeline_stats['submit']['max']:.1f})") if pipeline_stats['sync_wait']['avg'] > 0: print(f" 同步等待: {pipeline_stats['sync_wait']['avg']:.2f}ms (min:{pipeline_stats['sync_wait']['min']:.1f}, max:{pipeline_stats['sync_wait']['max']:.1f})") print(f"🔍 当前帧详情:") print(f" 左眼渲染: {pipeline_stats['current']['left_render']:.2f}ms") print(f" 右眼渲染: {pipeline_stats['current']['right_render']:.2f}ms") print(f" 姿态获取: {pipeline_stats['current']['wait_poses']:.2f}ms") # 显示Running Start模式信息 print(f"🎯 Running Start模式:") print(f" 模式: Valve Running Start - 帧开始时获取姿态") print(f" 优势: VSync前3ms获取姿态，提供充足渲染时间") print(f" 预测时间: {self.vr_manager.use_prediction_time * 1000:.1f}ms") # 分析最大瓶颈 current = pipeline_stats['current'] bottleneck_analysis = [] if current['wait_poses'] > 5.0: bottleneck_analysis.append(f"姿态获取耗时过长({current['wait_poses']:.1f}ms)") if current['total_render'] > 8.0: bottleneck_analysis.append(f"渲染耗时过长({current['total_render']:.1f}ms)") if current['submit'] > 2.0: bottleneck_analysis.append(f"纹理提交耗时过长({current['submit']:.1f}ms)") if bottleneck_analysis: print(f"🚨 瓶颈分析:") for analysis in bottleneck_analysis: print(f" ⚠️ {analysis}") # 性能建议 self._print_performance_recommendations(stats) print("===============================") def _print_performance_recommendations(self, stats): """根据性能数据输出优化建议""" print(f"💡 性能建议:") recommendations = [] # FPS相关建议 if stats['vr_fps'] < 60: recommendations.append(" ⚠️ VR帧率过低，可能影响体验") # 帧时间相关建议 if stats['frame_time_avg'] > 16.7: # 60fps = 16.7ms recommendations.append(" ⚠️ 平均帧时间过高，建议降低渲染质量") if stats['frame_time_max'] > 50: recommendations.append(" ⚠️ 检测到严重卡顿，检查CPU/GPU负载") # CPU建议 if stats['cpu_usage'] > 80: recommendations.append(" 🔴 CPU使用率过高，可能存在CPU瓶颈") elif stats['cpu_usage'] > 60: recommendations.append(" 🟡 CPU使用率偏高，注意监控") # 内存建议 if stats['memory_usage'] > 85: recommendations.append(" 🔴 内存使用率过高，可能影响性能") # GPU建议 if self.gputil_available or self.nvidia_ml_available: if stats['gpu_usage'] > 95: recommendations.append(" 🔴 GPU使用率接近满载，存在GPU瓶颈") if stats['gpu_memory_usage'] > 90: recommendations.append(" 🔴 显存使用率过高，可能需要降低纹理质量") # GPU渲染时间建议 if self.enable_gpu_timing: if self.gpu_total_render_ms > 12.0: recommendations.append(" ⚠️ GPU总渲染时间过长，建议优化场景复杂度") if self.gpu_scene_render_ms > 8.0: recommendations.append(" ⚠️ GPU场景渲染时间偏高，考虑降低渲染质量") if self.gpu_compositor_render_ms > 3.0: recommendations.append(" ⚠️ GPU合成器时间过长，检查VR设置或叠加层") if self.gpu_timing_failure_count > 100: recommendations.append(" ⚠️ GPU时间统计频繁失败，可能需要更新OpenVR") # 失败率建议 submit_fail_rate = (stats['submit_failures'] / max(stats['frame_count'], 1)) * 100 if submit_fail_rate > 1: recommendations.append(" ⚠️ VR帧提交失败率较高，检查VR系统状态") if not recommendations: recommendations.append(" ✅ 性能表现良好，无明显问题") for rec in recommendations: print(rec) def _print_brief_performance_report(self, stats): """输出简短的VR性能报告""" # 创建一行简短摘要 summary = f"🥽 VR性能: {stats['vr_fps']:.1f}fps" if stats['frame_time_avg'] > 0: summary += f" | 帧时间: {stats['frame_time_avg']:.1f}ms" if self.psutil_available: summary += f" | CPU: {stats['cpu_usage']:.0f}%" summary += f" | 内存: {stats['memory_usage']:.0f}%" # 显示GPU信息，如果库不可用则显示提示 if self.gputil_available or self.nvidia_ml_available: summary += f" | GPU: {stats['gpu_usage']:.0f}%" else: summary += " | GPU: N/A" # 添加失败率指示 if stats['frame_count'] > 0: submit_fail_rate = (stats['submit_failures'] / stats['frame_count']) * 100 if submit_fail_rate > 0.1: summary += f" | 提交失败: {submit_fail_rate:.1f}%" # 添加管线关键信息 if self.enable_pipeline_monitoring: pipeline_stats = self._get_pipeline_stats() current = pipeline_stats['current'] # 显示关键瓶颈 if current['wait_poses'] > 5.0: summary += f" | 姿态: {current['wait_poses']:.1f}ms⚠️" elif current['wait_poses'] > 0: summary += f" | 姿态: {current['wait_poses']:.1f}ms" if current['total_render'] > 8.0: summary += f" | 渲染: {current['total_render']:.1f}ms⚠️" elif current['total_render'] > 0: summary += f" | 渲染: {current['total_render']:.1f}ms" # 添加GPU渲染时间信息 if self.enable_gpu_timing: gpu_total = current.get('gpu_total_render', 0) gpu_scene = current.get('gpu_scene_render', 0) if gpu_total > 12.0: summary += f" | GPU: {gpu_total:.1f}ms⚠️" elif gpu_total > 0: summary += f" | GPU: {gpu_total:.1f}ms" elif gpu_scene > 0: summary += f" | GPU场景: {gpu_scene:.1f}ms" # 显示目标帧时间对比 vr_info = pipeline_stats['vr_info'] if vr_info['target_frame_time_ms'] > 0: target = vr_info['target_frame_time_ms'] current_avg = stats['frame_time_avg'] if current_avg > target * 1.1: summary += f" | 目标:{target:.0f}ms⚠️" else: summary += f" | 目标:{target:.0f}ms" # 性能状态指示 if stats['vr_fps'] < 72: summary += " ⚠️" elif stats['vr_fps'] > 85: summary += " ✅" print(summary) # ========== 性能监控核心方法 ========== def _init_performance_monitoring(self): """初始化性能监控库""" self.psutil_available = False self.gputil_available = False self.nvidia_ml_available = False try: import psutil self.psutil = psutil self.psutil_available = True print("✓ psutil性能监控库已加载") except ImportError: print("⚠️ psutil库未安装，CPU和内存监控将不可用") try: import GPUtil self.gputil = GPUtil self.gputil_available = True print("✓ GPUtil GPU监控库已加载") except ImportError: print("⚠️ GPUtil库未安装，GPU监控将不可用") try: import pynvml self.pynvml = pynvml pynvml.nvmlInit() self.nvidia_ml_available = True print("✓ NVIDIA-ML GPU监控库已加载") except ImportError: print("⚠️ pynvml库未安装，NVIDIA GPU详细监控将不可用") except Exception as e: print(f"⚠️ NVIDIA-ML初始化失败: {e}") def _update_performance_metrics(self): """更新系统性能指标""" if not self.performance_monitoring: return current_time = time.time() # 限制更新频率 if current_time - self.last_performance_check < self.performance_check_interval: return self.last_performance_check = current_time try: # 更新CPU和内存使用率 if self.psutil_available: self.cpu_usage = self.psutil.cpu_percent(interval=None) memory = self.psutil.virtual_memory() self.memory_usage = memory.percent # 更新GPU使用率 self._update_gpu_metrics() except Exception as e: if self.frame_count % 600 == 0: # 每10秒输出一次错误 print(f"⚠️ 性能监控更新失败: {e}") def _update_gpu_metrics(self): """更新GPU相关指标""" try: # 方法1: 使用GPUtil if self.gputil_available: gpus = self.gputil.getGPUs() if gpus: gpu = gpus[0] # 使用第一个GPU self.gpu_usage = gpu.load * 100 self.gpu_memory_usage = gpu.memoryUtil * 100 # 方法2: 使用NVIDIA-ML (更精确) elif self.nvidia_ml_available: try: handle = self.pynvml.nvmlDeviceGetHandleByIndex(0) # GPU使用率 utilization = self.pynvml.nvmlDeviceGetUtilizationRates(handle) self.gpu_usage = utilization.gpu # GPU内存使用率 memory_info = self.pynvml.nvmlDeviceGetMemoryInfo(handle) self.gpu_memory_usage = (memory_info.used / memory_info.total) * 100 except Exception as e: # NVIDIA-ML可能无法在某些系统上工作 pass except Exception as e: # GPU监控失败，但不影响VR功能 pass def _track_frame_time(self): """记录帧时间 - 性能优化版本""" current_time = time.time() if self._last_frame_time is not None: frame_time = (current_time - self._last_frame_time) * 1000 # 转换为毫秒 # 🚀 性能优化：性能模式下跳过列表操作以减少内存分配 if not self.performance_mode_enabled: # 添加到帧时间历史 self.frame_times.append(frame_time) # 限制历史长度 if len(self.frame_times) > self.max_frame_time_history: self.frame_times.pop(0) self._last_frame_time = current_time # ========== GPU计时方法 ========== def _get_gpu_frame_timing(self, frames_ago=0): """获取GPU渲染时间统计 Args: frames_ago: 获取多少帧之前的数据，0表示当前帧 Returns: dict: GPU时间数据，如果获取失败返回None """ if not self.enable_gpu_timing or not self.vr_manager.vr_compositor: return None try: # 调用OpenVR的getFrameTiming API result, timing = self.vr_manager.vr_compositor.getFrameTiming(framesAgo=frames_ago) if not result: self.gpu_timing_failure_count += 1 if self.gpu_timing_failure_count % 300 == 1: # 每5秒输出一次错误 print("⚠️ OpenVR getFrameTiming调用失败") return None # 提取GPU时间数据（单位：毫秒） gpu_data = {} # 检查timing对象是否有GPU时间相关的属性 if hasattr(timing, 'm_flSceneRenderGpuMs'): gpu_data['scene_render'] = timing.m_flSceneRenderGpuMs self.gpu_scene_render_ms = timing.m_flSceneRenderGpuMs if hasattr(timing, 'm_flPreSubmitGpuMs'): gpu_data['pre_submit'] = timing.m_flPreSubmitGpuMs self.gpu_pre_submit_ms = timing.m_flPreSubmitGpuMs if hasattr(timing, 'm_flPostSubmitGpuMs'): gpu_data['post_submit'] = timing.m_flPostSubmitGpuMs self.gpu_post_submit_ms = timing.m_flPostSubmitGpuMs if hasattr(timing, 'm_flTotalRenderGpuMs'): gpu_data['total_render'] = timing.m_flTotalRenderGpuMs self.gpu_total_render_ms = timing.m_flTotalRenderGpuMs if hasattr(timing, 'm_flCompositorRenderGpuMs'): gpu_data['compositor_render'] = timing.m_flCompositorRenderGpuMs self.gpu_compositor_render_ms = timing.m_flCompositorRenderGpuMs if hasattr(timing, 'm_flClientFrameIntervalMs'): gpu_data['frame_interval'] = timing.m_flClientFrameIntervalMs self.gpu_client_frame_interval_ms = timing.m_flClientFrameIntervalMs # 将GPU时间数据添加到历史记录 if gpu_data: self.gpu_timing_history.append(gpu_data) if len(self.gpu_timing_history) > self.gpu_timing_history_size: self.gpu_timing_history.pop(0) # 调试信息 - 仅在第一次成功时输出 if not hasattr(self, '_gpu_timing_success_logged'): available_fields = list(gpu_data.keys()) print(f"✅ GPU时间统计已启用 - 可用字段: {available_fields}") self._gpu_timing_success_logged = True return gpu_data except AttributeError as e: # OpenVR Python绑定可能不包含某些字段 if self.gpu_timing_failure_count == 0: print(f"⚠️ GPU时间统计部分功能不可用: {e}") print(" 这可能是由于OpenVR Python绑定版本问题") self.gpu_timing_failure_count += 1 return None except Exception as e: self.gpu_timing_failure_count += 1 if self.gpu_timing_failure_count % 300 == 1: # 每5秒输出一次错误 print(f"⚠️ 获取GPU时间统计失败: {e}") return None def enable_gpu_timing_monitoring(self): """启用GPU时间监控""" self.enable_gpu_timing = True print("✓ VR GPU时间监控已启用") def disable_gpu_timing_monitoring(self): """禁用GPU时间监控""" self.enable_gpu_timing = False print("✓ VR GPU时间监控已禁用") # ========== 管线统计方法 ========== def _start_timing(self, operation_name): """开始计时操作 - 性能优化版本""" if not self.enable_pipeline_monitoring or self.performance_mode_enabled: return None # 🚀 性能优化：减少字典创建，只在必要时创建 return { 'operation': operation_name, 'start_time': time.perf_counter() } def _end_timing(self, timing_data): """结束计时并记录结果 - 性能优化版本""" if not self.enable_pipeline_monitoring or self.performance_mode_enabled or not timing_data: return 0.0 elapsed = (time.perf_counter() - timing_data['start_time']) * 1000 # 转换为毫秒 # 保存到相应的历史记录 operation = timing_data['operation'] if operation == 'wait_poses': self.wait_poses_time = elapsed self.wait_poses_times.append(elapsed) if len(self.wait_poses_times) > self.pipeline_history_size: self.wait_poses_times.pop(0) elif operation == 'left_render': self.left_render_time = elapsed elif operation == 'right_render': self.right_render_time = elapsed elif operation == 'submit': self.submit_time = elapsed self.submit_times.append(elapsed) if len(self.submit_times) > self.pipeline_history_size: self.submit_times.pop(0) elif operation == 'sync_wait': self.vr_sync_wait_time = elapsed self.sync_wait_times.append(elapsed) if len(self.sync_wait_times) > self.pipeline_history_size: self.sync_wait_times.pop(0) # 计算总渲染时间 total_render = self.left_render_time + self.right_render_time self.render_times.append(total_render) if len(self.render_times) > self.pipeline_history_size: self.render_times.pop(0) return elapsed def _get_pipeline_stats(self): """获取渲染管线统计信息""" def get_stats(times_list): if not times_list: return {'avg': 0.0, 'min': 0.0, 'max': 0.0} return { 'avg': sum(times_list) / len(times_list), 'min': min(times_list), 'max': max(times_list) } # 计算GPU时间统计 def get_gpu_field_stats(field_name): """从GPU时间历史记录中提取特定字段的统计信息""" values = [] for gpu_data in self.gpu_timing_history: if field_name in gpu_data: values.append(gpu_data[field_name]) return get_stats(values) return { 'wait_poses': get_stats(self.wait_poses_times), 'render': get_stats(self.render_times), 'submit': get_stats(self.submit_times), 'sync_wait': get_stats(self.sync_wait_times), 'gpu_timing': { 'scene_render': get_gpu_field_stats('scene_render'), 'pre_submit': get_gpu_field_stats('pre_submit'), 'post_submit': get_gpu_field_stats('post_submit'), 'total_render': get_gpu_field_stats('total_render'), 'compositor_render': get_gpu_field_stats('compositor_render'), 'frame_interval': get_gpu_field_stats('frame_interval') }, 'current': { 'wait_poses': self.wait_poses_time, 'left_render': self.left_render_time, 'right_render': self.right_render_time, 'submit': self.submit_time, 'sync_wait': self.vr_sync_wait_time, 'total_render': self.left_render_time + self.right_render_time, 'gpu_scene_render': self.gpu_scene_render_ms, 'gpu_pre_submit': self.gpu_pre_submit_ms, 'gpu_post_submit': self.gpu_post_submit_ms, 'gpu_total_render': self.gpu_total_render_ms, 'gpu_compositor_render': self.gpu_compositor_render_ms, 'gpu_frame_interval': self.gpu_client_frame_interval_ms }, 'vr_info': { 'eye_resolution': self.current_eye_resolution, 'recommended_resolution': self.recommended_eye_resolution, 'display_frequency': self.vr_display_frequency, 'vsync_enabled': self.vr_vsync_enabled, 'target_frame_time_ms': self.target_frame_time_ms, 'vsync_to_photons_ms': self.vsync_to_photons_ms, 'vsync_window_ms': self.vsync_window_ms, 'async_reprojection': self.async_reprojection_enabled, 'motion_smoothing': self.motion_smoothing_enabled, 'gpu_timing_enabled': self.enable_gpu_timing, 'gpu_timing_failures': self.gpu_timing_failure_count } } def test_pipeline_monitoring(self): """测试管线监控功能 - 用于调试和验证""" print("🔧 正在测试VR管线监控功能...") try: # 测试基本信息获取 print("📊 基本信息:") print(f" 当前分辨率: {self.current_eye_resolution}") print(f" 显示频率: {self.vr_display_frequency} Hz") print(f" 目标帧时间: {self.target_frame_time_ms:.2f}ms") # Running Start模式信息 print("🎯 Running Start模式:") print(f" 预测时间: {self.vr_manager.use_prediction_time * 1000:.1f}ms") print(f" 模式: Valve Running Start - 帧开始时获取姿态") # 测试管线统计 if self.enable_pipeline_monitoring: pipeline_stats = self._get_pipeline_stats() print("⚙️ 管线统计:") print(f" waitGetPoses历史: {len(self.wait_poses_times)}帧") print(f" 渲染历史: {len(self.render_times)}帧") print(f" 提交历史: {len(self.submit_times)}帧") # 测试性能报告 print("📋 生成详细性能报告:") self._print_performance_report() print("✅ 管线监控功能测试完成") else: print("⚠️ 管线监控已禁用，无法测试统计功能") except Exception as e: print(f"❌ 测试管线监控功能时发生错误: {e}") import traceback traceback.print_exc() def set_prediction_time(self, prediction_time_ms): """设置预测时间（仅用于update_task策略） Args: prediction_time_ms: 预测时间，单位毫秒（通常8-16ms） """ prediction_time_s = prediction_time_ms / 1000.0 if prediction_time_s < 0.005 or prediction_time_s > 0.020: print(f"⚠️ 预测时间超出推荐范围(5-20ms): {prediction_time_ms}ms") old_time = self.vr_manager.use_prediction_time * 1000 self.vr_manager.use_prediction_time = prediction_time_s print(f"✓ VR预测时间已设置: {old_time:.1f}ms → {prediction_time_ms:.1f}ms") # ========== 诊断工具方法 ========== def _print_render_callback_diagnostics(self): """输出渲染回调诊断信息 - 包含优化效果分析""" try: print(f"🔍 DrawCallback渲染诊断:") # 回调次数统计 left_count = self.left_render_count right_count = self.right_render_count print(f" 渲染次数: 左眼={left_count}, 右眼={right_count}") if left_count == 0 and right_count == 0: print(f" ❌ VR缓冲区未被渲染 - 这是严重问题!") return # 渲染次数平衡性检查 if abs(left_count - right_count) > 5: print(f" ⚠️ 左右眼渲染次数不平衡: 差异={abs(left_count - right_count)}") else: print(f" ✓ 左右眼渲染次数平衡") # 🔧 真实渲染时间分析 - 显示优化效果 left_render_time = self.left_render_time right_render_time = self.right_render_time total_render_time = left_render_time + right_render_time print(f" ⏱️ 精确渲染时间测量:") print(f" 左眼cbdata.upcall(): {left_render_time:.2f}ms") print(f" 右眼cbdata.upcall(): {right_render_time:.2f}ms") print(f" 总计: {total_render_time:.2f}ms") # 渲染性能评估 if total_render_time > 16.0: # 超过60FPS时间 print(f" 🔴 渲染时间过长: {total_render_time:.1f}ms (目标<13.9ms@72Hz)") print(f" 建议: 检查RenderPipeline优化是否生效") elif total_render_time > 10.0: print(f" 🟡 渲染时间偏高: {total_render_time:.1f}ms (可接受)") else: print(f" 🟢 渲染性能良好: {total_render_time:.1f}ms") # 🔧 渲染管线优化状态检查 self._check_rendering_optimizations() # OpenGL状态诊断 self._diagnose_opengl_state() except Exception as e: print(f" 渲染回调诊断失败: {e}") def _check_rendering_optimizations(self): """检查渲染优化状态""" try: print(f" 🔧 渲染优化状态:") # 检查RenderPipeline优化 if hasattr(self.vr_manager.world, 'render_pipeline') and self.vr_manager.world.render_pipeline: print(f" RenderPipeline: 已检测并优化") else: print(f" RenderPipeline: 未检测到（使用基础Panda3D）") # 检查GPU同步优化 if hasattr(self.vr_manager, '_smart_sync_logged'): last_sync_frame = getattr(self.vr_manager, '_last_gpu_sync_frame', 0) current_frame = self.frame_count frames_since_sync = current_frame - last_sync_frame print(f" 智能GPU同步: 已启用 (距离上次同步: {frames_since_sync}帧)") else: print(f" 智能GPU同步: 未初始化") # 检查对象池状态 matrix_pool_status = self.vr_manager.get_object_pool_status() print(f" 对象池: Mat4={matrix_pool_status['matrix_pool_size']}/{matrix_pool_status['matrix_pool_capacity']}") # 检查垃圾回收控制 gc_status = self.get_debug_status() if gc_status['gc_disabled']: print(f" GC控制: 已启用手动模式 (间隔:{gc_status['manual_gc_interval']}帧)") else: print(f" GC控制: 自动模式") except Exception as e: print(f" 优化状态检查失败: {e}") def _diagnose_opengl_state(self): """诊断OpenGL渲染状态""" try: # 检查VR缓冲区状态 if hasattr(self.vr_manager, 'vr_left_eye_buffer') and self.vr_manager.vr_left_eye_buffer: left_gsg = self.vr_manager.vr_left_eye_buffer.getGsg() left_valid = self.vr_manager.vr_left_eye_buffer.isValid() print(f" 左眼缓冲区: {'有效' if left_valid else '无效'}") if hasattr(self.vr_manager, 'vr_right_eye_buffer') and self.vr_manager.vr_right_eye_buffer: right_gsg = self.vr_manager.vr_right_eye_buffer.getGsg() right_valid = self.vr_manager.vr_right_eye_buffer.isValid() print(f" 右眼缓冲区: {'有效' if right_valid else '无效'}") # 检查纹理准备状态 if hasattr(self.vr_manager, 'textures_prepared'): print(f" 纹理准备状态: {'已准备' if self.vr_manager.textures_prepared else '未准备'}") # 检查纹理ID缓存 if hasattr(self.vr_manager, 'left_texture_id') and hasattr(self.vr_manager, 'right_texture_id'): left_id = self.vr_manager.left_texture_id or 0 right_id = self.vr_manager.right_texture_id or 0 print(f" 纹理ID缓存: 左眼={left_id}, 右眼={right_id}") if left_id == 0 or right_id == 0: print(f" ⚠️ 检测到无效的纹理ID，这可能导致提交失败") else: print(f" ✓ 纹理ID缓存正常") # 检查场景渲染状态 if hasattr(self.vr_manager.world, 'render') and self.vr_manager.world.render: render_children = len(self.vr_manager.world.render.getChildren()) print(f" 场景节点数: {render_children}") if render_children == 0: print(f" ⚠️ 场景为空，可能导致渲染时间异常短") except Exception as e: print(f" OpenGL状态诊断失败: {e}") # ========== 调试控制方法 ========== def enable_debug_output(self): """启用调试输出""" self.debug_output_enabled = True print("✓ VR调试输出已启用") def disable_debug_output(self): """禁用调试输出""" self.debug_output_enabled = False print("✓ VR调试输出已禁用") def set_debug_mode(self, mode): """设置调试模式 Args: mode: 'brief' 或 'detailed' """ if mode in ['brief', 'detailed']: self.debug_mode = mode print(f"✓ VR调试模式设置为: {mode}") else: print("⚠️ 调试模式只能是 'brief' 或 'detailed'") def toggle_debug_output(self): """切换调试输出状态""" self.debug_output_enabled = not self.debug_output_enabled status = "启用" if self.debug_output_enabled else "禁用" print(f"✓ VR调试输出已{status}") return self.debug_output_enabled def get_debug_status(self): """获取调试状态""" return { 'debug_enabled': self.debug_output_enabled, 'debug_mode': self.debug_mode, 'performance_monitoring': self.performance_monitoring, 'report_interval_frames': self.performance_report_interval, 'report_interval_seconds': self.performance_report_interval / 60, # 假设60fps 'gc_control_enabled': self.vr_manager._gc_control_enabled, 'gc_disabled': self.vr_manager._gc_disabled, 'manual_gc_interval': self.vr_manager._manual_gc_interval, } # ========== 配置方法 ========== def set_performance_check_interval(self, interval): """设置性能检查间隔 Args: interval: 检查间隔（秒），建议0.1-2.0之间 """ if 0.1 <= interval <= 5.0: self.performance_check_interval = interval print(f"✓ 性能监控间隔设置为 {interval:.1f} 秒") else: print("⚠️ 性能监控间隔应在0.1-5.0秒之间") def set_frame_time_history_size(self, size): """设置帧时间历史记录大小 Args: size: 历史记录大小（帧数），建议30-300之间 """ if 10 <= size <= 1000: self.max_frame_time_history = size # 清理超出的历史记录 if len(self.frame_times) > size: self.frame_times = self.frame_times[-size:] print(f"✓ 帧时间历史记录大小设置为 {size} 帧") else: print("⚠️ 帧时间历史记录大小应在10-1000帧之间") def set_performance_report_interval(self, frames): """设置性能报告输出间隔 Args: frames: 帧数间隔，建议300-7200之间（5秒-2分钟@60fps） """ if 300 <= frames <= 7200: # 修改_update_vr中的报告间隔 print(f"✓ 性能报告间隔设置为每 {frames} 帧（约 {frames/60:.1f} 秒@60fps）") # 这里可以添加一个实例变量来控制 self.performance_report_interval = frames else: print("⚠️ 性能报告间隔应在300-7200帧之间") # ========== 查询方法 ========== def get_performance_stats(self): """获取详细的性能统计信息""" stats = { 'vr_fps': self.vr_fps, 'frame_count': self.frame_count, 'submit_failures': self.submit_failures, 'pose_failures': self.pose_failures, 'cpu_usage': self.cpu_usage, 'memory_usage': self.memory_usage, 'gpu_usage': self.gpu_usage, 'gpu_memory_usage': self.gpu_memory_usage, } # 计算帧时间统计 if self.frame_times: stats['frame_time_avg'] = sum(self.frame_times) / len(self.frame_times) stats['frame_time_min'] = min(self.frame_times) stats['frame_time_max'] = max(self.frame_times) stats['frame_time_95th'] = sorted(self.frame_times)[int(len(self.frame_times) * 0.95)] else: stats['frame_time_avg'] = 0 stats['frame_time_min'] = 0 stats['frame_time_max'] = 0 stats['frame_time_95th'] = 0 return stats def get_current_performance_summary(self): """获取当前性能摘要（简短版本）""" stats = self.get_performance_stats() summary = f"VR性能: {stats['vr_fps']:.1f}fps" if stats['frame_time_avg'] > 0: summary += f" | 帧时间: {stats['frame_time_avg']:.1f}ms" if self.psutil_available: summary += f" | CPU: {stats['cpu_usage']:.0f}%" summary += f" | 内存: {stats['memory_usage']:.0f}%" # 显示GPU信息，如果库不可用则显示提示 if self.gputil_available or self.nvidia_ml_available: summary += f" | GPU: {stats['gpu_usage']:.0f}%" else: summary += " | GPU: N/A" return summary def get_performance_monitoring_config(self): """获取当前性能监控配置""" return { 'enabled': self.performance_monitoring, 'check_interval': self.performance_check_interval, 'frame_history_size': self.max_frame_time_history, 'report_interval': self.performance_report_interval, 'psutil_available': self.psutil_available, 'gputil_available': self.gputil_available, 'nvidia_ml_available': self.nvidia_ml_available } def print_performance_monitoring_status(self): """输出性能监控状态""" config = self.get_performance_monitoring_config() print("🔧 ===== VR性能监控配置 =====") print(f" 监控状态: {'✅ 启用' if config['enabled'] else '❌ 禁用'}") print(f" 检查间隔: {config['check_interval']:.1f} 秒") print(f" 帧时间历史: {config['frame_history_size']} 帧") print(f" 报告间隔: {config['report_interval']} 帧") print(f" 可用库:") print(f" psutil (CPU/内存): {'✅' if config['psutil_available'] else '❌'}") print(f" GPUtil (GPU): {'✅' if config['gputil_available'] else '❌'}") print(f" NVIDIA-ML (GPU): {'✅' if config['nvidia_ml_available'] else '❌'}") print("=============================") # ========== 控制方法 ========== def enable_performance_monitoring(self): """启用性能监控""" self.performance_monitoring = True print("✓ VR性能监控已启用") def disable_performance_monitoring(self): """禁用性能监控""" self.performance_monitoring = False print("✓ VR性能监控已禁用") def force_performance_report(self): """强制输出一次性能报告""" print("🔄 手动触发性能报告...") self._print_performance_report() def reset_performance_counters(self): """重置性能计数器""" self.frame_count = 0 self.last_fps_check = 0 self.last_fps_time = 0 self.vr_fps = 0 self.submit_failures = 0 self.pose_failures = 0 self.frame_times.clear() print("✅ 性能计数器已重置")