#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ SUW Core - Memory Manager Module 拆分自: suw_impl.py (Line 82-605) 用途: Blender内存管理、依赖图管理、主线程处理 版本: 1.0.0 作者: SUWood Team """ import time import logging import threading import queue from typing import Dict, Callable from contextlib import contextmanager # 设置日志 logger = logging.getLogger(__name__) # 检查Blender可用性 try: import bpy BLENDER_AVAILABLE = True except ImportError: BLENDER_AVAILABLE = False # 全局主线程任务队列 _main_thread_queue = queue.Queue() _main_thread_id = None # ==================== 内存管理核心类 ==================== class BlenderMemoryManager: """Blender内存管理器 - 修复弱引用问题""" def __init__(self): # 改用普通集合和字典来跟踪对象，而不是弱引用 self.tracked_objects = set() # 存储对象名称而不是对象本身 self.tracked_meshes = set() # 存储网格名称 self.tracked_images = set() # 存储图像名称 self.tracked_materials = set() # 存储材质名称 self.tracked_collections = set() # 存储集合名称 self.cleanup_interval = 100 self.operation_count = 0 self.last_cleanup = time.time() self.max_memory_mb = 2048 self._cleanup_lock = threading.Lock() self.creation_stats = { "objects_created": 0, "objects_cleaned": 0 } def register_object(self, obj): """注册对象到内存管理器 - 修复版本""" if obj is None or not BLENDER_AVAILABLE: return try: with self._cleanup_lock: # 根据对象类型分别处理 if hasattr(obj, 'name'): obj_name = obj.name # 根据对象类型存储到不同的集合 if hasattr(obj, 'type'): # Blender Object self.tracked_objects.add(obj_name) elif str(type(obj)).find('Material') != -1: # Material self.tracked_materials.add(obj_name) elif str(type(obj)).find('Mesh') != -1: # Mesh self.tracked_meshes.add(obj_name) elif str(type(obj)).find('Image') != -1: # Image self.tracked_images.add(obj_name) elif str(type(obj)).find('Collection') != -1: # Collection self.tracked_collections.add(obj_name) else: self.tracked_objects.add(obj_name) self.operation_count += 1 # 定期清理 if self.should_cleanup(): self.cleanup_orphaned_data() except Exception as e: # 静默处理，不输出错误日志 pass def register_mesh(self, mesh): """注册网格到内存管理器 - 修复版本""" if mesh is None or not BLENDER_AVAILABLE: return try: with self._cleanup_lock: if hasattr(mesh, 'name'): self.tracked_meshes.add(mesh.name) self.operation_count += 1 except Exception as e: # 静默处理 pass def register_image(self, image): """注册图像到内存管理器 - 修复版本""" if image is None or not BLENDER_AVAILABLE: return try: with self._cleanup_lock: if hasattr(image, 'name'): self.tracked_images.add(image.name) self.operation_count += 1 except Exception as e: # 静默处理 pass def should_cleanup(self): """检查是否需要清理""" return (self.operation_count >= self.cleanup_interval or time.time() - self.last_cleanup > 300) # 5分钟强制清理 def cleanup_orphaned_data(self): """【暂时禁用】清理孤立的数据块 - 让Blender自动处理以避免冲突""" if not BLENDER_AVAILABLE: return # 【临时策略】完全禁用自动清理，只更新跟踪状态 logger.debug("🚫 自动清理已禁用，让Blender自动处理孤立数据") cleanup_count = 0 try: with self._cleanup_lock: # 只清理跟踪列表，不实际删除任何数据 invalid_objects = [] invalid_meshes = [] invalid_materials = [] invalid_images = [] # 清理无效的对象引用（不删除实际对象） for obj_name in list(self.tracked_objects): try: if obj_name not in bpy.data.objects: invalid_objects.append(obj_name) except: invalid_objects.append(obj_name) # 清理无效的网格引用（不删除实际网格） for mesh_name in list(self.tracked_meshes): try: if mesh_name not in bpy.data.meshes: invalid_meshes.append(mesh_name) except: invalid_meshes.append(mesh_name) # 清理无效的材质引用（不删除实际材质） for mat_name in list(self.tracked_materials): try: if mat_name not in bpy.data.materials: invalid_materials.append(mat_name) except: invalid_materials.append(mat_name) # 清理无效的图像引用（不删除实际图像） for img_name in list(self.tracked_images): try: if img_name not in bpy.data.images: invalid_images.append(img_name) except: invalid_images.append(img_name) # 只更新跟踪列表，不删除实际数据 for obj_name in invalid_objects: self.tracked_objects.discard(obj_name) for mesh_name in invalid_meshes: self.tracked_meshes.discard(mesh_name) for mat_name in invalid_materials: self.tracked_materials.discard(mat_name) for img_name in invalid_images: self.tracked_images.discard(img_name) total_cleaned = len(invalid_objects) + len(invalid_meshes) + \ len(invalid_materials) + len(invalid_images) if total_cleaned > 0: logger.debug(f"🧹 清理了 {total_cleaned} 个无效引用（不删除实际数据）") # 【修复】安全清理材质数据 materials_to_remove = [] for material_name in list(self.tracked_materials): try: if material_name in bpy.data.materials: material = bpy.data.materials[material_name] if material.users == 0: materials_to_remove.append(material_name) else: self.tracked_materials.discard(material_name) except Exception as e: logger.warning(f"检查材质 {material_name} 时出错: {e}") self.tracked_materials.discard(material_name) # 批量删除无用的材质 for material_name in materials_to_remove: try: if material_name in bpy.data.materials: material = bpy.data.materials[material_name] bpy.data.materials.remove(material, do_unlink=True) cleanup_count += 1 self.tracked_materials.discard(material_name) except Exception as e: logger.warning(f"删除材质数据失败: {e}") self.tracked_materials.discard(material_name) # 【修复】安全清理图像数据 images_to_remove = [] for image_name in list(self.tracked_images): try: if image_name in bpy.data.images: image = bpy.data.images[image_name] if image.users == 0: images_to_remove.append(image_name) else: self.tracked_images.discard(image_name) except Exception as e: logger.warning(f"检查图像 {image_name} 时出错: {e}") self.tracked_images.discard(image_name) # 批量删除无用的图像 for image_name in images_to_remove: try: if image_name in bpy.data.images: image = bpy.data.images[image_name] bpy.data.images.remove(image, do_unlink=True) cleanup_count += 1 self.tracked_images.discard(image_name) except Exception as e: logger.warning(f"删除图像数据失败: {e}") self.tracked_images.discard(image_name) # 【修复】清理无效的对象引用 invalid_objects = [] for obj_name in list(self.tracked_objects): try: if obj_name not in bpy.data.objects: invalid_objects.append(obj_name) except Exception as e: logger.warning(f"检查对象 {obj_name} 时出错: {e}") invalid_objects.append(obj_name) for obj_name in invalid_objects: self.tracked_objects.discard(obj_name) if cleanup_count > 0: logger.info(f"🧹 清理了 {cleanup_count} 个孤立数据块") except Exception as e: logger.error(f"内存清理过程中发生错误: {e}") import traceback traceback.print_exc() def _cleanup_tracked_references(self): """清理跟踪集合中的无效引用""" try: # 清理无效的对象引用 valid_objects = set() for obj_name in self.tracked_objects: if obj_name in bpy.data.objects: valid_objects.add(obj_name) self.tracked_objects = valid_objects # 清理无效的网格引用 valid_meshes = set() for mesh_name in self.tracked_meshes: if mesh_name in bpy.data.meshes: valid_meshes.add(mesh_name) self.tracked_meshes = valid_meshes # 清理无效的材质引用 valid_materials = set() for mat_name in self.tracked_materials: if mat_name in bpy.data.materials: valid_materials.add(mat_name) self.tracked_materials = valid_materials # 清理无效的图像引用 valid_images = set() for img_name in self.tracked_images: if img_name in bpy.data.images: valid_images.add(img_name) self.tracked_images = valid_images # 清理无效的集合引用 valid_collections = set() if hasattr(bpy.data, 'collections'): for col_name in self.tracked_collections: if col_name in bpy.data.collections: valid_collections.add(col_name) self.tracked_collections = valid_collections except Exception as e: logger.warning(f"清理跟踪引用失败: {e}") def get_memory_stats(self) -> Dict[str, int]: """获取内存使用统计""" try: stats = { "manager_type": "BlenderMemoryManager", # 添加这个字段 "tracked_objects": len(self.tracked_objects), "tracked_meshes": len(self.tracked_meshes), "tracked_images": len(self.tracked_images), "creation_count": self.creation_stats.get("objects_created", 0), "cleanup_count": self.creation_stats.get("objects_cleaned", 0), "blender_available": BLENDER_AVAILABLE } return stats except Exception as e: return {"manager_type": "BlenderMemoryManager", "error": str(e)} def force_cleanup(self): """强制清理""" try: with self._cleanup_lock: self.last_cleanup = 0 # 重置时间以强制清理 self.cleanup_orphaned_data() except Exception as e: logger.error(f"强制清理失败: {e}") # ==================== 依赖图管理器 ==================== class DependencyGraphManager: """依赖图管理器 - 控制更新频率，避免过度更新导致的冲突""" def __init__(self): self.update_interval = 0.1 # 100毫秒最小更新间隔 self.last_update_time = 0 self.pending_updates = False self._update_lock = threading.Lock() self._updating = False # 【新增】防止递归更新的标志 def request_update(self, force=False): """请求依赖图更新 - 线程安全版本""" if not BLENDER_AVAILABLE: return # 【新增】线程安全检查 - 只在主线程中执行更新 if threading.current_thread().ident != _main_thread_id: logger.debug("跳过非主线程的依赖图更新") self.pending_updates = True return with self._update_lock: current_time = time.time() if force or (current_time - self.last_update_time) >= self.update_interval: try: # 【修复依赖图冲突】添加求值状态检查 if hasattr(bpy.context, 'evaluated_depsgraph_get'): # 检查是否在依赖图求值过程中 try: depsgraph = bpy.context.evaluated_depsgraph_get() if depsgraph.is_evaluating: logger.debug("⚠️ 依赖图正在求值中，跳过更新") return except: pass # 【修复】使用延迟更新机制，避免递归调用 if not getattr(self, '_updating', False): self._updating = True try: bpy.context.view_layer.update() self.last_update_time = current_time self.pending_updates = False logger.debug("✅ 依赖图更新完成") finally: self._updating = False else: logger.debug("⚠️ 依赖图更新正在进行中，跳过") except (AttributeError, ReferenceError, RuntimeError) as e: # 这些错误在对象删除过程中是预期的 logger.debug(f"依赖图更新时的预期错误: {e}") except Exception as e: logger.warning(f"依赖图更新失败: {e}") # 【新增】记录失败但不抛出异常 if hasattr(self, '_updating'): self._updating = False def flush_pending_updates(self): """强制执行所有挂起的更新""" if self.pending_updates: self.request_update(force=True) # ==================== 主线程处理 ==================== def init_main_thread(): """初始化主线程ID""" global _main_thread_id _main_thread_id = threading.current_thread().ident def execute_in_main_thread_async(func: Callable, *args, **kwargs): """ 【真正的异步版】在主线程中安全地调度函数 - 真正的"即发即忘"，不等待结果。 """ global _main_thread_queue, _main_thread_id # 如果已经在主线程中，直接执行 if threading.current_thread().ident == _main_thread_id: try: func(*args, **kwargs) return True except Exception as e: logger.error(f"在主线程直接执行函数时出错: {e}") import traceback traceback.print_exc() return False # 在Blender中，使用应用程序定时器 - 即发即忘模式 try: import bpy def timer_task(): try: func(*args, **kwargs) except Exception as e: logger.error(f"主线程任务执行失败: {e}") import traceback traceback.print_exc() return None # 只执行一次 # 注册定时器任务就立即返回，不等待结果 bpy.app.timers.register(timer_task, first_interval=0.001) # ！！！关键：立即返回调度成功，不等待执行结果！！！ return True except ImportError: # 不在Blender环境中，使用原有的队列机制 - 也改为即发即忘 def wrapper(): try: func(*args, **kwargs) except Exception as e: logger.error(f"队列任务执行失败: {e}") import traceback traceback.print_exc() _main_thread_queue.put(wrapper) # 立即返回调度成功，不等待执行结果 return True # 【保持向后兼容】旧函数名的别名 execute_in_main_thread = execute_in_main_thread_async def process_main_thread_tasks(): """ 【修复版】处理主线程任务队列 - 一次只处理一个任务！ 这个函数需要被Blender的定时器定期调用。 """ global _main_thread_queue try: # ！！！关键修改：从 while 改为 if ！！！ # 一次定时器触发，只处理队列中的一个任务，然后就把控制权还给Blender。 if not _main_thread_queue.empty(): task = _main_thread_queue.get_nowait() try: task() except Exception as e: logger.error(f"执行主线程任务时出错: {e}") import traceback traceback.print_exc() except queue.Empty: pass # 队列是空的，什么也不做 @contextmanager def safe_blender_operation(operation_name: str): """线程安全的Blender操作上下文管理器 - 修复版本""" if not BLENDER_AVAILABLE: logger.warning(f"Blender不可用，跳过操作: {operation_name}") yield return start_time = time.time() logger.debug(f"🔄 开始操作: {operation_name}") # 保存当前状态 original_mode = None original_selection = [] original_active = None def _execute_operation(): nonlocal original_mode, original_selection, original_active try: # 确保在对象模式下 if hasattr(bpy.context, 'mode') and bpy.context.mode != 'OBJECT': original_mode = bpy.context.mode bpy.ops.object.mode_set(mode='OBJECT') # 保存当前选择和活动对象 if hasattr(bpy.context, 'selected_objects'): original_selection = list(bpy.context.selected_objects) if hasattr(bpy.context, 'active_object'): original_active = bpy.context.active_object # 清除选择以避免冲突 bpy.ops.object.select_all(action='DESELECT') return True except Exception as e: logger.error(f"准备操作失败: {e}") return False def _cleanup_operation(): try: # 尝试恢复原始状态 bpy.ops.object.select_all(action='DESELECT') for obj in original_selection: if obj and obj.name in bpy.data.objects: obj.select_set(True) # 恢复活动对象 if original_active and original_active.name in bpy.data.objects: bpy.context.view_layer.objects.active = original_active # 恢复模式 if original_mode and original_mode != 'OBJECT': bpy.ops.object.mode_set(mode=original_mode) except Exception as restore_error: logger.warning(f"恢复状态失败: {restore_error}") try: # 如果不在主线程，使用主线程执行准备操作 if threading.current_thread().ident != _main_thread_id: success = execute_in_main_thread(_execute_operation) if not success: raise RuntimeError("准备操作失败") else: success = _execute_operation() if not success: raise RuntimeError("准备操作失败") # 执行用户操作 yield elapsed_time = time.time() - start_time if elapsed_time > 5.0: logger.warning(f"操作耗时过长: {operation_name} ({elapsed_time:.2f}s)") else: logger.debug(f"✅ 操作完成: {operation_name} ({elapsed_time:.2f}s)") except Exception as e: logger.error(f"❌ 操作失败: {operation_name} - {e}") raise finally: # 清理操作也需要在主线程中执行 if threading.current_thread().ident != _main_thread_id: try: execute_in_main_thread(_cleanup_operation) except: pass else: _cleanup_operation() # ==================== 全局实例 ==================== # 全局内存管理器实例 memory_manager = BlenderMemoryManager() # 全局依赖图管理器 dependency_manager = DependencyGraphManager()