From 7af256ab6ea86b105777631fce116c4174547362 Mon Sep 17 00:00:00 2001 From: Your Name Date: Fri, 6 Mar 2026 01:35:50 +0000 Subject: [PATCH 1/6] fix: harden startup compat and restore low-risk MultiGPU helpers --- __init__.py | 179 +++++++++++++++++++++++++++++++++--------------- device_utils.py | 1 + nodes.py | 16 +++++ wanvideo.py | 9 ++- 4 files changed, 148 insertions(+), 57 deletions(-) diff --git a/__init__.py b/__init__.py index 2f5efd4..b2c4148 100644 --- a/__init__.py +++ b/__init__.py @@ -4,6 +4,7 @@ import os import copy import json +import importlib from datetime import datetime from pathlib import Path import folder_paths @@ -136,15 +137,36 @@ def mgpu_mm_log_method(self, msg): ) logger.mgpu_mm_log = mgpu_mm_log_method.__get__(logger, type(logger)) +def _normalize_module_name(module_name): + """Normalize a custom node directory name for tolerant matching.""" + return "".join(char for char in os.path.basename(module_name).lower() if char.isalnum()) + def check_module_exists(module_path): """Check if a custom node module exists in ComfyUI custom_nodes directory.""" - full_path = os.path.join(folder_paths.get_folder_paths("custom_nodes")[0], module_path) - logger.debug(f"[MultiGPU] Checking for module at {full_path}") - if not os.path.exists(full_path): - logger.debug(f"[MultiGPU] Module {module_path} not found - skipping") - return False - logger.debug(f"[MultiGPU] Found {module_path}, creating compatible MultiGPU nodes") - return True + custom_nodes_paths = folder_paths.get_folder_paths("custom_nodes") + normalized_module_path = _normalize_module_name(module_path) + + for custom_nodes_path in custom_nodes_paths: + full_path = os.path.join(custom_nodes_path, module_path) + logger.debug(f"[MultiGPU] Checking for module at {full_path}") + if os.path.isdir(full_path): + logger.debug(f"[MultiGPU] Found exact module match for {module_path} at {full_path}") + return True + + for custom_nodes_path in custom_nodes_paths: + try: + with os.scandir(custom_nodes_path) as entries: + for entry in entries: + if not entry.is_dir(): + continue + if _normalize_module_name(entry.name) == normalized_module_path: + logger.debug(f"[MultiGPU] Found normalized module match for {module_path} at {entry.path}") + return True + except OSError: + continue + + logger.debug(f"[MultiGPU] Module {module_path} not found - skipping") + return False current_device = mm.get_torch_device() current_text_encoder_device = mm.text_encoder_device() @@ -216,6 +238,44 @@ def unet_offload_device_patched(): logger.debug(f"[MultiGPU Core Patching] unet_offload_device_patched returning device: {device} (current_unet_offload_device={current_unet_offload_device})") return device +def _patch_comfy_kitchen_dlpack_device_guard(): + """Guard comfy_kitchen DLPack export by switching to the tensor's CUDA device.""" + try: + comfy_kitchen_cuda = importlib.import_module("comfy_kitchen.backends.cuda") + except ImportError: + logger.debug("[MultiGPU] comfy_kitchen not found - skipping CUDA DLPack compat patch") + return False + + wrap_for_dlpack = getattr(comfy_kitchen_cuda, "_wrap_for_dlpack", None) + if wrap_for_dlpack is None: + logger.debug("[MultiGPU] comfy_kitchen.backends.cuda._wrap_for_dlpack not found - skipping compat patch") + return False + + if getattr(wrap_for_dlpack, "_multigpu_cuda_device_guard", False): + return True + + def wrap_for_dlpack_with_device_guard(*args, **kwargs): + tensor = args[0] if args else kwargs.get("tensor") + previous_device_index = None + switched_device = False + + if isinstance(tensor, torch.Tensor) and tensor.is_cuda and tensor.device.index is not None: + previous_device_index = torch.cuda.current_device() + if previous_device_index != tensor.device.index: + torch.cuda.set_device(tensor.device.index) + switched_device = True + + try: + return wrap_for_dlpack(*args, **kwargs) + finally: + if switched_device and previous_device_index is not None: + torch.cuda.set_device(previous_device_index) + + wrap_for_dlpack_with_device_guard._multigpu_cuda_device_guard = True + comfy_kitchen_cuda._wrap_for_dlpack = wrap_for_dlpack_with_device_guard + logger.info("[MultiGPU] Applied comfy_kitchen CUDA DLPack device guard patch") + return True + logger.info(f"[MultiGPU Core Patching] Patching mm.get_torch_device, mm.text_encoder_device, mm.unet_offload_device") logger.info(f"[MultiGPU DEBUG] Initial current_device: {current_device}") logger.info(f"[MultiGPU DEBUG] Initial current_text_encoder_device: {current_text_encoder_device}") @@ -224,8 +284,10 @@ def unet_offload_device_patched(): mm.get_torch_device = get_torch_device_patched mm.text_encoder_device = text_encoder_device_patched mm.unet_offload_device = unet_offload_device_patched +_patch_comfy_kitchen_dlpack_device_guard() from .nodes import ( + DeviceSelectorMultiGPU, UnetLoaderGGUF, UnetLoaderGGUFAdvanced, CLIPLoaderGGUF, @@ -246,29 +308,6 @@ def unet_offload_device_patched(): UNetLoaderLP, ) -from .wanvideo import ( - LoadWanVideoT5TextEncoder, - WanVideoTextEncode, - WanVideoTextEncodeCached, - WanVideoTextEncodeSingle, - WanVideoVAELoader, - WanVideoTinyVAELoader, - WanVideoBlockSwap, - WanVideoImageToVideoEncode, - WanVideoDecode, - WanVideoModelLoader, - WanVideoSampler, - WanVideoVACEEncode, - WanVideoEncode, - LoadWanVideoClipTextEncoder, - WanVideoClipVisionEncode, - WanVideoControlnetLoader, - FantasyTalkingModelLoader, - Wav2VecModelLoader, - WanVideoUni3C_ControlnetLoader, - DownloadAndLoadWav2VecModel, -) - from .wrappers import ( override_class, override_class_offload, @@ -294,9 +333,57 @@ def unet_offload_device_patched(): CheckpointLoaderAdvancedDisTorch2MultiGPU ) +def _load_wanvideo_nodes(): + from .wanvideo import ( + LoadWanVideoT5TextEncoder, + WanVideoTextEncode, + WanVideoTextEncodeCached, + WanVideoTextEncodeSingle, + WanVideoVAELoader, + WanVideoTinyVAELoader, + WanVideoBlockSwap, + WanVideoImageToVideoEncode, + WanVideoDecode, + WanVideoModelLoader, + WanVideoSampler, + WanVideoVACEEncode, + WanVideoEncode, + LoadWanVideoClipTextEncoder, + WanVideoClipVisionEncode, + WanVideoControlnetLoader, + FantasyTalkingModelLoader, + Wav2VecModelLoader, + WanVideoUni3C_ControlnetLoader, + DownloadAndLoadWav2VecModel, + ) + + return { + "LoadWanVideoT5TextEncoderMultiGPU": LoadWanVideoT5TextEncoder, + "WanVideoTextEncodeMultiGPU": WanVideoTextEncode, + "WanVideoTextEncodeCachedMultiGPU": WanVideoTextEncodeCached, + "WanVideoTextEncodeSingleMultiGPU": WanVideoTextEncodeSingle, + "WanVideoVAELoaderMultiGPU": WanVideoVAELoader, + "WanVideoTinyVAELoaderMultiGPU": WanVideoTinyVAELoader, + "WanVideoBlockSwapMultiGPU": WanVideoBlockSwap, + "WanVideoImageToVideoEncodeMultiGPU": WanVideoImageToVideoEncode, + "WanVideoDecodeMultiGPU": WanVideoDecode, + "WanVideoModelLoaderMultiGPU": WanVideoModelLoader, + "WanVideoSamplerMultiGPU": WanVideoSampler, + "WanVideoVACEEncodeMultiGPU": WanVideoVACEEncode, + "WanVideoEncodeMultiGPU": WanVideoEncode, + "LoadWanVideoClipTextEncoderMultiGPU": LoadWanVideoClipTextEncoder, + "WanVideoClipVisionEncodeMultiGPU": WanVideoClipVisionEncode, + "WanVideoControlnetLoaderMultiGPU": WanVideoControlnetLoader, + "FantasyTalkingModelLoaderMultiGPU": FantasyTalkingModelLoader, + "Wav2VecModelLoaderMultiGPU": Wav2VecModelLoader, + "WanVideoUni3C_ControlnetLoaderMultiGPU": WanVideoUni3C_ControlnetLoader, + "DownloadAndLoadWav2VecModelMultiGPU": DownloadAndLoadWav2VecModel, + } + NODE_CLASS_MAPPINGS = { "CheckpointLoaderAdvancedMultiGPU": CheckpointLoaderAdvancedMultiGPU, "CheckpointLoaderAdvancedDisTorch2MultiGPU": CheckpointLoaderAdvancedDisTorch2MultiGPU, + "DeviceSelectorMultiGPU": DeviceSelectorMultiGPU, "UNetLoaderLP": UNetLoaderLP, } @@ -342,8 +429,14 @@ def register_and_count(module_names, node_map): count = 0 if found: + try: + resolved_node_map = node_map() if callable(node_map) else node_map + except Exception as exc: + logger.warning(f"[MultiGPU] Failed to register nodes for {module_names[0]}: {exc}") + resolved_node_map = {} + initial_len = len(NODE_CLASS_MAPPINGS) - for key, value in node_map.items(): + for key, value in resolved_node_map.items(): NODE_CLASS_MAPPINGS[key] = value count = len(NODE_CLASS_MAPPINGS) - initial_len @@ -401,29 +494,7 @@ def register_and_count(module_names, node_map): } register_and_count(["PuLID_ComfyUI", "pulid_comfyui"], pulid_nodes) -wanvideo_nodes = { - "LoadWanVideoT5TextEncoderMultiGPU": LoadWanVideoT5TextEncoder, - "WanVideoTextEncodeMultiGPU": WanVideoTextEncode, - "WanVideoTextEncodeCachedMultiGPU": WanVideoTextEncodeCached, - "WanVideoTextEncodeSingleMultiGPU": WanVideoTextEncodeSingle, - "WanVideoVAELoaderMultiGPU": WanVideoVAELoader, - "WanVideoTinyVAELoaderMultiGPU": WanVideoTinyVAELoader, - "WanVideoBlockSwapMultiGPU": WanVideoBlockSwap, - "WanVideoImageToVideoEncodeMultiGPU": WanVideoImageToVideoEncode, - "WanVideoDecodeMultiGPU": WanVideoDecode, - "WanVideoModelLoaderMultiGPU": WanVideoModelLoader, - "WanVideoSamplerMultiGPU": WanVideoSampler, - "WanVideoVACEEncodeMultiGPU": WanVideoVACEEncode, - "WanVideoEncodeMultiGPU": WanVideoEncode, - "LoadWanVideoClipTextEncoderMultiGPU": LoadWanVideoClipTextEncoder, - "WanVideoClipVisionEncodeMultiGPU": WanVideoClipVisionEncode, - "WanVideoControlnetLoaderMultiGPU": WanVideoControlnetLoader, - "FantasyTalkingModelLoaderMultiGPU": FantasyTalkingModelLoader, - "Wav2VecModelLoaderMultiGPU": Wav2VecModelLoader, - "WanVideoUni3C_ControlnetLoaderMultiGPU": WanVideoUni3C_ControlnetLoader, - "DownloadAndLoadWav2VecModelMultiGPU": DownloadAndLoadWav2VecModel, -} -register_and_count(["ComfyUI-WanVideoWrapper", "comfyui-wanvideowrapper"], wanvideo_nodes) +register_and_count(["ComfyUI-WanVideoWrapper", "comfyui-wanvideowrapper"], _load_wanvideo_nodes) for item in registration_data: logger.info(fmt_reg.format(item['name'], item['found'], str(item['count']))) diff --git a/device_utils.py b/device_utils.py index 6647572..6b7b7ae 100644 --- a/device_utils.py +++ b/device_utils.py @@ -175,6 +175,7 @@ def soft_empty_cache_multigpu(): logger.mgpu_mm_log(f"Clearing CUDA cache on {device_str} (idx={device_idx})") multigpu_memory_log("general", f"pre-empty:{device_str}") with torch.cuda.device(device_idx): + torch.cuda.synchronize() torch.cuda.empty_cache() if hasattr(torch.cuda, "ipc_collect"): torch.cuda.ipc_collect() diff --git a/nodes.py b/nodes.py index 4a75b78..c2d3787 100644 --- a/nodes.py +++ b/nodes.py @@ -5,6 +5,22 @@ from .device_utils import get_device_list from .model_management_mgpu import force_full_system_cleanup +class DeviceSelectorMultiGPU: + @classmethod + def INPUT_TYPES(s): + devices = get_device_list() + return {"required": {"device": (devices,)}} + + RETURN_TYPES = ("MULTIGPUDEVICE",) + RETURN_NAMES = ("device",) + FUNCTION = "select_device" + CATEGORY = "multigpu" + TITLE = "Device Selector (MultiGPU)" + + def select_device(self, device): + """Return the selected device label without side effects.""" + return (device,) + class UnetLoaderGGUF: @classmethod def INPUT_TYPES(s): diff --git a/wanvideo.py b/wanvideo.py index 4ebecf9..1628e26 100644 --- a/wanvideo.py +++ b/wanvideo.py @@ -11,9 +11,7 @@ from comfy.utils import load_torch_file, ProgressBar import gc import numpy as np -from accelerate import init_empty_weights import os -import importlib.util logger = logging.getLogger("MultiGPU") @@ -64,6 +62,7 @@ def INPUT_TYPES(s): "lora": ("WANVIDLORA", {"default": None}), "vram_management_args": ("VRAM_MANAGEMENTARGS", {"default": None, "tooltip": "Alternative offloading method from DiffSynth-Studio, more aggressive in reducing memory use than block swapping, but can be slower"}), "extra_model": ("VACEPATH", {"default": None, "tooltip": "Extra model to add to the main model, ie. VACE or MTV Crafter"}), + "vace_model": ("VACEPATH", {"default": None, "tooltip": "Backward-compatible alias for extra_model"}), "fantasytalking_model": ("FANTASYTALKINGMODEL", {"default": None, "tooltip": "FantasyTalking model https://github.com/Fantasy-AMAP"}), "multitalk_model": ("MULTITALKMODEL", {"default": None, "tooltip": "Multitalk model"}), "fantasyportrait_model": ("FANTASYPORTRAITMODEL", {"default": None, "tooltip": "FantasyPortrait model"}), @@ -83,6 +82,10 @@ def loadmodel(self, model, base_precision, compute_device, quantization, load_de loader_module = inspect.getmodule(original_loader) original_module_device = loader_module.device + vace_model = kwargs.pop("vace_model", None) + if kwargs.get("extra_model") is None and vace_model is not None: + kwargs["extra_model"] = vace_model + set_current_device(compute_device) compute_device_to_be_patched = mm.get_torch_device() @@ -863,4 +866,4 @@ def loadmodel(self, model, base_precision, load_device, device, quantization, at set_current_device(device) original_loader = NODE_CLASS_MAPPINGS["WanVideoUni3C_ControlnetLoader"]() - return original_loader.loadmodel(model, base_precision, load_device, quantization, attention_mode, compile_args) \ No newline at end of file + return original_loader.loadmodel(model, base_precision, load_device, quantization, attention_mode, compile_args) From 24e4e17a97ca1992c4bcf21955ed353cef13c65c Mon Sep 17 00:00:00 2001 From: John Pollock Date: Fri, 6 Mar 2026 05:19:03 -0600 Subject: [PATCH 2/6] feat: enhance MultiGPU support with device guards and runtime management --- __init__.py | 169 ++++++++++++++++++++++++++++++++++++++++++++++++---- wrappers.py | 20 +++++-- 2 files changed, 170 insertions(+), 19 deletions(-) diff --git a/__init__.py b/__init__.py index b2c4148..14abdbd 100644 --- a/__init__.py +++ b/__init__.py @@ -5,11 +5,14 @@ import copy import json import importlib +from contextlib import contextmanager from datetime import datetime from pathlib import Path import folder_paths import comfy.model_management as mm +import comfy.memory_management import comfy.model_patcher +import comfy.sample as comfy_sample from nodes import NODE_CLASS_MAPPINGS as GLOBAL_NODE_CLASS_MAPPINGS from .device_utils import ( get_device_list, @@ -171,6 +174,9 @@ def check_module_exists(module_path): current_device = mm.get_torch_device() current_text_encoder_device = mm.text_encoder_device() current_unet_offload_device = mm.unet_offload_device() +_aimdo_initialized_devices = set() +if isinstance(current_device, torch.device) and current_device.type == "cuda" and current_device.index is not None: + _aimdo_initialized_devices.add(current_device.index) def set_current_device(device): """Set the current device context for MultiGPU operations.""" @@ -205,6 +211,73 @@ def get_current_unet_offload_device(): """Get the current UNet offload device context at runtime.""" return current_unet_offload_device +def _coerce_torch_device(device): + """Best-effort conversion to torch.device for guard and patch helpers.""" + if device is None: + return None + if isinstance(device, torch.device): + return device + try: + return torch.device(device) + except (TypeError, RuntimeError, ValueError): + return None + +@contextmanager +def cuda_device_guard(device, reason="runtime"): + """Temporarily switch the real CUDA current device for non-primary execution paths.""" + target_device = _coerce_torch_device(device) + previous_device_index = None + switched_device = False + + if ( + target_device is not None + and target_device.type == "cuda" + and target_device.index is not None + and torch.cuda.is_available() + ): + previous_device_index = torch.cuda.current_device() + if previous_device_index != target_device.index: + logger.info( + f"[MultiGPU CUDA Guard] Switching CUDA current device {previous_device_index} -> {target_device.index} ({reason})" + ) + torch.cuda.set_device(target_device.index) + switched_device = True + + try: + yield target_device + finally: + if switched_device and previous_device_index is not None: + torch.cuda.set_device(previous_device_index) + logger.info( + f"[MultiGPU CUDA Guard] Restored CUDA current device {target_device.index} -> {previous_device_index} ({reason})" + ) + +def _get_runtime_device_from_model(model): + """Resolve the actual execution device from a model or patcher wrapper.""" + if hasattr(model, "load_device"): + return getattr(model, "load_device") + patcher = getattr(model, "patcher", None) + if patcher is not None and hasattr(patcher, "load_device"): + return patcher.load_device + inner_model = getattr(model, "model", None) + if inner_model is not None and hasattr(inner_model, "load_device"): + return inner_model.load_device + return None + +@contextmanager +def multigpu_runtime_device_guard(device, reason="runtime"): + """Align MultiGPU logical device state with the real runtime device for inference.""" + original_device = get_current_device() + target_device = _coerce_torch_device(device) or device + if target_device is not None: + set_current_device(target_device) + logger.info(f"[MultiGPU Runtime] Using runtime device {target_device} ({reason})") + try: + with cuda_device_guard(target_device, reason=reason): + yield _coerce_torch_device(target_device) + finally: + set_current_device(original_device) + def get_torch_device_patched(): """Return MultiGPU-aware device selection for patched mm.get_torch_device.""" device = None @@ -238,6 +311,85 @@ def unet_offload_device_patched(): logger.debug(f"[MultiGPU Core Patching] unet_offload_device_patched returning device: {device} (current_unet_offload_device={current_unet_offload_device})") return device +def _patch_model_management_current_stream(): + """Make ComfyUI stream lookup honor the requested CUDA device.""" + current_stream = getattr(mm, "current_stream", None) + if current_stream is None: + return False + if getattr(current_stream, "_multigpu_cuda_device_aware", False): + return True + + def current_stream_device_aware(device): + target_device = _coerce_torch_device(device) + if target_device is not None and target_device.type == "cuda": + return torch.cuda.current_stream(device=target_device) + return current_stream(device) + + current_stream_device_aware._multigpu_cuda_device_aware = True + current_stream_device_aware._multigpu_original = current_stream + mm.current_stream = current_stream_device_aware + logger.info("[MultiGPU] Patched comfy.model_management.current_stream to honor CUDA device arguments") + return True + +def _initialize_aimdo_visible_cuda_devices(): + """Ensure DynamicVRAM initializes every visible CUDA device once when enabled.""" + if not getattr(comfy.memory_management, "aimdo_enabled", False): + logger.info("[MultiGPU] DynamicVRAM not enabled; skipping multi-device aimdo initialization") + return False + if not torch.cuda.is_available(): + logger.info("[MultiGPU] CUDA unavailable; skipping multi-device aimdo initialization") + return False + + try: + from comfy_aimdo import control as aimdo_control + except ImportError: + logger.warning("[MultiGPU] comfy_aimdo unavailable during multi-device initialization") + return False + + init_device = getattr(aimdo_control, "init_device", None) + if not callable(init_device): + logger.warning("[MultiGPU] comfy_aimdo.control.init_device missing; skipping multi-device initialization") + return False + + initialized_any = False + for device_index in range(torch.cuda.device_count()): + if device_index in _aimdo_initialized_devices: + continue + logger.info(f"[MultiGPU] Initializing comfy_aimdo for CUDA device {device_index}") + initialized = bool(init_device(device_index)) + logger.info(f"[MultiGPU] comfy_aimdo init_device({device_index}) -> {initialized}") + if initialized: + _aimdo_initialized_devices.add(device_index) + initialized_any = True + + return initialized_any + +def _patch_comfy_sample_runtime_device(): + """Wrap Comfy sampling entrypoints so runtime device state matches the model load device.""" + sample_fn = getattr(comfy_sample, "sample", None) + if callable(sample_fn) and not getattr(sample_fn, "_multigpu_runtime_device_guard", False): + def sample_with_runtime_device(model, *args, **kwargs): + runtime_device = _get_runtime_device_from_model(model) + with multigpu_runtime_device_guard(runtime_device, reason=f"comfy.sample.sample:{type(model).__name__}"): + return sample_fn(model, *args, **kwargs) + + sample_with_runtime_device._multigpu_runtime_device_guard = True + sample_with_runtime_device._multigpu_original = sample_fn + comfy_sample.sample = sample_with_runtime_device + logger.info("[MultiGPU] Patched comfy.sample.sample with runtime device guard") + + sample_custom_fn = getattr(comfy_sample, "sample_custom", None) + if callable(sample_custom_fn) and not getattr(sample_custom_fn, "_multigpu_runtime_device_guard", False): + def sample_custom_with_runtime_device(model, *args, **kwargs): + runtime_device = _get_runtime_device_from_model(model) + with multigpu_runtime_device_guard(runtime_device, reason=f"comfy.sample.sample_custom:{type(model).__name__}"): + return sample_custom_fn(model, *args, **kwargs) + + sample_custom_with_runtime_device._multigpu_runtime_device_guard = True + sample_custom_with_runtime_device._multigpu_original = sample_custom_fn + comfy_sample.sample_custom = sample_custom_with_runtime_device + logger.info("[MultiGPU] Patched comfy.sample.sample_custom with runtime device guard") + def _patch_comfy_kitchen_dlpack_device_guard(): """Guard comfy_kitchen DLPack export by switching to the tensor's CUDA device.""" try: @@ -256,20 +408,8 @@ def _patch_comfy_kitchen_dlpack_device_guard(): def wrap_for_dlpack_with_device_guard(*args, **kwargs): tensor = args[0] if args else kwargs.get("tensor") - previous_device_index = None - switched_device = False - - if isinstance(tensor, torch.Tensor) and tensor.is_cuda and tensor.device.index is not None: - previous_device_index = torch.cuda.current_device() - if previous_device_index != tensor.device.index: - torch.cuda.set_device(tensor.device.index) - switched_device = True - - try: + with cuda_device_guard(getattr(tensor, "device", None), reason="comfy_kitchen._wrap_for_dlpack"): return wrap_for_dlpack(*args, **kwargs) - finally: - if switched_device and previous_device_index is not None: - torch.cuda.set_device(previous_device_index) wrap_for_dlpack_with_device_guard._multigpu_cuda_device_guard = True comfy_kitchen_cuda._wrap_for_dlpack = wrap_for_dlpack_with_device_guard @@ -284,7 +424,10 @@ def wrap_for_dlpack_with_device_guard(*args, **kwargs): mm.get_torch_device = get_torch_device_patched mm.text_encoder_device = text_encoder_device_patched mm.unet_offload_device = unet_offload_device_patched +_patch_model_management_current_stream() +_patch_comfy_sample_runtime_device() _patch_comfy_kitchen_dlpack_device_guard() +_initialize_aimdo_visible_cuda_devices() from .nodes import ( DeviceSelectorMultiGPU, diff --git a/wrappers.py b/wrappers.py index a132792..304b85c 100644 --- a/wrappers.py +++ b/wrappers.py @@ -447,7 +447,7 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra def override_class(cls): """Standard MultiGPU device override for UNet/VAE models""" - from . import set_current_device, get_current_device + from . import set_current_device, get_current_device, cuda_device_guard class NodeOverride(cls): @classmethod @@ -466,10 +466,11 @@ def override(self, *args, device=None, **kwargs): original_device = get_current_device() if device is not None: set_current_device(device) + target_device = device if device is not None else get_current_device() fn = getattr(super(), cls.FUNCTION) - out = fn(*args, **kwargs) try: - return out + with cuda_device_guard(target_device, reason=f"{type(self).__name__}.{cls.FUNCTION}"): + return fn(*args, **kwargs) finally: set_current_device(original_device) @@ -477,7 +478,13 @@ def override(self, *args, device=None, **kwargs): def override_class_offload(cls): """Standard MultiGPU device override for UNet/VAE models""" - from . import set_current_device, set_current_unet_offload_device, get_current_device, get_current_unet_offload_device + from . import ( + set_current_device, + set_current_unet_offload_device, + get_current_device, + get_current_unet_offload_device, + cuda_device_guard, + ) class NodeOverride(cls): @classmethod @@ -500,10 +507,11 @@ def override(self, *args, device=None, offload_device=None, **kwargs): set_current_device(device) if offload_device is not None: set_current_unet_offload_device(offload_device) + target_device = device if device is not None else get_current_device() fn = getattr(super(), cls.FUNCTION) - out = fn(*args, **kwargs) try: - return out + with cuda_device_guard(target_device, reason=f"{type(self).__name__}.{cls.FUNCTION}"): + return fn(*args, **kwargs) finally: set_current_device(original_device) set_current_unet_offload_device(original_offload_device) From 0b438f7a8bf3198fc60c6dbedb62494b9897a532 Mon Sep 17 00:00:00 2001 From: John Pollock Date: Fri, 6 Mar 2026 05:59:12 -0600 Subject: [PATCH 3/6] Refactor code for improved readability and performance - Cleaned up unnecessary whitespace and comments in model_management_mgpu.py, nodes.py, wanvideo.py, and wrappers.py for better code clarity. - Replaced list comprehensions with direct list conversions in nodes.py for efficiency. - Updated memory logging format in model_management_mgpu.py to streamline data capture. - Enhanced device management in wanvideo.py by ensuring consistent device setting and loading. - Added linting configurations in pyproject.toml to enforce code quality standards. - Removed unused imports and optimized existing ones across multiple files. --- __init__.py | 31 ++++---- checkpoint_multigpu.py | 68 +++++++++-------- ci/extract_allocation.py | 16 ++-- ci/run_workflows.py | 30 +++++--- ci/summarize_log.py | 14 +++- device_utils.py | 58 +++++++------- distorch_2.py | 161 ++++++++++++++++++--------------------- model_management_mgpu.py | 22 +++--- nodes.py | 20 ++--- pyproject.toml | 78 ++++++++++++++++++- wanvideo.py | 40 +++++----- wrappers.py | 93 +++++++++++----------- 12 files changed, 354 insertions(+), 277 deletions(-) diff --git a/__init__.py b/__init__.py index 14abdbd..dbd15d8 100644 --- a/__init__.py +++ b/__init__.py @@ -1,13 +1,12 @@ import torch import logging -import weakref import os -import copy import json import importlib from contextlib import contextmanager from datetime import datetime from pathlib import Path +from types import MethodType import folder_paths import comfy.model_management as mm import comfy.memory_management @@ -17,13 +16,13 @@ from .device_utils import ( get_device_list, is_accelerator_available, - soft_empty_cache_multigpu, + soft_empty_cache_multigpu as soft_empty_cache_multigpu, ) from .model_management_mgpu import ( - trigger_executor_cache_reset, - check_cpu_memory_threshold, - multigpu_memory_log, - force_full_system_cleanup, + trigger_executor_cache_reset as trigger_executor_cache_reset, + check_cpu_memory_threshold as check_cpu_memory_threshold, + multigpu_memory_log as multigpu_memory_log, + force_full_system_cleanup as force_full_system_cleanup, ) WEB_DIRECTORY = "./web" @@ -138,7 +137,7 @@ def mgpu_mm_log_method(self, msg): f"[MultiGPU Model Management] {msg}", extra={"mgpu_context": {"component": "model_management"}}, ) -logger.mgpu_mm_log = mgpu_mm_log_method.__get__(logger, type(logger)) +logger.mgpu_mm_log = MethodType(mgpu_mm_log_method, logger) def _normalize_module_name(module_name): """Normalize a custom node directory name for tolerant matching.""" @@ -416,7 +415,7 @@ def wrap_for_dlpack_with_device_guard(*args, **kwargs): logger.info("[MultiGPU] Applied comfy_kitchen CUDA DLPack device guard patch") return True -logger.info(f"[MultiGPU Core Patching] Patching mm.get_torch_device, mm.text_encoder_device, mm.unet_offload_device") +logger.info("[MultiGPU Core Patching] Patching mm.get_torch_device, mm.text_encoder_device, mm.unet_offload_device") logger.info(f"[MultiGPU DEBUG] Initial current_device: {current_device}") logger.info(f"[MultiGPU DEBUG] Initial current_text_encoder_device: {current_text_encoder_device}") logger.info(f"[MultiGPU DEBUG] Initial current_unet_offload_device: {current_unet_offload_device}") @@ -457,18 +456,18 @@ def wrap_for_dlpack_with_device_guard(*args, **kwargs): override_class_clip, override_class_clip_no_device, override_class_with_distorch_gguf, - override_class_with_distorch_gguf_v2, + override_class_with_distorch_gguf_v2 as override_class_with_distorch_gguf_v2, override_class_with_distorch_clip, override_class_with_distorch_clip_no_device, - override_class_with_distorch, + override_class_with_distorch as override_class_with_distorch, override_class_with_distorch_safetensor_v2, override_class_with_distorch_safetensor_v2_clip, override_class_with_distorch_safetensor_v2_clip_no_device, ) from .distorch_2 import ( - register_patched_safetensor_modelpatcher, - analyze_safetensor_loading, - calculate_safetensor_vvram_allocation, + register_patched_safetensor_modelpatcher as register_patched_safetensor_modelpatcher, + analyze_safetensor_loading as analyze_safetensor_loading, + calculate_safetensor_vvram_allocation as calculate_safetensor_vvram_allocation, ) from .checkpoint_multigpu import ( @@ -569,7 +568,7 @@ def register_and_count(module_names, node_map): if check_module_exists(name): found = True break - + count = 0 if found: try: @@ -582,7 +581,7 @@ def register_and_count(module_names, node_map): for key, value in resolved_node_map.items(): NODE_CLASS_MAPPINGS[key] = value count = len(NODE_CLASS_MAPPINGS) - initial_len - + registration_data.append({"name": module_names[0], "found": "Y" if found else "N", "count": count}) return found diff --git a/checkpoint_multigpu.py b/checkpoint_multigpu.py index 40aba3f..15b2a8f 100644 --- a/checkpoint_multigpu.py +++ b/checkpoint_multigpu.py @@ -21,11 +21,11 @@ def patch_load_state_dict_guess_config(): """Monkey patch comfy.sd.load_state_dict_guess_config with MultiGPU-aware checkpoint loading.""" global original_load_state_dict_guess_config - + if original_load_state_dict_guess_config is not None: logger.debug("[MultiGPU Checkpoint] load_state_dict_guess_config is already patched.") return - + logger.info("[MultiGPU Core Patching] Patching comfy.sd.load_state_dict_guess_config for advanced MultiGPU loading.") original_load_state_dict_guess_config = comfy.sd.load_state_dict_guess_config comfy.sd.load_state_dict_guess_config = patched_load_state_dict_guess_config @@ -35,7 +35,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, te_model_options={}, metadata=None): """Patched checkpoint loader with MultiGPU and DisTorch2 device placement support.""" from . import set_current_device, set_current_text_encoder_device, get_current_device, get_current_text_encoder_device - + sd_size = sum(p.numel() for p in sd.values() if hasattr(p, 'numel')) config_hash = str(sd_size) device_config = checkpoint_device_config.get(config_hash) @@ -53,7 +53,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, vae = None model = None model_patcher = None - + # Capture the current devices at runtime so we can restore them after loading original_main_device = get_current_device() original_clip_device = get_current_text_encoder_device() @@ -68,7 +68,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, sd, metadata = comfy.utils.convert_old_quants(sd, diffusion_model_prefix, metadata=metadata) model_config = comfy.model_detection.model_config_from_unet(sd, diffusion_model_prefix, metadata=metadata) - + if model_config is None: logger.warning("[MultiGPU] Warning: Not a standard checkpoint file. Trying to load as diffusion model only.") # Simplified fallback for non-checkpoints @@ -83,13 +83,13 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, unet_weight_dtype = list(model_config.supported_inference_dtypes) if model_config.scaled_fp8 is not None: weight_dtype = None - + if custom_operations is not None: model_config.custom_operations = custom_operations unet_dtype = model_options.get("dtype", model_options.get("weight_dtype", None)) if unet_dtype is None: unet_dtype = mm.unet_dtype(model_params=parameters, supported_dtypes=unet_weight_dtype, weight_dtype=weight_dtype) - + unet_compute_device = device_config.get('unet_device', original_main_device) if model_config.scaled_fp8 is not None: manual_cast_dtype = mm.unet_manual_cast(None, torch.device(unet_compute_device), model_config.supported_inference_dtypes) @@ -104,7 +104,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, if output_model: unet_compute_device = device_config.get('unet_device', original_main_device) - set_current_device(unet_compute_device) + set_current_device(unet_compute_device) inital_load_device = mm.unet_inital_load_device(parameters, unet_dtype) multigpu_memory_log(f"unet:{config_hash[:8]}", "pre-load") @@ -131,7 +131,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, vae_target_device = torch.device(device_config.get('vae_device', original_main_device)) set_current_device(vae_target_device) # Use main device context for VAE multigpu_memory_log(f"vae:{config_hash[:8]}", "pre-load") - + vae_sd = comfy.utils.state_dict_prefix_replace(sd, {k: "" for k in model_config.vae_key_prefix}, filter_keys=True) vae_sd = model_config.process_vae_state_dict(vae_sd) vae = VAE(sd=vae_sd, metadata=metadata) @@ -151,7 +151,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, for pref in scaled_fp8_list: skip = skip or k.startswith(pref) if not skip: - out_sd[k] = sd[k] + out_sd[k] = sd[k] for pref in scaled_fp8_list: quant_sd, qmetadata = comfy.utils.convert_old_quants(sd, pref, metadata={}) @@ -161,7 +161,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, clip_target_device = device_config.get('clip_device', original_clip_device) set_current_text_encoder_device(clip_target_device) - + clip_target = model_config.clip_target(state_dict=sd) if clip_target is not None: clip_sd = model_config.process_clip_state_dict(sd) @@ -182,15 +182,17 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, clip.patcher.model._distorch_high_precision_loras = distorch_config.get('high_precision_loras', True) m, u = clip.load_sd(clip_sd, full_model=True) # This respects the patched text_encoder_device - if len(m) > 0: logger.warning(f"CLIP missing keys: {m}") - if len(u) > 0: logger.debug(f"CLIP unexpected keys: {u}") + if len(m) > 0: + logger.warning(f"CLIP missing keys: {m}") + if len(u) > 0: + logger.debug(f"CLIP unexpected keys: {u}") logger.info("CLIP Loaded.") multigpu_memory_log(f"clip:{config_hash[:8]}", "post-load") else: logger.warning("No CLIP/text encoder weights in checkpoint.") else: logger.warning("CLIP target not found in model config.") - + finally: set_current_device(original_main_device) set_current_text_encoder_device(original_clip_device) @@ -206,7 +208,7 @@ def INPUT_TYPES(s): import folder_paths devices = get_device_list() default_device = devices[1] if len(devices) > 1 else devices[0] - + return { "required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ), @@ -215,27 +217,27 @@ def INPUT_TYPES(s): "vae_device": (devices, {"default": default_device}), } } - + RETURN_TYPES = ("MODEL", "CLIP", "VAE") FUNCTION = "load_checkpoint" CATEGORY = "multigpu" TITLE = "Checkpoint Loader Advanced (MultiGPU)" - + def load_checkpoint(self, ckpt_name, unet_device, clip_device, vae_device): patch_load_state_dict_guess_config() - + import folder_paths import comfy.utils - + ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name) sd = comfy.utils.load_torch_file(ckpt_path) sd_size = sum(p.numel() for p in sd.values() if hasattr(p, 'numel')) config_hash = str(sd_size) - + checkpoint_device_config[config_hash] = { 'unet_device': unet_device, 'clip_device': clip_device, 'vae_device': vae_device } - + # Load using standard loader, our patch will intercept from nodes import CheckpointLoaderSimple return CheckpointLoaderSimple().load_checkpoint(ckpt_name) @@ -247,7 +249,7 @@ def INPUT_TYPES(s): import folder_paths devices = get_device_list() compute_device = devices[1] if len(devices) > 1 else devices[0] - + return { "required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ), @@ -265,18 +267,18 @@ def INPUT_TYPES(s): "eject_models": ("BOOLEAN", {"default": True}), } } - + RETURN_TYPES = ("MODEL", "CLIP", "VAE") FUNCTION = "load_checkpoint" CATEGORY = "multigpu/distorch_2" TITLE = "Checkpoint Loader Advanced (DisTorch2)" - + def load_checkpoint(self, ckpt_name, unet_compute_device, unet_virtual_vram_gb, unet_donor_device, clip_compute_device, clip_virtual_vram_gb, clip_donor_device, vae_device, unet_expert_mode_allocations="", clip_expert_mode_allocations="", high_precision_loras=True, eject_models=True): - + if eject_models: - logger.mgpu_mm_log(f"[EJECT_MODELS_SETUP] eject_models=True - marking all loaded models for eviction") + logger.mgpu_mm_log("[EJECT_MODELS_SETUP] eject_models=True - marking all loaded models for eviction") ejection_count = 0 for i, lm in enumerate(mm.current_loaded_models): model_name = type(getattr(lm.model, 'model', lm.model)).__name__ if lm.model else 'Unknown' @@ -289,17 +291,17 @@ def load_checkpoint(self, ckpt_name, unet_compute_device, unet_virtual_vram_gb, logger.mgpu_mm_log(f"[EJECT_MARKED] Model {i}: {model_name} (direct patcher) ā†’ marked for eviction") ejection_count += 1 logger.mgpu_mm_log(f"[EJECT_MODELS_SETUP_COMPLETE] Marked {ejection_count} models for Comfy Core eviction during load_models_gpu") - - patch_load_state_dict_guess_config() - + + patch_load_state_dict_guess_config() + import folder_paths import comfy.utils - + ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name) sd = comfy.utils.load_torch_file(ckpt_path) sd_size = sum(p.numel() for p in sd.values() if hasattr(p, 'numel')) config_hash = str(sd_size) - + checkpoint_device_config[config_hash] = { 'unet_device': unet_compute_device, 'clip_device': clip_compute_device, @@ -312,7 +314,7 @@ def load_checkpoint(self, ckpt_name, unet_compute_device, unet_virtual_vram_gb, elif unet_expert_mode_allocations: unet_vram_str = unet_compute_device unet_alloc = f"{unet_expert_mode_allocations}#{unet_vram_str}" if unet_expert_mode_allocations or unet_vram_str else "" - + clip_vram_str = "" if clip_virtual_vram_gb > 0: clip_vram_str = f"{clip_compute_device};{clip_virtual_vram_gb};{clip_donor_device}" @@ -327,6 +329,6 @@ def load_checkpoint(self, ckpt_name, unet_compute_device, unet_virtual_vram_gb, 'unet_settings': hashlib.sha256(f"{unet_alloc}{high_precision_loras}".encode()).hexdigest(), 'clip_settings': hashlib.sha256(f"{clip_alloc}{high_precision_loras}".encode()).hexdigest(), } - + from nodes import CheckpointLoaderSimple return CheckpointLoaderSimple().load_checkpoint(ckpt_name) diff --git a/ci/extract_allocation.py b/ci/extract_allocation.py index a11c05e..734ee23 100644 --- a/ci/extract_allocation.py +++ b/ci/extract_allocation.py @@ -3,10 +3,16 @@ import argparse import json +import sys from pathlib import Path from typing import Iterable, Iterator, Dict, Any +def _write_stdout(message: str = "") -> None: + sys.stdout.write(f"{message}\n") + sys.stdout.flush() + + def load_json_lines(path: Path) -> Iterator[Dict[str, Any]]: with path.open("r", encoding="utf-8") as handle: for line in handle: @@ -37,12 +43,12 @@ def main() -> int: entries = list(load_json_lines(args.logfile)) if not entries: - print("No entries found in log file.") + _write_stdout("No entries found in log file.") return 0 matched = [entry for entry in entries if is_allocation_event(entry, args.keywords)] if not matched: - print("No allocation events matched provided keywords.") + _write_stdout("No allocation events matched provided keywords.") return 0 for entry in matched: @@ -51,9 +57,9 @@ def main() -> int: component = entry.get("component", "") header_bits = [bit for bit in (timestamp, category, component) if bit] header = " | ".join(header_bits) if header_bits else "allocation" - print(f"## {header}") - print(entry.get("message", "")) - print() + _write_stdout(f"## {header}") + _write_stdout(entry.get("message", "")) + _write_stdout() return 0 diff --git a/ci/run_workflows.py b/ci/run_workflows.py index 8ad7e3d..a2b9879 100644 --- a/ci/run_workflows.py +++ b/ci/run_workflows.py @@ -19,6 +19,16 @@ DEFAULT_WORKFLOW_TIMEOUT = int(os.environ.get("COMFYUI_WORKFLOW_TIMEOUT", "900")) +def _write_stdout(message: str) -> None: + sys.stdout.write(f"{message}\n") + sys.stdout.flush() + + +def _write_stderr(message: str) -> None: + sys.stderr.write(f"{message}\n") + sys.stderr.flush() + + class ComfyWorkflowRunner: def __init__(self, host: str, port: int, connect_timeout: int, workflow_timeout: int, secure: bool = False) -> None: self.host = host @@ -78,7 +88,7 @@ def wait_for_completion(self, prompt_id: str) -> bool: except websocket.WebSocketTimeoutException: continue except Exception as exc: # noqa: BLE001 - print(f"WebSocket error: {exc}", file=sys.stderr, flush=True) + _write_stderr(f"WebSocket error: {exc}") return False if isinstance(message, bytes): @@ -94,16 +104,16 @@ def wait_for_completion(self, prompt_id: str) -> bool: if message_type == "execution_error": if data.get("prompt_id") == prompt_id: - print(f"Execution error: {payload}", file=sys.stderr, flush=True) + _write_stderr(f"Execution error: {payload}") return False elif message_type == "status" and data.get("status") == "error": if data.get("prompt_id") == prompt_id: - print(f"Status error: {payload}", file=sys.stderr, flush=True) + _write_stderr(f"Status error: {payload}") return False elif message_type == "executing": if data.get("prompt_id") == prompt_id and data.get("node") is None: return True - print("Workflow timed out", file=sys.stderr, flush=True) + _write_stderr("Workflow timed out") return False def run_workflow(self, workflow_path: Path) -> bool: @@ -126,25 +136,25 @@ def restore_env() -> None: with workflow_path.open("r", encoding="utf-8") as handle: workflow = json.load(handle) except (OSError, json.JSONDecodeError) as exc: - print(f"Failed to load workflow {workflow_path}: {exc}", file=sys.stderr, flush=True) + _write_stderr(f"Failed to load workflow {workflow_path}: {exc}") restore_env() return False - print(f"Running workflow {workflow_path}", flush=True) + _write_stdout(f"Running workflow {workflow_path}") start = time.monotonic() try: prompt_id = self.queue_prompt(workflow) os.environ["MGPU_JSON_PROMPT"] = prompt_id except requests.HTTPError as exc: - print(f"HTTP error while queueing workflow: {exc}", file=sys.stderr, flush=True) + _write_stderr(f"HTTP error while queueing workflow: {exc}") restore_env() return False except requests.RequestException as exc: - print(f"Request error while queueing workflow: {exc}", file=sys.stderr, flush=True) + _write_stderr(f"Request error while queueing workflow: {exc}") restore_env() return False except RuntimeError as exc: - print(str(exc), file=sys.stderr, flush=True) + _write_stderr(str(exc)) restore_env() return False @@ -152,7 +162,7 @@ def restore_env() -> None: if not self.wait_for_completion(prompt_id): return False duration = time.monotonic() - start - print(f"Workflow {workflow_path} completed in {duration:.2f}s", flush=True) + _write_stdout(f"Workflow {workflow_path} completed in {duration:.2f}s") return True finally: restore_env() diff --git a/ci/summarize_log.py b/ci/summarize_log.py index f1d3b4b..1e6fd94 100644 --- a/ci/summarize_log.py +++ b/ci/summarize_log.py @@ -3,10 +3,16 @@ import argparse import json +import sys from pathlib import Path from typing import Iterator, Dict, Any +def _write_stdout(message: str = "") -> None: + sys.stdout.write(f"{message}\n") + sys.stdout.flush() + + def load_json_lines(path: Path) -> Iterator[Dict[str, Any]]: with path.open("r", encoding="utf-8") as handle: for line in handle: @@ -32,11 +38,11 @@ def main() -> int: entries = list(load_json_lines(args.logfile)) if not entries: - print("No entries found in log file.") + _write_stdout("No entries found in log file.") return 0 - print("| Timestamp | Level | Component | Message |") - print("| --- | --- | --- | --- |") + _write_stdout("| Timestamp | Level | Component | Message |") + _write_stdout("| --- | --- | --- | --- |") for entry in entries: level = entry.get("level", "") if args.severity and level not in args.severity: @@ -50,7 +56,7 @@ def main() -> int: continue timestamp = entry.get("timestamp", "") message = entry.get("message", "").replace("|", "\u2502") - print(f"| {timestamp} | {level} | {component} | {message} |") + _write_stdout(f"| {timestamp} | {level} | {component} | {message} |") return 0 diff --git a/device_utils.py b/device_utils.py index 6b7b7ae..a29b83b 100644 --- a/device_utils.py +++ b/device_utils.py @@ -1,9 +1,9 @@ import torch import logging -import hashlib import psutil import comfy.model_management as mm import gc +import importlib logger = logging.getLogger("MultiGPU") @@ -14,7 +14,7 @@ def get_device_list(): Enumerate ALL physically available devices that can store torch tensors. This includes all device types supported by ComfyUI core. Results are cached after first call since devices don't change during runtime. - + Returns a comprehensive list of all available devices across all types: - CPU (always available) - CUDA devices (NVIDIA GPUs + AMD w/ ROCm GPUs) @@ -26,51 +26,51 @@ def get_device_list(): - CoreX/IXUCA devices """ global _DEVICE_LIST_CACHE - + if _DEVICE_LIST_CACHE is not None: return _DEVICE_LIST_CACHE - + devs = [] - + devs.append("cpu") - + if hasattr(torch, "cuda") and hasattr(torch.cuda, "is_available") and torch.cuda.is_available(): device_count = torch.cuda.device_count() devs += [f"cuda:{i}" for i in range(device_count)] logger.debug(f"[MultiGPU_Device_Utils] Found {device_count} CUDA device(s)") - + try: - import intel_extension_for_pytorch as ipex + importlib.import_module("intel_extension_for_pytorch") except ImportError: pass - + if hasattr(torch, "xpu") and hasattr(torch.xpu, "is_available") and torch.xpu.is_available(): device_count = torch.xpu.device_count() devs += [f"xpu:{i}" for i in range(device_count)] logger.debug(f"[MultiGPU_Device_Utils] Found {device_count} XPU device(s)") - + try: - import torch_npu + importlib.import_module("torch_npu") if hasattr(torch, "npu") and hasattr(torch.npu, "is_available") and torch.npu.is_available(): device_count = torch.npu.device_count() devs += [f"npu:{i}" for i in range(device_count)] logger.debug(f"[MultiGPU_Device_Utils] Found {device_count} NPU device(s)") except ImportError: pass - + try: - import torch_mlu + importlib.import_module("torch_mlu") if hasattr(torch, "mlu") and hasattr(torch.mlu, "is_available") and torch.mlu.is_available(): device_count = torch.mlu.device_count() devs += [f"mlu:{i}" for i in range(device_count)] logger.debug(f"[MultiGPU_Device_Utils] Found {device_count} MLU device(s)") except ImportError: pass - + if hasattr(torch.backends, "mps") and torch.backends.mps.is_available(): devs.append("mps") logger.debug("[MultiGPU_Device_Utils] Found MPS device") - + try: import torch_directml adapter_count = torch_directml.device_count() @@ -79,7 +79,7 @@ def get_device_list(): logger.debug(f"[MultiGPU_Device_Utils] Found {adapter_count} DirectML adapter(s)") except ImportError: pass - + try: if hasattr(torch, "corex"): if hasattr(torch.corex, "device_count"): @@ -91,30 +91,30 @@ def get_device_list(): logger.debug("[MultiGPU_Device_Utils] Found CoreX device") except ImportError: pass - + _DEVICE_LIST_CACHE = devs - + logger.debug(f"[MultiGPU_Device_Utils] Device list initialized: {devs}") - + return devs def is_accelerator_available(): """Check if any GPU or accelerator device is available including CUDA, XPU, NPU, MLU, MPS, DirectML, or CoreX.""" if hasattr(torch, "cuda") and torch.cuda.is_available(): return True - + if hasattr(torch, "xpu") and hasattr(torch.xpu, "is_available") and torch.xpu.is_available(): return True - + try: - import torch_npu + importlib.import_module("torch_npu") if hasattr(torch, "npu") and hasattr(torch.npu, "is_available") and torch.npu.is_available(): return True except ImportError: pass try: - import torch_mlu + importlib.import_module("torch_mlu") if hasattr(torch, "mlu") and hasattr(torch.mlu, "is_available") and torch.mlu.is_available(): return True except ImportError: @@ -132,7 +132,7 @@ def is_accelerator_available(): if hasattr(torch, "corex"): return True - + return False def is_device_compatible(device_string): @@ -156,7 +156,7 @@ def parse_device_string(device_string): def soft_empty_cache_multigpu(): """Clear allocator caches across all devices using context managers to preserve calling thread device context.""" from .model_management_mgpu import multigpu_memory_log - + logger.mgpu_mm_log("soft_empty_cache_multigpu: starting GC and multi-device cache clear") gc.collect() @@ -164,7 +164,7 @@ def soft_empty_cache_multigpu(): # Clear cache for ALL devices (not just ComfyUI's single device) all_devices = get_device_list() logger.mgpu_mm_log(f"soft_empty_cache_multigpu: devices to clear = {all_devices}") - + # Check global availability first to avoid unnecessary iteration if backend is missing is_cuda_available = hasattr(torch, "cuda") and hasattr(torch.cuda, "is_available") and torch.cuda.is_available() @@ -235,15 +235,15 @@ def soft_empty_cache_multigpu(): def soft_empty_cache_distorch2_patched(force=False): """Patched mm.soft_empty_cache managing VRAM across all devices, CPU RAM with adaptive thresholding, and DisTorch store pruning.""" - from .model_management_mgpu import multigpu_memory_log, check_cpu_memory_threshold, trigger_executor_cache_reset - + from .model_management_mgpu import check_cpu_memory_threshold, trigger_executor_cache_reset + is_distorch_active = False for i, lm in enumerate(mm.current_loaded_models): mp = lm.model if mp is not None: inner_model = mp.model - + if hasattr(inner_model, '_distorch_v2_meta'): is_distorch_active = True break diff --git a/distorch_2.py b/distorch_2.py index 94d2f53..093f9fe 100644 --- a/distorch_2.py +++ b/distorch_2.py @@ -3,21 +3,16 @@ Contains all safetensor related code for distributed memory management """ -import sys import torch import logging -import hashlib import re -import gc +from collections import defaultdict logger = logging.getLogger("MultiGPU") -import copy -import inspect -from collections import defaultdict import comfy.model_management as mm import comfy.model_patcher -from .device_utils import get_device_list, soft_empty_cache_multigpu -from .model_management_mgpu import multigpu_memory_log, force_full_system_cleanup +from .device_utils import get_device_list +from .model_management_mgpu import multigpu_memory_log @@ -36,19 +31,16 @@ def unpack_load_item(item): def register_patched_safetensor_modelpatcher(): """Register and patch the ModelPatcher for distributed safetensor loading""" - from comfy.model_patcher import wipe_lowvram_weight, move_weight_functions # Patch ComfyUI's ModelPatcher if not hasattr(comfy.model_patcher.ModelPatcher, '_distorch_patched'): # PATCH load_models_gpu with correct memory calculations per model flags - original_load_models_gpu = mm.load_models_gpu - def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False, minimum_memory_required=None, force_full_load=False): from comfy.model_management import cleanup_models_gc, get_free_memory, free_memory, current_loaded_models from comfy.model_management import VRAMState, vram_state, lowvram_available, MIN_WEIGHT_MEMORY_RATIO from comfy.model_management import minimum_inference_memory, extra_reserved_memory, is_device_cpu - + multigpu_memory_log("load_models_gpu_top_level", "start") cleanup_models_gc() @@ -78,7 +70,7 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False logger.debug(f"[MultiGPU DisTorch V2] Registering mm_patch: {type(mm_patch).__name__}") models_temp.add(mm_patch) continue - + for mm_patch in m.model_patches_models(): models_temp.add(mm_patch) patches = m.model_patches_to(m.load_device) @@ -94,7 +86,7 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False loaded_model = mm.LoadedModel(x) try: loaded_model_index = current_loaded_models.index(loaded_model) - except: + except ValueError: loaded_model_index = None if loaded_model_index is not None: @@ -108,8 +100,8 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False for loaded_model in models_to_load: to_unload = [] - for i in range(len(current_loaded_models)): - if loaded_model.model.is_clone(current_loaded_models[i].model): + for i, current_loaded_model in enumerate(current_loaded_models): + if loaded_model.model.is_clone(current_loaded_model.model): to_unload = [i] + to_unload for i in to_unload: model_to_unload = current_loaded_models.pop(i) @@ -125,16 +117,16 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False base_memory = loaded_model.model_memory_required(device) inner_model = loaded_model.model.model - + if hasattr(inner_model, '_distorch_v2_meta'): meta = inner_model._distorch_v2_meta allocation_str = meta['full_allocation'] - + # Parse allocation string: "expert#compute_device;virtual_vram_gb;donors" parts = allocation_str.split('#') virtual_vram_gb = 0.0 has_eject = False - + if len(parts) > 1: virtual_vram_str = parts[1] virtual_info = virtual_vram_str.split(';') @@ -142,11 +134,11 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False virtual_vram_gb = float(virtual_info[1]) if len(virtual_info) > 2 and virtual_info[2]: has_eject = True - + if has_eject: eject_device = device logger.mgpu_mm_log("DisTorch eject_models detected - MAX memory eviction") - + virtual_vram_bytes = virtual_vram_gb * (1024**3) adjusted_memory = max(0, base_memory - virtual_vram_bytes) total_memory_required[device] = total_memory_required.get(device, 0) + adjusted_memory @@ -156,24 +148,24 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False total_memory_required[device] = total_memory_required.get(device, 0) + base_memory logger.mgpu_mm_log(f"[LOAD_MODELS_GPU] Standard model {(base_memory)/(1024**3):.2f}GB for device {device}") - for device in total_memory_required: + for device, device_memory in total_memory_required.items(): if device != torch.device("cpu"): - requested_mem = total_memory_required[device] * 1.1 + extra_mem - logger.mgpu_mm_log(f"[FREE_MEMORY_CALL] Device {device}: requesting {requested_mem/(1024**3):.2f}GB = {total_memory_required[device]/(1024**3):.2f}GB * 1.1 + {extra_mem/(1024**3):.2f}GB inference") - - + requested_mem = device_memory * 1.1 + extra_mem + logger.mgpu_mm_log(f"[FREE_MEMORY_CALL] Device {device}: requesting {requested_mem/(1024**3):.2f}GB = {device_memory/(1024**3):.2f}GB * 1.1 + {extra_mem/(1024**3):.2f}GB inference") + + multigpu_memory_log("free_memory", "pre") - for device in total_memory_required: + for device, device_memory in total_memory_required.items(): if device != torch.device("cpu"): if device == eject_device: total_device_memory = mm.get_total_memory(device) logger.mgpu_mm_log(f"[LOAD_MODELS_GPU] eject_models=1, is_distorch=1 ā†’ using MAX memory ({total_device_memory/(1024**3):.2f}GB) for eviction") free_memory(total_device_memory,device) else: - logger.mgpu_mm_log(f"[LOAD_MODELS_GPU] eject_models=0, using Comfy Core Computed memory ({(total_memory_required[device] * 1.1 + extra_mem)/(1024**3):.2f}GB) for eviction") - free_memory(total_memory_required[device] * 1.1 + extra_mem, device) - + logger.mgpu_mm_log(f"[LOAD_MODELS_GPU] eject_models=0, using Comfy Core Computed memory ({(device_memory * 1.1 + extra_mem)/(1024**3):.2f}GB) for eviction") + free_memory(device_memory * 1.1 + extra_mem, device) + multigpu_memory_log("free_memory/minimum_memory_required", "post/pre") for device in total_memory_required: @@ -186,7 +178,7 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False if free_mem < minimum_memory_required: models_l = free_memory(minimum_memory_required, device) logger.mgpu_mm_log(f"[EVICTION] Device {device}: unloaded {len(models_l)} models due to insufficient memory") - logging.info("{} models unloaded.".format(len(models_l))) + logging.info(f"{len(models_l)} models unloaded.") multigpu_memory_log("minimum_memory_required", "post") @@ -198,7 +190,7 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False else: vram_set_state = vram_state lowvram_model_memory = 0 - if lowvram_available and (vram_set_state == VRAMState.LOW_VRAM or vram_set_state == VRAMState.NORMAL_VRAM) and not force_full_load: + if lowvram_available and vram_set_state in (VRAMState.LOW_VRAM, VRAMState.NORMAL_VRAM) and not force_full_load: loaded_memory = loaded_model.model_loaded_memory() current_free_mem = get_free_memory(torch_dev) + loaded_memory @@ -218,21 +210,20 @@ def patched_load_models_gpu(models, memory_required=0, force_patch_weights=False def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_patch_weights=False, **kwargs): """Override to use direct model annotation for allocation""" - + mp_id = id(self) - mp_patches_uuid = self.patches_uuid inner_model = self.model inner_model_id = id(inner_model) - + if not hasattr(inner_model, "_distorch_v2_meta"): logger.debug(f"[DISTORCH_SKIP] ModelPatcher=0x{mp_id:x} inner_model=0x{inner_model_id:x} type={type(inner_model).__name__} - no metadata, using standard loading") result = original_partially_load(self, device_to, extra_memory, force_patch_weights) if hasattr(self, '_distorch_block_assignments'): del self._distorch_block_assignments return result - + allocations = inner_model._distorch_v2_meta['full_allocation'] - + if not hasattr(self.model, '_distorch_high_precision_loras'): self.model._distorch_high_precision_loras = True @@ -242,7 +233,7 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p unpatch_weights = self.model.current_weight_patches_uuid is not None and (self.model.current_weight_patches_uuid != self.patches_uuid or force_patch_weights) if unpatch_weights: - logger.debug(f"[MultiGPU DisTorch V2] Patches changed or forced. Unpatching model.") + logger.debug("[MultiGPU DisTorch V2] Patches changed or forced. Unpatching model.") self.unpatch_model(self.offload_device, unpatch_weights=True) self.patch_model(load_weights=False) @@ -254,7 +245,7 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p # Check for valid cache allocations_match = hasattr(self, '_distorch_last_allocations') and self._distorch_last_allocations == allocations cache_exists = hasattr(self, '_distorch_cached_assignments') - + if cache_exists and allocations_match and not unpatch_weights and not force_patch_weights: device_assignments = self._distorch_cached_assignments logger.debug(f"[MultiGPU DisTorch V2] Reusing cached analysis for {type(inner_model).__name__}") @@ -262,7 +253,7 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p device_assignments = analyze_safetensor_loading(self, allocations, is_clip=is_clip_model) ## This should be the only required line - that is how it worked previous release so if it doesn't it is Comfy changes self._distorch_cached_assignments = device_assignments self._distorch_last_allocations = allocations - + model_original_dtype = comfy.utils.weight_dtype(self.model.state_dict()) high_precision_loras = getattr(self.model, "_distorch_high_precision_loras", True) # Use standard ComfyUI load list - the device comparison fix ensures we don't crash @@ -270,12 +261,12 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p loading.sort(reverse=True) for item in loading: module_size, module_name, module_object, params = unpack_load_item(item) - if not unpatch_weights and hasattr(module_object, "comfy_patched_weights") and module_object.comfy_patched_weights == True: + if not unpatch_weights and hasattr(module_object, "comfy_patched_weights") and module_object.comfy_patched_weights is True: block_target_device = device_assignments['block_assignments'].get(module_name, device_to) current_module_device = None try: if any(p.numel() > 0 for p in module_object.parameters(recurse=False)): - current_module_device = next(module_object.parameters(recurse=False)).device + current_module_device = next(module_object.parameters(recurse=False)).device except StopIteration: pass @@ -290,8 +281,8 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p module_object.to(device_to) # Step 2: Apply LoRa patches while on compute device - weight_key = "{}.weight".format(module_name) - bias_key = "{}.bias".format(module_name) + weight_key = f"{module_name}.weight" + bias_key = f"{module_name}.bias" if weight_key in self.patches: self.patch_weight_to_device(weight_key, device_to=device_to) @@ -335,7 +326,7 @@ def new_partially_load(self, device_to, extra_memory=0, full_load=False, force_p return 0 - + comfy.model_patcher.ModelPatcher.partially_load = new_partially_load comfy.model_patcher.ModelPatcher._distorch_patched = True logger.info("[MultiGPU Core Patching] Successfully patched ModelPatcher.partially_load") @@ -347,9 +338,9 @@ def _extract_clip_head_blocks(raw_block_list, compute_device): distributable_blocks = [] head_memory = 0 block_assignments = {} - + block_assignments = {} - + for item in raw_block_list: module_size, module_name, module_object, params = unpack_load_item(item) if any(kw in module_name.lower() for kw in head_keywords): @@ -358,7 +349,7 @@ def _extract_clip_head_blocks(raw_block_list, compute_device): head_memory += module_size else: distributable_blocks.append((module_size, module_name, module_object, params)) - + return head_blocks, distributable_blocks, block_assignments, head_memory def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False): @@ -370,8 +361,6 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) device_table = {} distorch_alloc = "" virtual_vram_str = "" - virtual_vram_gb = 0.0 - if '#' in allocations_string: distorch_alloc, virtual_vram_str = allocations_string.split('#', 1) else: @@ -381,16 +370,13 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) logger.debug(f"[MultiGPU DisTorch V2] Compute Device: {compute_device}") if not distorch_alloc: - mode = "fraction" distorch_alloc = calculate_safetensor_vvram_allocation(model_patcher, virtual_vram_str) elif any(c in distorch_alloc.lower() for c in ['g', 'm', 'k', 'b']): - mode = "byte" distorch_alloc = calculate_fraction_from_byte_expert_string(model_patcher, distorch_alloc) elif "%" in distorch_alloc: - mode = "ratio" distorch_alloc = calculate_fraction_from_ratio_expert_string(model_patcher, distorch_alloc) - + all_devices = get_device_list() present_devices = {item.split(',')[0] for item in distorch_alloc.split(';') if ',' in item} for device in all_devices: @@ -421,20 +407,20 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) logger.info(eq_line) logger.info(" DisTorch2 Model Device Allocations") logger.info(eq_line) - + fmt_rosetta = "{:<8}{:>9}{:>9}{:>11}{:>10}" logger.info(fmt_rosetta.format("Device", "VRAM GB", "Dev %", "Model GB", "Dist %")) logger.info(dash_line) sorted_devices = sorted(device_table.keys(), key=lambda d: (d == "cpu", d)) - + total_allocated_model_bytes = sum(d["alloc_gb"] * (1024**3) for d in device_table.values()) for dev in sorted_devices: total_dev_gb = device_table[dev]["total_gb"] alloc_fraction = device_table[dev]["fraction"] alloc_gb = device_table[dev]["alloc_gb"] - + dist_ratio_percent = (alloc_gb * (1024**3) / total_allocated_model_bytes) * 100 if total_allocated_model_bytes > 0 else 0 logger.info(fmt_rosetta.format( @@ -444,7 +430,7 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) f"{alloc_gb:.2f}", f"{dist_ratio_percent:.1f}%" )) - + logger.info(dash_line) block_summary = {} @@ -485,9 +471,9 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) module_size, module_name, module_object, params = unpack_load_item(item) distributable_all_blocks.append((module_name, module_object, type(module_object).__name__, module_size)) - block_list = [b for b in distributable_all_blocks if (b[3] >= MIN_BLOCK_THRESHOLD and hasattr(b[1], "bias"))] + block_list = [b for b in distributable_all_blocks if (b[3] >= MIN_BLOCK_THRESHOLD and hasattr(b[1], "bias"))] tiny_block_list = [b for b in distributable_all_blocks if b not in block_list] - + logger.debug(f"[MultiGPU DisTorch V2] Total blocks: {len(all_blocks)}") logger.debug(f"[MultiGPU DisTorch V2] Distributable blocks: {len(block_list)}") logger.debug(f"[MultiGPU DisTorch V2] Tiny blocks (<0.01%): {len(tiny_block_list)}") @@ -497,19 +483,19 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) fmt_layer = "{:<18}{:>7}{:>14}{:>10}" logger.info(fmt_layer.format("Layer Type", "Layers", "Memory (MB)", "% Total")) logger.info(dash_line) - + for layer_type, count in block_summary.items(): mem_mb = memory_by_type[layer_type] / (1024 * 1024) mem_percent = (memory_by_type[layer_type] / total_memory) * 100 if total_memory > 0 else 0 logger.info(fmt_layer.format(layer_type[:18], str(count), f"{mem_mb:.2f}", f"{mem_percent:.1f}%")) - + logger.info(dash_line) # Distribute blocks sequentially from the tail of the model - device_assignments = {device: [] for device in DEVICE_RATIOS_DISTORCH.keys()} + device_assignments = {device: [] for device in DEVICE_RATIOS_DISTORCH} # Create a memory quota for each donor device based on its calculated allocation. - donor_devices = [d for d in sorted_devices] + donor_devices = list(sorted_devices) donor_quotas = { dev: device_table[dev]["alloc_gb"] * (1024**3) for dev in donor_devices @@ -529,7 +515,7 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) donor_quotas[donor] -= block_memory assigned_to_donor = True break # Move to the next block - + if not assigned_to_donor: #Note - small rounding errors and tensor-fitting on devices make a block occasionally an orphan. We treat orphans the same as tiny_block_list as they are generally small rounding errors block_assignments[block_name] = compute_device @@ -549,7 +535,7 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) logger.info(dash_line) logger.info(fmt_assign.format("Device", "Layers", "Memory (MB)", "% Total")) logger.info(dash_line) - + if tiny_block_list: tiny_block_memory = sum(b[3] for b in tiny_block_list) tiny_mem_mb = tiny_block_memory / (1024 * 1024) @@ -560,7 +546,7 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) total_assigned_memory = 0 device_memories = {} - + for device, blocks in device_assignments.items(): dist_blocks = [b for b in blocks if b[3] >= MIN_BLOCK_THRESHOLD] if not dist_blocks: @@ -577,11 +563,11 @@ def analyze_safetensor_loading(model_patcher, allocations_string, is_clip=False) dist_blocks = [b for b in device_assignments[dev] if b[3] >= MIN_BLOCK_THRESHOLD] if not dist_blocks: continue - + mem_mb = device_memories[dev] / (1024 * 1024) mem_percent = (device_memories[dev] / total_memory) * 100 if total_memory > 0 else 0 logger.info(fmt_assign.format(dev, str(len(dist_blocks)), f"{mem_mb:.2f}", f"{mem_percent:.1f}%")) - + logger.info(dash_line) return { @@ -595,10 +581,10 @@ def parse_memory_string(mem_str): match = re.match(r'(\d+\.?\d*)\s*([gmkb]?)', mem_str) if not match: raise ValueError(f"Invalid memory string format: {mem_str}") - + val, unit = match.groups() val = float(val) - + if unit == 'g': return val * (1024**3) elif unit == 'm': @@ -623,7 +609,7 @@ def calculate_fraction_from_byte_expert_string(model_patcher, byte_str): continue dev_name, val_str = allocation.split(',', 1) is_wildcard = '*' in val_str - + if is_wildcard: wildcard_device = dev_name # Don't add wildcard to the priority list yet @@ -640,12 +626,12 @@ def calculate_fraction_from_byte_expert_string(model_patcher, byte_str): # Determine the actual bytes to allocate to this device bytes_to_assign = min(requested_bytes, remaining_model_bytes) - + if bytes_to_assign > 0: final_byte_allocations[dev] = bytes_to_assign remaining_model_bytes -= bytes_to_assign logger.info(f"[MultiGPU DisTorch V2] Assigning {bytes_to_assign / (1024**2):.2f}MB of model to {dev} (requested {requested_bytes / (1024**2):.2f}MB).") - + if remaining_model_bytes <= 0: logger.info("[MultiGPU DisTorch V2] All model blocks have been allocated. Subsequent devices in the string will receive no assignment.") break @@ -662,7 +648,7 @@ def calculate_fraction_from_byte_expert_string(model_patcher, byte_str): if total_device_vram > 0: fraction = bytes_alloc / total_device_vram allocation_parts.append(f"{dev},{fraction:.4f}") - + allocations_string = ";".join(allocation_parts) return allocations_string @@ -674,7 +660,8 @@ def calculate_fraction_from_ratio_expert_string(model_patcher, ratio_str): raw_ratios = {} for allocation in ratio_str.split(';'): - if ',' not in allocation: continue + if ',' not in allocation: + continue dev_name, val_str = allocation.split(',', 1) # Assumes the value is a unitless ratio number, ignores '%' for simplicity. value = float(val_str.replace('%','').strip()) @@ -696,7 +683,7 @@ def calculate_fraction_from_ratio_expert_string(model_patcher, ratio_str): ratio_string = ":".join(ratio_values) normalized_pcts = [(v / total_ratio_parts) * 100 for v in raw_ratios.values()] - + put_parts = [] for i, dev_name in enumerate(raw_ratios.keys()): put_parts.append(f"{int(normalized_pcts[i])}% on {dev_name}") @@ -707,7 +694,7 @@ def calculate_fraction_from_ratio_expert_string(model_patcher, ratio_str): put_part = f"{put_parts[0]} and {put_parts[1]}" else: put_part = ", ".join(put_parts[:-1]) + f", and {put_parts[-1]}" - + logger.info(f"[MultiGPU DisTorch V2] Ratio(%) Mode - {ratio_str} -> {ratio_string} ratio, put {put_part}") allocations_string = ";".join(allocation_parts) @@ -736,31 +723,31 @@ def calculate_safetensor_vvram_allocation(model_patcher, virtual_vram_str): logger.info(fmt_assign.format(recipient_device, 'recip', f"{recipient_vram:.2f}GB",f"{recipient_virtual:.2f}GB", f"+{virtual_vram_gb:.2f}GB")) # Handle donor devices - ram_donors = [d for d in donors.split(',')] + ram_donors = list(donors.split(',')) remaining_vram_needed = virtual_vram_gb - + donor_device_info = {} donor_allocations = {} - + for donor in ram_donors: donor_vram = mm.get_total_memory(torch.device(donor)) / (1024**3) max_donor_capacity = donor_vram - + donation = min(remaining_vram_needed, max_donor_capacity) donor_virtual = donor_vram - donation remaining_vram_needed -= donation donor_allocations[donor] = donation - + donor_device_info[donor] = (donor_vram, donor_virtual) logger.info(fmt_assign.format(donor, 'donor', f"{donor_vram:.2f}GB", f"{donor_virtual:.2f}GB", f"-{donation:.2f}GB")) - - + + logger.info(dash_line) # Calculate model size model = model_patcher.model if hasattr(model_patcher, 'model') else model_patcher total_memory = 0 - + for name, module in model.named_modules(): if hasattr(module, "weight"): if module.weight is not None: @@ -790,6 +777,6 @@ def calculate_safetensor_vvram_allocation(model_patcher, virtual_vram_str): donor_vram = donor_device_info[donor][0] donor_percent = donor_allocations[donor] / donor_vram allocation_parts.append(f"{donor},{donor_percent:.4f}") - + allocations_string = ";".join(allocation_parts) return allocations_string diff --git a/model_management_mgpu.py b/model_management_mgpu.py index bd3be8f..1e5a239 100644 --- a/model_management_mgpu.py +++ b/model_management_mgpu.py @@ -8,10 +8,8 @@ import hashlib import psutil import comfy.model_management as mm -import gc from datetime import datetime, timezone import server -from collections import defaultdict @@ -46,13 +44,13 @@ def _capture_memory_snapshot(): """Capture memory snapshot for CPU and all devices""" # Import here to avoid circular dependency from .device_utils import get_device_list - + snapshot = {} - + # CPU vm = psutil.virtual_memory() snapshot["cpu"] = (vm.used, vm.total) - + # GPU devices devices = [d for d in get_device_list() if d != "cpu"] for dev_str in devices: @@ -85,26 +83,26 @@ def multigpu_memory_log(identifier, tag): ts = datetime.now(timezone.utc) curr = _capture_memory_snapshot() - + # Store in series if identifier not in _MEM_SNAPSHOT_SERIES: _MEM_SNAPSHOT_SERIES[identifier] = [] _MEM_SNAPSHOT_SERIES[identifier].append((ts, tag, curr)) - + # Clean aligned format: timestamp + padded tag + memory values ts_str = ts.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" tag_padded = f"{identifier}_{tag}".ljust(35) - + parts = [] cpu_used, _ = curr.get("cpu", (0, 0)) parts.append(f"cpu|{cpu_used/(1024**3):.2f}") - - for dev in sorted([k for k in curr.keys() if k != "cpu"]): + + for dev in sorted(k for k in curr if k != "cpu"): used, _ = curr[dev] parts.append(f"{dev}|{used/(1024**3):.2f}") - + logger.mgpu_mm_log(f"{ts_str} {tag_padded} {' '.join(parts)}") - + _MEM_SNAPSHOT_LAST[identifier] = (tag, curr) diff --git a/nodes.py b/nodes.py index c2d3787..0d1d178 100644 --- a/nodes.py +++ b/nodes.py @@ -1,9 +1,7 @@ -import torch import folder_paths from pathlib import Path from nodes import NODE_CLASS_MAPPINGS from .device_utils import get_device_list -from .model_management_mgpu import force_full_system_cleanup class DeviceSelectorMultiGPU: @classmethod @@ -24,7 +22,7 @@ def select_device(self, device): class UnetLoaderGGUF: @classmethod def INPUT_TYPES(s): - unet_names = [x for x in folder_paths.get_filename_list("unet_gguf")] + unet_names = list(folder_paths.get_filename_list("unet_gguf")) return { "required": { "unet_name": (unet_names,), @@ -44,7 +42,7 @@ def load_unet(self, unet_name, dequant_dtype=None, patch_dtype=None, patch_on_de class UnetLoaderGGUFAdvanced(UnetLoaderGGUF): @classmethod def INPUT_TYPES(s): - unet_names = [x for x in folder_paths.get_filename_list("unet_gguf")] + unet_names = list(folder_paths.get_filename_list("unet_gguf")) return { "required": { "unet_name": (unet_names,), @@ -224,7 +222,7 @@ class DownloadAndLoadFlorence2Model: def INPUT_TYPES(s): return {"required": { "model": ( - [ + [ 'microsoft/Florence-2-base', 'microsoft/Florence-2-base-ft', 'microsoft/Florence-2-large', @@ -444,12 +442,14 @@ def INPUT_TYPES(s): def load_unet(self, unet_name): """Load UNet with low-precision LoRA flag for CPU storage optimization.""" original_loader = NODE_CLASS_MAPPINGS["UNETLoader"]() - out = original_loader.load_unet(unet_name) - + out = original_loader.load_unet(unet_name, "default") + # Set the low-precision LoRA flag on the loaded model if hasattr(out[0], 'model'): out[0].model._distorch_high_precision_loras = False - elif hasattr(out[0], 'patcher') and hasattr(out[0].patcher, 'model'): - out[0].patcher.model._distorch_high_precision_loras = False - + else: + patcher = getattr(out[0], "patcher", None) + if patcher is not None and hasattr(patcher, "model"): + patcher.model._distorch_high_precision_loras = False + return out diff --git a/pyproject.toml b/pyproject.toml index 789db4b..cc07ea7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,4 +11,80 @@ Repository = "https://github.com/pollockjj/ComfyUI-MultiGPU" [tool.comfy] PublisherId = "pollockjj" DisplayName = "ComfyUI-MultiGPU" -Icon = "https://raw.githubusercontent.com/pollockjj/ComfyUI-MultiGPU/main/assets/multigpu_icon.png" \ No newline at end of file +Icon = "https://raw.githubusercontent.com/pollockjj/ComfyUI-MultiGPU/main/assets/multigpu_icon.png" + +[tool.ruff] +lint.select = [ + "N805", # invalid-first-argument-name-for-method + "S307", # suspicious-eval-usage + "S102", # exec + "E", + "T", # print-usage + "W", + # The "F" series in Ruff stands for "Pyflakes" rules, which catch various Python syntax errors and undefined names. + # See all rules here: https://docs.astral.sh/ruff/rules/#pyflakes-f + "F", +] + +lint.ignore = ["E501", "E722", "E731", "E712", "E402", "E741"] + +exclude = ["*.ipynb", "**/generated/*.pyi"] + +[tool.pylint] +master.py-version = "3.10" +master.init-hook = "import os, sys; sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), '../..')))" +master.extension-pkg-allow-list = [ + "pydantic", +] +reports.output-format = "colorized" +similarities.ignore-imports = "yes" +messages_control.disable = [ + "missing-module-docstring", + "missing-class-docstring", + "missing-function-docstring", + "line-too-long", + "too-few-public-methods", + "too-many-public-methods", + "too-many-instance-attributes", + "too-many-positional-arguments", + "broad-exception-raised", + "too-many-lines", + "invalid-name", + "unused-argument", + "broad-exception-caught", + "consider-using-with", + "fixme", + "too-many-statements", + "too-many-branches", + "too-many-locals", + "too-many-arguments", + "too-many-return-statements", + "too-many-nested-blocks", + "duplicate-code", + "abstract-method", + "superfluous-parens", + "arguments-differ", + "redefined-builtin", + "unnecessary-lambda", + "dangerous-default-value", + "invalid-overridden-method", + # next warnings should be fixed in future + "bad-classmethod-argument", # Class method should have 'cls' as first argument + "wrong-import-order", # Standard imports should be placed before third party imports + "ungrouped-imports", + "unnecessary-pass", + "unnecessary-lambda-assignment", + "no-else-return", + "unused-variable", + "arguments-renamed", + "cyclic-import", + "global-statement", + "import-outside-toplevel", + "logging-format-interpolation", + "logging-fstring-interpolation", + "protected-access", + "redefined-outer-name", + "reimported", + "useless-import-alias", + "wrong-import-position", +] diff --git a/wanvideo.py b/wanvideo.py index 1628e26..0f3be1a 100644 --- a/wanvideo.py +++ b/wanvideo.py @@ -1,17 +1,11 @@ import logging import torch -import sys import inspect import copy import folder_paths import comfy.model_management as mm from nodes import NODE_CLASS_MAPPINGS from .device_utils import get_device_list -from .model_management_mgpu import multigpu_memory_log -from comfy.utils import load_torch_file, ProgressBar -import gc -import numpy as np -import os logger = logging.getLogger("MultiGPU") @@ -43,7 +37,7 @@ def INPUT_TYPES(s): "model": (folder_paths.get_filename_list("unet_gguf") + folder_paths.get_filename_list("diffusion_models"), {"tooltip": "These models are loaded from the 'ComfyUI/models/diffusion_models' -folder",}), "base_precision": (["fp32", "bf16", "fp16", "fp16_fast"], {"default": "bf16"}), - "quantization": (["disabled", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e4m3fn_scaled", "fp8_e4m3fn_scaled_fast", "fp8_e5m2", "fp8_e5m2_fast", "fp8_e5m2_scaled", "fp8_e5m2_scaled_fast"], {"default": "disabled", + "quantization": (["disabled", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e4m3fn_scaled", "fp8_e4m3fn_scaled_fast", "fp8_e5m2", "fp8_e5m2_fast", "fp8_e5m2_scaled", "fp8_e5m2_scaled_fast"], {"default": "disabled", "tooltip": "Optional quantization method, 'disabled' acts as autoselect based by weights. Scaled modes only work with matching weights, _fast modes (fp8 matmul) require CUDA compute capability >= 8.9 (NVIDIA 4000 series and up), e4m3fn generally can not be torch.compiled on compute capability < 8.9 (3000 series and under)"}), "load_device": (["main_device", "offload_device"], {"default": "offload_device", "tooltip": "Initial device to load the model to, NOT recommended with the larger models unless you have 48GB+ VRAM"}), "compute_device": (devices, {"default": default_device}), @@ -86,7 +80,7 @@ def loadmodel(self, model, base_precision, compute_device, quantization, load_de if kwargs.get("extra_model") is None and vace_model is not None: kwargs["extra_model"] = vace_model - set_current_device(compute_device) + set_current_device(compute_device) compute_device_to_be_patched = mm.get_torch_device() loader_module.device = compute_device_to_be_patched @@ -141,16 +135,16 @@ def INPUT_TYPES(s): "add_noise_to_samples": ("BOOLEAN", {"default": False, "tooltip": "Add noise to the samples before sampling, needed for video2video sampling when starting from clean video"}), } } - + RETURN_TYPES = ("LATENT", "LATENT",) RETURN_NAMES = ("samples", "denoised_samples",) FUNCTION = "process" CATEGORY = "multigpu/WanVideoWrapper" DESCRIPTION = "MultiGPU-aware sampler that ensures correct device for each model" - + def process(self, model, compute_device, **kwargs): from . import set_current_device - + original_sampler = NODE_CLASS_MAPPINGS["WanVideoSampler"]() sampler_module = inspect.getmodule(original_sampler) @@ -253,7 +247,7 @@ def loadmodel(self, model_name, precision, device=None, quantization="disabled") from . import set_current_device set_current_device(device) - + if device == "cpu": load_device = "offload_device" else: @@ -291,7 +285,7 @@ def loadmodel(self, model_name, precision, device=None): from . import set_current_device set_current_device(device) - + if device == "cpu": load_device = "offload_device" else: @@ -428,7 +422,7 @@ def INPUT_TYPES(s): }, "optional": { "load_device": (devices, {"default": default_device}), - "precision": (["fp16", "fp32", "bf16"], {"default": "fp16"}), + "precision": (["fp16", "fp32", "bf16"], {"default": "fp16"}), "parallel": ("BOOLEAN", {"default": False, "tooltip": "uses more memory but is faster"}), } } @@ -508,8 +502,8 @@ def INPUT_TYPES(s): FUNCTION = "process" CATEGORY = "multigpu/WanVideoWrapper" - def process(self, width, height, num_frames, force_offload, noise_aug_strength, - start_latent_strength, end_latent_strength, start_image=None, end_image=None, control_embeds=None, fun_or_fl2v_model=False, + def process(self, width, height, num_frames, force_offload, noise_aug_strength, + start_latent_strength, end_latent_strength, start_image=None, end_image=None, control_embeds=None, fun_or_fl2v_model=False, temporal_mask=None, extra_latents=None, clip_embeds=None, tiled_vae=False, add_cond_latents=None, vae=None, load_device=None): from . import set_current_device @@ -579,7 +573,7 @@ def decode(self, vae, load_device, samples, enable_vae_tiling, tile_x, tile_y, t decode_module = inspect.getmodule(original_decode) original_module_device = decode_module.device - set_current_device(load_device) + set_current_device(load_device) compute_device_to_be_patched = mm.get_torch_device() decode_module.device = compute_device_to_be_patched @@ -681,7 +675,7 @@ def INPUT_TYPES(s): "clip_vision": ("CLIP_VISION",), "load_device": ("MULTIGPUDEVICE",), "image_1": ("IMAGE", {"tooltip": "Image to encode"}), - "strength_1": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.001, "tooltip": "Additional clip embed multiplier"}), + "strength_1": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.001, "tooltip": "Additional clip embed multiplier"}), "strength_2": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.001, "tooltip": "Additional clip embed multiplier"}), "crop": (["center", "disabled"], {"default": "center", "tooltip": "Crop image to 224x224 before encoding"}), "combine_embeds": (["average", "sum", "concat", "batch"], {"default": "average", "tooltip": "Method to combine multiple clip embeds"}), @@ -741,7 +735,7 @@ def loadmodel(self, model, base_precision, load_device, quantization, device): from . import set_current_device set_current_device(device) - + original_loader = NODE_CLASS_MAPPINGS["WanVideoControlnetLoader"]() return original_loader.loadmodel(model, base_precision, load_device, quantization) @@ -768,7 +762,7 @@ def loadmodel(self, model, base_precision, device): from . import set_current_device set_current_device(device) - + original_loader = NODE_CLASS_MAPPINGS["FantasyTalkingModelLoader"]() return original_loader.loadmodel(model, base_precision) @@ -796,7 +790,7 @@ def loadmodel(self, model, base_precision, load_device, device): from . import set_current_device set_current_device(device) - + original_loader = NODE_CLASS_MAPPINGS["Wav2VecModelLoader"]() return original_loader.loadmodel(model, base_precision, load_device) @@ -829,7 +823,7 @@ def loadmodel(self, model, base_precision, load_device, device): from . import set_current_device set_current_device(device) - + original_loader = NODE_CLASS_MAPPINGS["DownloadAndLoadWav2VecModel"]() return original_loader.loadmodel(model, base_precision, load_device) @@ -864,6 +858,6 @@ def loadmodel(self, model, base_precision, load_device, device, quantization, at from . import set_current_device set_current_device(device) - + original_loader = NODE_CLASS_MAPPINGS["WanVideoUni3C_ControlnetLoader"]() return original_loader.loadmodel(model, base_precision, load_device, quantization, attention_mode, compile_args) diff --git a/wrappers.py b/wrappers.py index 304b85c..f3d36f4 100644 --- a/wrappers.py +++ b/wrappers.py @@ -18,8 +18,7 @@ def _create_distorch_safetensor_v2_override(cls, device_param_name, device_setter_func, apply_device_kwarg_workaround, eject_models_default=True): """Internal factory function creating DisTorch2 override class with parameterized device selection behavior.""" from .distorch_2 import register_patched_safetensor_modelpatcher - from .model_management_mgpu import force_full_system_cleanup - + class NodeOverrideDisTorchSafetensorV2(cls): @classmethod def INPUT_TYPES(s): @@ -83,7 +82,7 @@ def override(self, *args, virtual_vram_gb=4.0, donor_device="cpu", logger.mgpu_mm_log(f"[EJECT_MODELS_SETUP_COMPLETE] Marked {ejection_count} models for Comfy Core eviction during load_models_gpu") else: - logger.mgpu_mm_log(f"[EJECT_MODELS_SETUP] eject_models=False - loading without eviction") + logger.mgpu_mm_log("[EJECT_MODELS_SETUP] eject_models=False - loading without eviction") if device_value is not None: device_setter_func(device_value) @@ -93,7 +92,7 @@ def override(self, *args, virtual_vram_gb=4.0, donor_device="cpu", if k not in [device_param_name, 'virtual_vram_gb', 'donor_device', 'expert_mode_allocations', 'eject_models']} - + if apply_device_kwarg_workaround: clean_kwargs['device'] = 'default' @@ -106,10 +105,10 @@ def override(self, *args, virtual_vram_gb=4.0, donor_device="cpu", vram_string = device_value full_allocation = f"{expert_mode_allocations}#{vram_string}" if expert_mode_allocations or vram_string else "" - + fn = getattr(super(), cls.FUNCTION) out = fn(*args, **clean_kwargs) - + model_to_check = None if hasattr(out[0], 'model'): model_to_check = out[0] @@ -174,7 +173,7 @@ def override_class_with_distorch_gguf(cls): """DisTorch V1 Legacy wrapper - maintains V1 UI but calls V2 backend""" from . import set_current_device, get_current_device from .distorch_2 import register_patched_safetensor_modelpatcher - + class NodeOverrideDisTorchGGUFLegacy(cls): @classmethod def INPUT_TYPES(s): @@ -197,14 +196,14 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra original_device = get_current_device() if device is not None: set_current_device(device) - + # Strip MultiGPU-specific parameters before calling original function - clean_kwargs = {k: v for k, v in kwargs.items() - if k not in ['device', 'virtual_vram_gb', 'use_other_vram', + clean_kwargs = {k: v for k, v in kwargs.items() + if k not in ['device', 'virtual_vram_gb', 'use_other_vram', 'expert_mode_allocations']} - + register_patched_safetensor_modelpatcher() - + vram_string = "" if virtual_vram_gb > 0: if use_other_vram: @@ -217,7 +216,7 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra vram_string = f"{device};{virtual_vram_gb};cpu" full_allocation = f"{expert_mode_allocations}#{vram_string}" if expert_mode_allocations or vram_string else "" - + fn = getattr(super(), cls.FUNCTION) out = fn(*args, **clean_kwargs) @@ -226,7 +225,7 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra model_to_check = out[0] elif hasattr(out[0], 'patcher') and hasattr(out[0].patcher, 'model'): model_to_check = out[0].patcher - + if model_to_check and full_allocation: inner_model = model_to_check.model inner_model._distorch_v2_meta = {"full_allocation": full_allocation} @@ -242,14 +241,14 @@ def override_class_with_distorch_gguf_v2(cls): """DisTorch V2 wrapper for GGUF models""" from . import set_current_device, get_current_device from .distorch_2 import register_patched_safetensor_modelpatcher - + class NodeOverrideDisTorchGGUFv2(cls): @classmethod def INPUT_TYPES(s): inputs = copy.deepcopy(cls.INPUT_TYPES()) devices = get_device_list() compute_device = devices[1] if len(devices) > 1 else devices[0] - + inputs["optional"] = inputs.get("optional", {}) inputs["optional"]["compute_device"] = (devices, {"default": compute_device}) inputs["optional"]["virtual_vram_gb"] = ("FLOAT", {"default": 4.0, "min": 0.0, "max": 128.0, "step": 0.1}) @@ -265,14 +264,14 @@ def override(self, *args, compute_device=None, virtual_vram_gb=4.0, donor_device original_device = get_current_device() if compute_device is not None: set_current_device(compute_device) - + # Strip MultiGPU-specific parameters before calling original function - clean_kwargs = {k: v for k, v in kwargs.items() - if k not in ['compute_device', 'virtual_vram_gb', + clean_kwargs = {k: v for k, v in kwargs.items() + if k not in ['compute_device', 'virtual_vram_gb', 'donor_device', 'expert_mode_allocations']} - + register_patched_safetensor_modelpatcher() - + vram_string = "" if virtual_vram_gb > 0: vram_string = f"{compute_device};{virtual_vram_gb};{donor_device}" @@ -280,18 +279,18 @@ def override(self, *args, compute_device=None, virtual_vram_gb=4.0, donor_device vram_string = compute_device full_allocation = f"{expert_mode_allocations}#{vram_string}" if expert_mode_allocations or vram_string else "" - + logger.info(f"[MultiGPU DisTorch V2] Full allocation string: {full_allocation}") - + fn = getattr(super(), cls.FUNCTION) out = fn(*args, **clean_kwargs) - + model_to_check = None if hasattr(out[0], 'model'): model_to_check = out[0] elif hasattr(out[0], 'patcher') and hasattr(out[0].patcher, 'model'): model_to_check = out[0].patcher - + if model_to_check and full_allocation: inner_model = model_to_check.model inner_model._distorch_v2_meta = {"full_allocation": full_allocation} @@ -307,7 +306,7 @@ def override_class_with_distorch_clip(cls): """DisTorch V1 wrapper for CLIP models - calls V2 backend""" from . import set_current_text_encoder_device, get_current_text_encoder_device from .distorch_2 import register_patched_safetensor_modelpatcher - + class NodeOverrideDisTorchClip(cls): @classmethod def INPUT_TYPES(s): @@ -329,14 +328,14 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra original_text_device = get_current_text_encoder_device() if device is not None: set_current_text_encoder_device(device) - + # Strip MultiGPU-specific parameters before calling original function - clean_kwargs = {k: v for k, v in kwargs.items() - if k not in ['device', 'virtual_vram_gb', 'use_other_vram', + clean_kwargs = {k: v for k, v in kwargs.items() + if k not in ['device', 'virtual_vram_gb', 'use_other_vram', 'expert_mode_allocations']} - + register_patched_safetensor_modelpatcher() - + vram_string = "" if virtual_vram_gb > 0: if use_other_vram: @@ -349,16 +348,16 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra vram_string = f"{device};{virtual_vram_gb};cpu" full_allocation = f"{expert_mode_allocations}#{vram_string}" if expert_mode_allocations or vram_string else "" - + fn = getattr(super(), cls.FUNCTION) out = fn(*args, **clean_kwargs) - + model_to_check = None if hasattr(out[0], 'model'): model_to_check = out[0] elif hasattr(out[0], 'patcher') and hasattr(out[0].patcher, 'model'): model_to_check = out[0].patcher - + if model_to_check and full_allocation: inner_model = model_to_check.model inner_model._distorch_v2_meta = {"full_allocation": full_allocation} @@ -374,7 +373,7 @@ def override_class_with_distorch_clip_no_device(cls): """DisTorch V1 wrapper for Triple/Quad CLIP models - calls V2 backend""" from . import set_current_text_encoder_device, get_current_text_encoder_device from .distorch_2 import register_patched_safetensor_modelpatcher - + class NodeOverrideDisTorchClipNoDevice(cls): @classmethod def INPUT_TYPES(s): @@ -396,14 +395,14 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra original_text_device = get_current_text_encoder_device() if device is not None: set_current_text_encoder_device(device) - + # Strip MultiGPU-specific parameters before calling original function - clean_kwargs = {k: v for k, v in kwargs.items() - if k not in ['device', 'virtual_vram_gb', 'use_other_vram', + clean_kwargs = {k: v for k, v in kwargs.items() + if k not in ['device', 'virtual_vram_gb', 'use_other_vram', 'expert_mode_allocations']} - + register_patched_safetensor_modelpatcher() - + vram_string = "" if virtual_vram_gb > 0: if use_other_vram: @@ -416,16 +415,16 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra vram_string = f"{device};{virtual_vram_gb};cpu" full_allocation = f"{expert_mode_allocations}#{vram_string}" if expert_mode_allocations or vram_string else "" - + fn = getattr(super(), cls.FUNCTION) out = fn(*args, **clean_kwargs) - + model_to_check = None if hasattr(out[0], 'model'): model_to_check = out[0] elif hasattr(out[0], 'patcher') and hasattr(out[0].patcher, 'model'): model_to_check = out[0].patcher - + if model_to_check and full_allocation: inner_model = model_to_check.model inner_model._distorch_v2_meta = {"full_allocation": full_allocation} @@ -448,7 +447,7 @@ def override(self, *args, device=None, expert_mode_allocations="", use_other_vra def override_class(cls): """Standard MultiGPU device override for UNet/VAE models""" from . import set_current_device, get_current_device, cuda_device_guard - + class NodeOverride(cls): @classmethod def INPUT_TYPES(s): @@ -485,7 +484,7 @@ def override_class_offload(cls): get_current_unet_offload_device, cuda_device_guard, ) - + class NodeOverride(cls): @classmethod def INPUT_TYPES(s): @@ -523,7 +522,7 @@ def override(self, *args, device=None, offload_device=None, **kwargs): def override_class_clip(cls): """Standard MultiGPU device override for CLIP models (with device kwarg workaround)""" from . import set_current_text_encoder_device, get_current_text_encoder_device - + class NodeOverride(cls): @classmethod def INPUT_TYPES(s): @@ -555,7 +554,7 @@ def override(self, *args, device=None, **kwargs): def override_class_clip_no_device(cls): """Standard MultiGPU device override for Triple/Quad CLIP models (no device kwarg workaround)""" from . import set_current_text_encoder_device, get_current_text_encoder_device - + class NodeOverride(cls): @classmethod def INPUT_TYPES(s): From 2aaa033f7009b41e73c21df70ea0358a9d0711eb Mon Sep 17 00:00:00 2001 From: John Pollock Date: Fri, 6 Mar 2026 07:50:22 -0600 Subject: [PATCH 4/6] feat: add starter workflow for MultiGPU setup with detailed instructions, fix checkpoint loading. --- checkpoint_multigpu.py | 52 +- .../ComfyUI-starter_multigpu.jpg | Bin 0 -> 244575 bytes .../ComfyUI-starter_multigpu.json | 743 ++++++++++++++++++ 3 files changed, 779 insertions(+), 16 deletions(-) create mode 100755 example_workflows/ComfyUI-starter_multigpu.jpg create mode 100755 example_workflows/ComfyUI-starter_multigpu.json diff --git a/checkpoint_multigpu.py b/checkpoint_multigpu.py index 15b2a8f..b42b453 100644 --- a/checkpoint_multigpu.py +++ b/checkpoint_multigpu.py @@ -32,7 +32,7 @@ def patch_load_state_dict_guess_config(): def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_clipvision=False, embedding_directory=None, output_model=True, model_options={}, - te_model_options={}, metadata=None): + te_model_options={}, metadata=None, disable_dynamic=False): """Patched checkpoint loader with MultiGPU and DisTorch2 device placement support.""" from . import set_current_device, set_current_text_encoder_device, get_current_device, get_current_text_encoder_device @@ -42,7 +42,18 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, distorch_config = checkpoint_distorch_config.get(config_hash) if not device_config and not distorch_config: - return original_load_state_dict_guess_config(sd, output_vae, output_clip, output_clipvision, embedding_directory, output_model, model_options, te_model_options, metadata) + return original_load_state_dict_guess_config( + sd, + output_vae=output_vae, + output_clip=output_clip, + output_clipvision=output_clipvision, + embedding_directory=embedding_directory, + output_model=output_model, + model_options=model_options, + te_model_options=te_model_options, + metadata=metadata, + disable_dynamic=disable_dynamic, + ) logger.debug("[MultiGPU Checkpoint] ENTERING Patched Checkpoint Loader") logger.debug(f"[MultiGPU Checkpoint] Received Device Config: {device_config}") @@ -73,7 +84,12 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, logger.warning("[MultiGPU] Warning: Not a standard checkpoint file. Trying to load as diffusion model only.") # Simplified fallback for non-checkpoints set_current_device(device_config.get('unet_device', original_main_device)) - diffusion_model = comfy.sd.load_diffusion_model_state_dict(sd, model_options={}) + diffusion_model = comfy.sd.load_diffusion_model_state_dict( + sd, + model_options={}, + metadata=metadata, + disable_dynamic=disable_dynamic, + ) if diffusion_model is None: return None return (diffusion_model, None, VAE(sd={}), None) @@ -90,11 +106,11 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, if unet_dtype is None: unet_dtype = mm.unet_dtype(model_params=parameters, supported_dtypes=unet_weight_dtype, weight_dtype=weight_dtype) - unet_compute_device = device_config.get('unet_device', original_main_device) + unet_compute_device = torch.device(device_config.get('unet_device', original_main_device)) if model_config.scaled_fp8 is not None: - manual_cast_dtype = mm.unet_manual_cast(None, torch.device(unet_compute_device), model_config.supported_inference_dtypes) + manual_cast_dtype = mm.unet_manual_cast(None, unet_compute_device, model_config.supported_inference_dtypes) else: - manual_cast_dtype = mm.unet_manual_cast(unet_dtype, torch.device(unet_compute_device), model_config.supported_inference_dtypes) + manual_cast_dtype = mm.unet_manual_cast(unet_dtype, unet_compute_device, model_config.supported_inference_dtypes) model_config.set_inference_dtype(unet_dtype, manual_cast_dtype) logger.info(f"UNet DType: {unet_dtype}, Manual Cast: {manual_cast_dtype}") @@ -103,19 +119,20 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, clipvision = comfy.clip_vision.load_clipvision_from_sd(sd, model_config.clip_vision_prefix, True) if output_model: - unet_compute_device = device_config.get('unet_device', original_main_device) + unet_compute_device = torch.device(device_config.get('unet_device', original_main_device)) set_current_device(unet_compute_device) inital_load_device = mm.unet_inital_load_device(parameters, unet_dtype) multigpu_memory_log(f"unet:{config_hash[:8]}", "pre-load") model = model_config.get_model(sd, diffusion_model_prefix, device=inital_load_device) - model.load_model_weights(sd, diffusion_model_prefix) + model_patcher_class = comfy.model_patcher.ModelPatcher if disable_dynamic else comfy.model_patcher.CoreModelPatcher + model_patcher = model_patcher_class(model, load_device=unet_compute_device, offload_device=mm.unet_offload_device()) + model.load_model_weights(sd, diffusion_model_prefix, assign=model_patcher.is_dynamic()) multigpu_memory_log(f"unet:{config_hash[:8]}", "post-weights") logger.mgpu_mm_log("Invoking soft_empty_cache_multigpu before UNet ModelPatcher setup") soft_empty_cache_multigpu() - model_patcher = comfy.model_patcher.ModelPatcher(model, load_device=unet_compute_device, offload_device=mm.unet_offload_device()) multigpu_memory_log(f"unet:{config_hash[:8]}", "post-model") if distorch_config and 'unet_allocation' in distorch_config: @@ -159,7 +176,7 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, out_sd[k] = quant_sd[k] sd = out_sd - clip_target_device = device_config.get('clip_device', original_clip_device) + clip_target_device = torch.device(device_config.get('clip_device', original_clip_device)) set_current_text_encoder_device(clip_target_device) clip_target = model_config.clip_target(state_dict=sd) @@ -170,7 +187,15 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, multigpu_memory_log(f"clip:{config_hash[:8]}", "pre-load") soft_empty_cache_multigpu() clip_params = comfy.utils.calculate_parameters(clip_sd) - clip = CLIP(clip_target, embedding_directory=embedding_directory, tokenizer_data=clip_sd, parameters=clip_params, model_options=te_model_options) + clip = CLIP( + clip_target, + embedding_directory=embedding_directory, + tokenizer_data=clip_sd, + parameters=clip_params, + state_dict=clip_sd, + model_options=te_model_options, + disable_dynamic=disable_dynamic, + ) if distorch_config and 'clip_allocation' in distorch_config: clip_alloc = distorch_config['clip_allocation'] @@ -181,11 +206,6 @@ def patched_load_state_dict_guess_config(sd, output_vae=True, output_clip=True, logger.info(f"[CHECKPOINT_META] CLIP inner_model id=0x{id(inner_clip):x}") clip.patcher.model._distorch_high_precision_loras = distorch_config.get('high_precision_loras', True) - m, u = clip.load_sd(clip_sd, full_model=True) # This respects the patched text_encoder_device - if len(m) > 0: - logger.warning(f"CLIP missing keys: {m}") - if len(u) > 0: - logger.debug(f"CLIP unexpected keys: {u}") logger.info("CLIP Loaded.") multigpu_memory_log(f"clip:{config_hash[:8]}", "post-load") else: diff --git a/example_workflows/ComfyUI-starter_multigpu.jpg b/example_workflows/ComfyUI-starter_multigpu.jpg new file mode 100755 index 0000000000000000000000000000000000000000..24d95a62b5820da97dbd4cd5fa8cb3658751c5a7 GIT binary patch literal 244575 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 z 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 >acS~s9Mbk5!P$7btDpYlYKGg0*zfvm zok>UYbfsQ&;Yjof0l~Ye1XpL@odzpZ#mowA1C8DgRhT@z@EMdz5u?wv?$_{ldNZIn z>ANy;Sr*aY3?7pqH@6rNEsEqwrY9|E8Vo}Wu9|{j6eFT1(&G6=0$k>KNLYlxr5~cs zxF10l!SCY6{Pu?X5TbP*J%|$fj<@Ean_cXhZKh7*60}Q_Z~#s4xQzA2fQ*EB{G$-* zD*t&&qDG>bYWHR4^FF;(pFi^JbKhv4Qj-vlJreLu!|9$$t*x-7+l*Ike&ude$nYvr zD8<6Cx>c-?s~h$`zJ4qOGc(=ESG;s=>}oK}jXYP%Pa#Z82OvYUx zZ=CX&lUMkx=_9r#fOodgu;|T+Yy59iYN7hk9p&^Tli)>pA^A|RRajf8C0(Kgv-EjV zyexPNMu`=hb-!=aTFwRj5@^{J8O0`vA5WC&(T5;qJQwBNR70Qie2PsDL$)iO+t`}x zL+K=A%l7`VU$6Y6$D#y*t>0cq3eNI)%jNQR4?r$?H@P>9)Gc}$Dea)$eZcTGRD2z^CV9C8J zFQ@y9J=m|FSY*j7b9PKl(H_T8{wvFljI{q+_*X*47jTG>g#MIc#i#=*yz>m!8638m z?d^b}&%Lpa*pOAx2F=qMwRyV+sxQ5tsqy=#TNfWBIBl20Y2h$Nz1epPHzT%;Ef?2&pPB;nS-n zFq%e{E!!hVM$!3arb@`vm2uJ{3J)@@!K&Ut)*XOKiaTd|p2lb`_(9JZ)P4fKAfs5i z@{iS)f0JfIDZ{RMEhQF$_M7crtzV5AE!>>v_c~Ffn_+IJi-TWE;C+U2N(>gMro3;| zjrcXPpo{~8vMqY{f7}j7dF5TsbtN)}b7`l`cMhZv0#ORm3}Q3gs~VB!5BhCu$YVyF z4D8NqX3>o_hmW&X$qKw@K45jfKP>eQ`2y*cDw@3_eKGV>mz8~?jX(kr=Eg0~YxI6q zQ$@Vv_gC$?KGlBNuBxH+C#~xV6yBw#-nHr}I+HXsr1xDaGE-tL4Zg=ZVqGrjZ~{{z zBSw8Migyys@3MbuIG;M$1#M?hb{_b7juJcaitAkEMEQ?!C@Vyl4cG5a4cB?ZzddU0 zJl5w5x6KiZEchNQXyVj^_Zt%LH{7In=fO4GS}XwH#6JC@z8?6dblO^wbhPQ;>_?v0Upidoqg7LWw0L?Ljpj;K>o!{k{OU{zXbi9nQiIkm|7wr8Izr)Wr z_n(b;-S6v#{y~Jm3F?I z!M?9hQd+3qPh5z-O;1bM15cur?GXvR-*R(|4XtNZ?_HqQA;DL){AbF}oEfqdL_>f- zkkRJ3i`F<*xS?#J{9ugR)31sSU2(pimA2q@Ac1X*jAy?=G3(1J_%G=wiGH6Ok1C_} z{@N$d&G5EccF$^Cq^k43oL3~F*2#WJDq)-I9?y1nsMhr<-;)Q0ukIl3-<67LLB0Eq zrXXUfS4=)6MWy!x1WkL8#7a6Yh4PefE4DYU5a;*Wzu-x#gs<%!I5HuvjI{G-U2T7ztx#&bv+s2b^2n1@6(!a*K> zd9=5N2S__p?pglbc#AhJicS*5whJ+d6t|1z+m9SUS7$(^*}Kb~ju1?J`GHh?Z7GO! zh&OUOZ3RqPrpv&d(rNFD7G3u}$^y@|&6us*viB?|o%MH;t=FDEQ8XL7r9|5$OxNrc zj{|IfuD7pvA`0+@RfwknDI5It4X5eo6@y2YEM5tB_uAby6!N}J*AH153(K@BR=Fyk zL(}m-PZxJkR3KBU)k4y8KjSXO;Mi#_>y~TtLB@QWwiOYxD;uPg4mb#tt328G+*-I% ztHjgnhdY7^uL0v5x<`$|ZCJfDn|8l#;rCiE&eEdMj|tC>aQDD_3Gt0mRT<=I z{kbmue|6Y}L=@>4=8SRo+W6a?HrR70D@*~mc0v7Bo;&RcT(8~A-bvKiVT@PpXcHIT zQ%xY)9_Z>xa!qtZOksCf2p=$SMR+C;AhwVTWwM4LrAazwY6r^LsSBos5jprX0Ybah062>gfyZR(q`z z6u>uOGWadb`E};w2M}TglXePY59n_>KI5t=B=}>4j8Dlh+boIEP4xBoS~!F%afF@J zhGxUYd?d#{GVq(PxadU?T!W&oa^KJ@jkCPOHnGqCU!@-}{JddI@=+&YoyVo<<_@_k zt@`tYtJ{QMgWM`wWfJ@jPQBPeR6Ts*Qkfy88F5}^t`o2jE)_-?#1egh54)^B#;UCy zYxCwRs(Vec`}dR?Jrk|iyo=K3(O?pWXz~t~D9erYe`L9O9@tzp{CTqEr1iI#e0FI2 zHkb+8UZrVQ}UtWjh zWRnj#uhWE!1|JJVdr3^6fPe@5=IZT3$w6qt>z(UzdD*0J9#r>Kh9BGRYRv2*qp#ib zd&O-T?0&UkK-829G9f~2S9j)^h0QD1xm061nClX%iCOl`)joMJx(HTUBZ9I}1g-155mgWP38)q4_ZUgCIHG$+{{gCk1+;NRkzNh###3Rg&o7+bD&Zx6spU)TV zonBqYzZ<)&;?QC>bn^yI43<8#BN{bG`yiX?MxXEXid#4V#Bc%CO7HQb`8M*ww|BI@ z=YlvitK!605GS*k$i!K_ngJ*LX-{-!1q^c&@O+*k$s^}m9ev_Q+&}Ub?(*k6$?0CV^m#C_ z3>qc#g|kxjqC^Arpgx*1E?McHA|3;)>kpn;t`Lx1A`ao0{0|9~GdEE7Lsoe@s*U8p>2ZQ@T)+$@$RjDG;y(yUOS#aOu7SkkCO4t zZ6XZy@`PCCgy06-B7;uxmy22j&H~%_pe8i8S@9!3z3BwUyZAaS4;1D5faa%zR=|(i zs}t?#njfn-7mAPsh?0j!xr!Ji7-6(I|tc=2luM3zc+1YFH!|Dil97p`U^sqSZ(Ym)5UK z9&8>~7X*%=m2*V5`;UA>*c#97!6dOhZZOUEpKC~PXLswZVeb5~QJPlC0x)yax98+N zVkPl^35{933ni;$YL+xMF5-l&QoF*(6!z)BN(YQD8x@-moy;Zlwc$wK&;)Ubzxd?T zf!5!pZJ(hRcW+Q>E&Ha=k%3vXHjTBqy!#CzhFA=Sw&XW-!$E5Nb9LU1M0I@gS72pe zFxC-9Gsz8bo#|J8BXJ45<=5v;Gx*3X#(~=?82}JqHR2s~jG7XaAND8ZIA##1>VPIT&l+copY}eN#7Cb;2p;Y9h#@ z6?*W?wTDSA?NTM9bTq+mPn&=3__@ERO{{F42YeiB-h(2bE)2d<@2eXHgIez2n*U$+j{zZL$ zk^|c(k`*+KSbub-`iMxflC|pcO~u{hg&SIV_98b(bE--N&u{#)_i$mXb--2x(Uwd_ zCN1`m6ws+piaOMa=Vu*LB8w9Kx5f9JLi6Ec;xTkp4_dBHO}NvPXKKlw#as#ykE_Qh#rM$)-twp-XMsF**hY}tq*eJ;Zrp;5ZGkQUeU()eEN;~97oBuD+jxKoBm%g zw%@ZETq*9P@YboCDeDbH_nBmEJ>H&%|3z(p&(njVvvM?=>;$e!-lN>~`vaGhuC#E} z^`CyHnxx|WR^hrR{@c3$T>v2k@C`f+Xf%9u5jBYic|;Wf=;Uai*cKx~yv>0Oh&IG- z1;u0~9(tr)P>rM9v<`Pq&~rR``l=PHD*{eY{}Di(Zxbe{F+Iqn>TK|*+d0^O1kd#C zaWYu3G1VmlK27Dis&Dn~>>luC=twIt+Dku$$6+hy`5cK{$*=#H7_-H4DeahL$1jeD z!`5q~!Sg>(=(nj9I|nw@=km7=JSvJt_H_H2&lOUs+bS&mT~Sn7{mm}C4Hmg8UWjr* z;M8m`#_V55?8Q#I%F57sMsF0X<`>GeyZ~Id9fCj73u$O0YFY|~-=$zb=J?*|Sl#9L z`>e};B+j@edUDNN(;CLaRz-jbrNoQ^5N za4a>WAbPFUoydfp`mVz~vPrC(H^-ER<(OH+?(w9&DZBMcg58rU4bPVW;Blap15FT_ z21op_8pEa4FA=vKy-rl+bys=>=jq3zyfK(&;l1(=HKt0|R%H&&YV|MrEN4Y&mNFKb zIo9+KoA<;SKkWB-S^3Oi6h6PwFDuXoZTU>$zwExgopL68ebPADIY5Y^Ii^Us#H%13l7*%uMJm5 zU$Wiuk(mj-MCh5i4M^g0^c%h3>pB>|p;4Pz=)HF^?bfRUPje?mVxwm(rF1_Vy0%=% z45sMlYt<@(ZolpC8e{y{mrX^N{!~>c-r7_V<0Pi>3B$K~$7gTcK&7>|swmzy2V82P zUn`%CIlWWLm|s2~mK2WT@+X{eSLST4o)UpRoeveJ9Y2||HP=d3?dmNL7EqhnlR2d$$~NPNqdXOirf?sD7!mQVc-0GexB4{o)tTZ36!UlP9+TCCB9)*@ zACKFl7uP=86r#)!&%t2|uKTkswb99eXNqKhU81J}^4_eZAR4gd{tf@~ao?hU*NX>? zPul(uI6=q0=Dx)Jl{8r*)KJ`K?H2a(O5uhuPs@+|dcFhrMXKLeYf@cVUCC!M#kYJX zX~8`+_*dwc?8NVF;qMS?a}x4Frh?A=@D<**e3H%E{)WC+_nbR9#0@+ zfsxep?dxA1r%AN?WO)j-uPlQO6!il+KaF^Yf;5=s@pX!Zc7HID`{itKdjU#?6==4P zjHJEE&imZ@=fIj&R;^`YY#YlhZWS2hjo}!MgQ0U-{{Xkvq^+rF)`)N+v}Ysz=Oh0B zWv;j34Y1*fw??Dqc<$;E(%RY>zY@E@_G<8P+TvoLM9)Vr zR>Rbnc9HQuqb6=&>t2=cg7()&f%OTke$zRW#}?!AD*&VtJN2(Q7ISJB!V7pLo@YNS zaj9lMKr7Sy72)fsv^xZvC$^4TnMr3DB#nT9@5k$2wpAAD{EwigE=rN*-5+#*%8hZU z_<`@QAI+64WR$mH4$wcHdEds3V&WNY=C{8#61?(1oFy@ygSh&d^$*#e%lkV;@io$d z65me|AR$xnn^Q^eFDGlOgtKNcvB_pQ1n2$)Ys$3^Qu=Fx zhV`W!=N5~B`3mBGiS$Y2e$1CUZtR5E@>Q%*cZr47lm0xD5P*UYe zD*mU}o*(_G^*DuOa&|lG+#fBP4IZU^!qm=ddT&jNN<3{vXwK3ucz~ z{90MYuv^<(MyLXVo>;depJ87>vV6KT=5|r@>V2jfSSomBIov^(aChe5BcVpRblQ22lcGIrdfhdmI_k8O_!0w ziN;2xn!{4E?$1f_uf_deUX{(o`^v0&g&PV7ryPD&<@eg%#o5fQl6mV{Uv4dsTB?~i z2X{YO@Nrp$u^KHGWO(tRXL)MNx`oqADzkND1M=hgRa}xf)C}c_$;cf!r3^tMwRtX0 zoiUBHX5WXS`%bB8ANQnD`q!;!`c2lOtm;!JjqO>PA9G_rHvo6^uQKoqOD~A+0U6}C z;stsZiSaqSF=EF}vsg7*1nmfLm21Yy^7i&D?!?L-sr!OHRTo%dAE=!_nZ&by@v8XCrh$H)!m$r z#1HYWy5V>w?Iv+!CCwPe%V?PjYoGWrt+n67-w;~d$LA%z?WN2N$L>Fx zsz~~yIIjZAH^>4d9e?=Z%r{X8a`nZHZ{Rkh>*IV&E zbEN*xH$b=id~8Ag00NtL@~&dVKsxK3gEhz;_xX)!{?xa_MEEbEY2~)O%p9-#k@Nbn zuO}NXek;uB$s*#bKGA=RKQ?|LU758BTRddfoL-FXJ&kt0FrUu6lN~o2;%^RA`&Si9 zZhig&EmKI3Nzvui=DA3oG%&#PpE0qJypTQXF^CFBtxqRh)n>*pD~qkqql!*89c=q% z8@}lqNT_CAj8o9!l~kAO?ki#q3QP1CZtH7k2hTK~zQes~1m&@`7N&GDNp}K68X08| zfT}WiAO5Em^Isj+?_5ZE~|l?TxLuN1#22`R`YCcsD^CkKk;62mFe_@YTnWs>ZGN zWd#q{x9eSn)B;;+Qyi5zubiy?jwwv{C_Z`)EaRRb0o*~rB~Q@PW3{(c^RB04a&hIL z%QwHb_l#mZB`-}vNHq+EdK0!e?My8v(zrlg6g_y!`n8?h!kW;gt+^vI2d2nqbNkLyIb0QE%2dU?$^6OVtyds=I$t7d;B6Awr&jgFH zgk&aroN>)~cZ=*T{6VZ~X*Ib+h7xT%OB{~l{PS8~4e=(rXS32{nrQB%ki_;kv6fX_ zbs6V@ob;^SQ{o4P?tDRY4Blp&J+r(iDvj_-f_`sR${ zI+4NVl({z5tE;1~@X|u}!XgO>hYA5XP(ffn;34>~!r~N|N9L86cs^X+5=A2i4emI` zLHv68^|iysmbX@NERLsiS8%>nkNM)Z+r;alCDqQQX7+&m&SNTLe^LM-Wd1ejQ=Fi= zTGac@_bY}zaK_P^+N0<@o&o1d{1R>7teF$1Z7`R z#{=tvKQUS!D){GRYv)I!S<5BEe=$XfyEf|9dX##M9X8y7yXn10^HW$J zCqR~eWs2HeHtOz0gsL1y`;R|#?L24Sj@935v-wtYv|Ika$dALX9-ZNHcP=1_mF{16 z8v)CHKz}Oy=lHSWIebUroksRU^IcBU{Q)Nf@UOkTIcrPdZ-siU!Xq+3En@?Zzw(ej z;5o0(KM>q`*YYqq1B&LxPRhsIaGo39saxb>&TvgXNrTP3R>pSofl*G_&wAJJ%0~=y z+{=JM;Q{Vz!kfCfKV8E?N=oDBJEUSqTCT$;z4PK%gMJce-wk5aJTu~{bw3p!BsHg+ z3~WgPL$}KXa56?uY;#^2aFHv*sgafW$vyIarYnYpby+z@Th#XJVciy!mF`tkBQ)e( zkSks-56#f$)I`V@H`(Qr^B$k$RBSCIy}X9rCEYBpBSGp(z#pw|&8EE!y_}Hb+=_5< zQ`>UFyPt`F2K9f1*48s>S5}t^c1ow&orwehPC*0KxSMtPht{r*NYq@>*yP2<()VYh zHnhC%U#)!s`#*Sn_5T1E=+LC$f3ul!-rFMKO7lE5c~qmb$U0A>xgVlcazPxr9kj(u`^)|9=ZpsCVV zT3_?AjHpI+XNauq^|z+iXUg6Zw~t!!r`jb9)3mK2IpB3YKEKkwyYSV|_7B4!5^8L? zV+lm#obBKb#en=P%Iy9b*;(De;tvkqTkBpQyUs4-P?JHyK3s{|^ydSoA#wrqAB$Iw z;V*-FUzA=sE?eyk$-x)}hw97uSF?(gF;b&W9b}iMsd*L-bgRqSExPwUGWe$`yPa;V zt{F`0x=VQ*aYo7LPjB;@@~vc>OB-~~9f^?sCm;JQcOEJ6TzdP>7P5+N4oo-js7V#O zESTZJ>67ye=OhiMf$^J&bpZfv-c}>et_Bb5n){s2q@jZLZ2C;nbmpSzv!?iUs6CdY z9P9Vc?jKtH7WkXxO%)cCTndR`!+gsYL)RA8t#OlqJ zWe1E9bN>L>ub%AmJK1hm9vbsWKX=NT2l6%bZ^fM+d)+GjC}nGQkzSD$}k4vjBE`3^r8rBOUhXyK!`UqkG&j3b04ikHjO z`S;@oj!vl8ZqgGx&eBTc@>un+pP-HPeN$&76OwDA@m{koqpLYG6Ouv4Lr~gjKVi|N znlYQZrz;u`qA~ZI^T7WAzP&5zeVk~=m28hfqUqI|9v^7#wSNJp#c{fS_0JB%YKMyq5z1J-vR3)B8LG>pBze9c}vgy{k7Mz?#Z5cQo ziWNumuae9vy47jHcP6xcuZ5{DwzuAVrSVfyn(xMUvq0B=Tt~@YvED@kVL)E5*QaXZ zz45K!W#QZRQV~zc1O%nqSZ9dp#BKhO*Qt571x<0(_Wxsa8$VfG32NNw{L3Q{iXHI zA|Ddn!GCdbf*6t}XjNQCkO(_T8@X2w`4MVyjk{>l<0Qj_1y zcVMUe+z<9eV%T3v0_qbf!E|WPxFedSW-}=I)nmCim6oSUsZwdFy$`IvV*MCj{6Vyo zugh(3EXVO(qyGRxuXyq0(74pK6T2nv1S8x6qyGS9uQL6HtcUj2vp?}eV7UBTAL(7E zi5tyJyNsXQwan-K0~SZ>1$gvgrHOt?9#&z0t41rUXUo4ByhLKYzPpI!rMkjro&h-h z0Is9t6CQgPpw zKhC}i@f32MQ&5sY^KWGzfyI7?>6UHc?*bhmS}~|uNxCrnuHbUNfd_-{?O!Q;S@=(T zYpvZ)9ig<5n{@WfF}06YUsWe3j-9eOuanB^LX@XUZ(FmsF{dd)Gm6n9kBq!RjXt$@ z-E#X!;m7o->~zT_bpdmp)#-!bcA;^4;o)U+0Fhsy{uA(| zUkAP&jUom^tX~b%x_=KG^XQ9MWH0n>3r{G8ATJ9hc?K(e3$@T(s%S6D4Ktuf*ZSVjd1Rf5eu{vFCpq zyj!MO#P(NLQ^yeihqge?-<&ZX-<5pVJ+Ff9ZW+zywIh;FOmPqETb~j2_3^l$9-rRk8#Ec$a? zGAd-P%BUcdfr1Io-aUs(`g7w&;m|$_=(hRVWyFMf{EXks*MWQl@aOhknRLPY-!e$z z4U7VQZU-j4fA+l8hMnP^Cr(l^6_dUPY^YKH0HD{MkF`uq2wScG{$E|ZZOEmZS&jj&WdfDAI)Skwh;QJ#sqXtJA0|uTh)3Q3@bxz0Mf3a?z z{h#5l66#Jdwm6eNgR%br&_#LY$BjqH(=20PSjev-{7ri=z&kOb`~=mmm*tY?;g>$a z5D(P1=Uxx{L0qCIoI^ z{{R4Nw_9D@n94ASC?3TB0QIZH+T%;KnJ#w-@K zK#|3|BOGbb5SAGC?O#pH`?*W96?zFqF;8>dziG)vkMOI)I%=JyTbUVs)-@UY*w^Pz zjU_Jy+_)!mZ58@U`%-v%e-Oc?M*<(SizY~1ecj~r{RMt}`2PUG`i7TlJ+;lGkxv_) z=*n`xQC~HJ*9_lXPeQv(6q4y>_#PLk@#U{ScOtqC157(2clpZzdFHY;hzPh$j9_BA zEd}lgi2xp0?~34Yvuz%mYn1wv_Dj%y*YPvMYmDOQWh2=>Z~d0OnEj!(96_yM^Bi&8 z{$ywW0A{Zq{f6}6aq$M$c3hiVNu}xBuHXHhyWiReR>h93B86sq^TTooP}RN}b7Gg0 zJRE2HzpTF`d|BdIoa=KS3&8`L^*@1Dqs?bvt-j_I810SBe~_;=*ZfazH7O*UM$_eN z@$<*D`D>Yvot=Klc385&FL=I0MPe=}dB+Pp8V{>~6wSg)L@-gL2!pe(09 zksqae4e?9Cw>OteQZmY1up`{(AFX_*8&y}m&sMy>lc5K)Nco!f*_v_%I^N!3kH2#^ z-J^Fn8R$P+^=nUs_gA-A@`~rV73q3E?2qEDZ$P-!Y&46jn`mP$W!bPWAKcF_eU~-M zI!Qao^y7?Q40S$Yv$rWJIPG4I;Cohki+m2^vh|M*HkErUEW25FAoUg2_yWue%WzNe zbfH4bDpXQ}XXqEen?a@g0@NiSt6g0<y6{!L#${?J;~aO=r!EOE+_TSlYzj;;4| z+v{IW_+rI0zuEi4@bqhz^AEmV+xiOmPvdEZ{{Y20gll(i49Ou!TZK`8I2bGsr?q<7 zGIT`)DsMY}FzW`S+1VR52s( zu6msM*UQ>=l`NWrc~ZeBL(3y8arjr*U$b3~AH%_RlGlOGIO+cY>aTAU?S`C=c~f(% z2zjG3_UP1$>z4Mw@dc6r>{;0V0EK>j>v5L4d;`g^w!dvl$*#PAt44!xghdFz^o@V1 zHS*8HeLGFR_^si{JVwbDh4#gg`R5PncuZ9B-=TB^Z=oqZaPZxg979S8VFQl8pG3m1D z@Wl}O0eJkt@)tWqXKBGqk_LF|jy^m4ZgG?4rz7-l>?$%^)JNyd_3ZEvTrgj)P;F`P zfLkA0`p5Rs@h8FUYrz^id^)($<<*9u4C70K%6})zf4%aKH*NhZ=1&87Ye?79^ZQd; zwbEvf9!R;BQD3fe&u%?B*R6%j>Q<%gC3v27e4-TU`#N@JB5N|V$r~0>Pjk&aElO8* zUF3xXoSK)$dJVsab&Ex^)T}i~7y@OnxDo|9hGK*CuM>ts z8yT+e;pUh%?QYV;&Vt|1V7_(Cfg?|LW7@r16*--xaaY5}*Rl6!!VehR+TD0_QER83 z?eOzW^D?<34yD_v!9R_6-?S%(1ov;KLOxr|aKXUia^Qpd56--1-%!(hE#Pe*OHFzm zb?v5TUF{)Z6|rxbaQtNCH&x_r!5HW0j}G3)@mJwIO2f?5tP^7?>cvO?%)hQ{Y-ANT zOBn_3?9DSw1w2LtMvt$}ADiD2Y^KosLp(}`5UtR9XOGgoGvJqv*Ak>d{yD3&~O|Y*F(bAp zvG`ScyKuK8p1@TqEi-vy;U%Lh{3WsTujT{zfEfJi^k?AhzxH3j-xk~vhB2%F{SzPi zJ$#Gszu}eTj-d>XXk+<-#?T96wkz#F?8$r~@G597(A(W=H!FyrhQTAK{{VFfuAEfj z=thEi$*;`w=r>ZduN~ia}%7EHTo&^WmnAVQJ#n zCbYep@rx!;AZbw3cqBDI15 zeqG5H*7>;VN%gO;rA0;x=Z6|{jTdx%h42Q*pA%_8y2WhHbLvz70J1gn2kncho8O6k zB~^Tg?!3SIbZNx!+%Z{azL>e5zz z{4UB5Z{i(m>rVi9SK({g*uB1`;$1@G6#df81*{3za0GdbdXv*N^jS@)w^DI$PKxKh zhmSp5sNToX-vwi94~3p8yC8z`l?Uk`__ci1@kdv+v%gs7yS;)>ED|k*c*alnxv#4< z0xkXuYS$Rq_N$PiaOW98{SADL@mo@|vDcrf|pa# zziVsbru;eZeSqUAWng`gNB+)h;5~OycedC9-glS~&n7#en{m z@Mf(i@0|OZ{QCW=(medAxlpL7`&F^E;5ONxBfb7P7NRTR<|-Z3nMbBV+SDQ{{S&r-w(F7 zutRh)Fz4K3`q#2}4_xrBhv6vhwP|kd^(beW81$$nXwktDo$_FUMtH_~+I{QwESXya zbsN5Ikr)gWJXL8aNi8>Lvi{3gX46>GWOK9$j3@pCq<=OQ-2Ty;1lL-gzikw4ESEOx zDk6-N+mFh;v*BNi=GJwDy0+7!v$KuAcDAtvjT?dqBfkT!eIfCQ6I0N1pAp2Ej%a*| zw)G0*`W%nOzF#<`=;kn!R_4(8y#D|%_E>4EPUE^cHSNCyH2p~1>Q+}4mnioTe(1bR2J{7&oM3bV@vk5FiQ-LHM)5_?pK&a|=+1WK zj~?Unt*-%mN7t@(I|FTfENmnMv$?>*$8Js#?!rv(V>n_$G%k!^-elPqyy711Wdtq@I`$d$k6a2kEJTUen2l20` zd==w}bZu50M@e+@Wpg5hI6`_lbK9Ohh_6%e*Tc;d_J#2CURa21{6PwBB46Sd`;L0! zJsTd_>t6|s!_Ng;UeY#;{2A%OjY!AX&3^KqPV310tk!gfgrj_{7-u83Vohjs)AX;U zej)q;*E}PCEvBQV&1}G(o7XDC)mU&xxF)>Pe~0%_&52?mbHT@2g-K6XyPYw{!V$Ec zpP9q>Yf6&yShqwO+S`xeUgf6fcEVd*jX`7(MF!|qK>g&Kjt4!n*Z%;oQuqVmR922J zZxP~vj1~jtVd%N7t-Zdn}0_UB~c**L1?oLmjA8nUPo(Bxv z-LJXl&mT^;SjIZo@Xupu$kiQoZWU}{js@U!7R_Gg$5r+<}Ty-9Dq z_yNb`RQw^}T^Hc~k~JMo*5gtj>_zA1^ik{Y+uNM^hs0lrCsNjJZk^VBLRLRyvQw2z zXK8OipI*2SEnOr^VBPWwQx zU1wOZia79>6B*=RMchfx;hOUw+q1=rHH#e@H~DO>GV7j?Ate6*Nnk@X`VhrN6S`$YKuUl#bMQ`Dw!p5|74x%;D{kH7#w3i!H`_LbY| z6YBEn4-bS~-xWuHl0JR$47=xY4}P`E-JJLDTY9AaYm-=W4egGkn&+2fecl!gD-@jm zUiDm_O?DQ(4oGc9-nVo8lWIm*HW{8@Wlp2&YY$(tx3;`iv)pZDK*_k}hp0aFo24kO zW_ya1ly1tpF@-f-LvVsve83%Bp$4bdZ*J~yCW3MjI3#39mxWLcI#zm&5Jv~KYxsx> zuTtc6xs7Gx*BC#jH3|Eg8b&5IDBGHOPI~i77P2fzq-%LnRN;|>55t=DRU&v&RXJAy zhtP`it-SkJb>Vsb(W9cCOiW|`qxp*Ra|m84eUDQGEnEz1i*apoPffCZhN;ekK`sdo z6Ym5baCkraEpBVDGF&N82$4wV)Kx2Mcvd*Kt4TcU(MZJLE=Cj&$GP^ea|b_dL0h31 zh&aik25DYU71*#|04JqQrpWg9u{?i$SV*|;M{1VePfLL2S<=^G$Ir=cpsOb8!L3yw zM@g;Z1!QB(so?&&;k&zHp=#E;vXV(a;bivbb#|4a;^9rgIhP+&x?F{qTH}Yxr)#)ndB}B2S3A}dUh4p=z9FR z)4i>%2U3nG%gqj?7jl7tfWUG|J;3_cbEOMCD$U}zwT=aRyCiB9WR7!+^0B!80IS(b zlIQMDRl;@g6z5A1jGDu=*DFr{0OWj_Vt1Ub(pY4WeSs(R2EC`?Mu~Giw>9mYQO$dA z7UfBsXxd0t=Leo}KBl!OmReNANQ2IA|)dRzwRUE4yha2o(HIM^~r2k#z$bgq?UypAwz<+s$a)FIfweR4`HbZCIW_bb?Oozwt$ae&l^-c+648F3WxrC@^R>g{KAkJZ#mkzehwPj? zhEy;yzVA|`%ugBX#cV+}Ui?7T!br|nZo@;Ny{wlcetn$kQ5YA*6 zB4sD?#SJ@XT|QoKdD#xvJWs4^-coAXh1K_wkb>q`a+&Mb=szl57TO!T*dd|(QPC?NW-eUvZudR&!e0(P z9@`k_z4)PTE93o6pP^n#$J;Kkf%(_nAF{`Xyf@+R3+kHIly2^A#5rlNVpxd-JOl-? z)BDFfbg#}&ht|e>#at3I(!Wal3t)UL@Dogh2Fdj(;$z!8-*Eo`$7{N-wA2??eAO$e z@~HNTxz2n}@y+c161;o)w@Eqj)kgtCXQ2N8bszH;K>Dqpm1)QdwN+x|fGOBTav#UOlbcE#<4B<7fboM?x}32aYR>lqHJH(~j{@TK&h@WV9hpl&4YJ zE3xwSy`)Dzp&!}gX<&I3NMVLdoOA8(Tt|uSzR{_(llO^l%;vpQ#6J_|@zcoH`gWab za~ia*cV!2aB#b%BfOejr-3Okv<65lS?_anB0~POQHB@LvOE^v>w%|pX8 zL2+qwBooGRl1AlO53wBj*XQ$(wp_Qd!05P3n%7;A(@VdDk9rkmyS9}_VyD01Nn!9J zD|t7^C7Q7BwEqBwd~M;++9O-O2(oKe335g;CBp=9>DT2o=-v_d-+gbZM;mHRE{Val zzh*JX_>;8$d9Ow|JXGQCRZRJL#|1{WzlWFJeLdm}`yYjV4!d||^RJ{|FYO38Qhg6> zbB}yi#$On`QERB_QOT#s>?d$V6z5dNw5BBH8KMp`puor7P5B6jI;r{^8E9#$(y04RWsK^d}&1vP2_lPI@it+yd z*r&the;8a}75QxJS%LIsAxG$1y5Eg@lTU4a@ie>cuKcv}WAhsTjA485y*t;;QIEF8 zr1~CqYwqEcddZ#!%P>{N&5TDJ`F<=hVE+KSw1xV1tNMSMXI1-g-RT#LOuvu`QQlmI z$)8iXYl2B-m%^w{eQRIB1YK&D(59$E$k+(}84zc_H}o6>&3=I|b`D1^I%!2KA5HuY zRj||b-9}9R0HWFL-p8H+&p+@Q_^;z`vbPr{cHxSWbKf=hAA@Yx!{J7(%_>Cq(ijAi zovVT|$sIe_#-FqY!p{-tGp+5;pDSt3p;GEE-bK$(oNzxJA8PqLzHyc&tnaIKUnAXy z7N^wU)O0?7LQ_d6p_W7be@ab1?~koo)a>N5wzh^uWGJMZ`kJR`+Z<7hZ`#|jl{kB@ z=i9%q=Aj&ZAk{6Iux>Q)0QDiq_}6XXm<^U$@^3)_L9lWQ^(mG(UjzI$RWQUbg}rO z;r{>?*_%HUY0xo@aA!hBJyphkrG9MuHt|8c(&X^gqcDyqb2guGDZsazxX)#L0DTBk z*w;g*d{gl!hP6X&HPr54ZI1=V&5U-zuQL&nQ^v>JC24tnhVsHyvz-r`dmnyV%kZuV zyvr>XJG+s}#3Ei`@i)d-({$I1PPBtWv_X$C_T>k##?}36;+9oBgRrsM4QeA6OM-14S)X1fTsB#Jv9UVyPj2?1VjQJ}erAl1Y zo}O;!0;65RTE+=)W3<)&F-@)N#w$rBxh&tjy_A;1j;EhNp0(s2D)EKYwav}cj`Eqw zEi7kzQvU$Fj0nwr1>j$T7dJ7RJ7_%8!(_52q2nyw0QUV&YkW}sn{9MW1{uV$y~8n# zqQt7Bfq}po`kJX?@RVx%2t9fqCt8f930I6;gm-<zX}W&G-A%9={cE)F z6@b)M3+sz}9XiO$P)wGp&PW;H9z8nxilgK22a64IOGHhvx`sv0FnJsrn9D7#_M4_F z;wxKlRZwFr_;N`46(8^sUe*eno#idMA5oRi!_=eoiiFQQwldJVi!B=O!} z?q;1pECE1H7xAiJwsxjl#Md_2`C+z>FusJ0{{ZaO+58OBnk`eqcEodMW+iX;igWtc zo&MFo6z!h-ThjF%Gf%uI<~w~rL$c-^9-EYnz+j9KUnMl^<}p!MvVV&>?w%TQT60M7 zTMyaeR@QX5^$kl}@Xv=Wu5ie@#>i??Dl&|mWi7iScqlk082#-1 zHqos#?JMAfkZAWt`pzd3Ex}Ej!I3g{ZRd%!ro6RMWw(jiNIDWRl76esN2k!% zIb5R|&NANTJ}wGXDa|b`d|Rkofp$P3;Nu|Vb+38&7vh-gES?rp@=NmVUaq+r1Ke;& zy5qfg$M!wEH_!I6>WHN6Ba(eTI_&-z$S(XrEOF*Eir!h5X~xp3SRc(reSQ)ba#Go& zsuZC%uhjhw@Mpw}O>@Kc)>_?^I?k4=6(<8MgB)ZW5J38VHKpUP3ixVY1L`{8hqMho z>iRW1R`wq^&Bg}SW+dYtgmGUocpt>>ZSSt(ym=Z~LX-$2*|>}^A9(QGo=?=8`U~Pq zjU(V@pBc)v)zoC*{{RTw-^oRMraLeCrXn$ew=+7a#!%;{QqPrcesX+vT`O1CXKNn{ z+4x@m+1fkEtS%&y86*dis^zw0k$`brUV#COMnF4-d*6w5--EaM-T2n@{{R)*>JrM& zEc$ibw9uC%l0QUQyu2)^OTKBDCv*hwnsc1 zsLoV*WoEWHIht3s?tMl34ctULU2~P#(rM4P>%B8q{{U!6CAQNw2MSn6s7xGsa!CC% zUTym!__i$*$C_;Hc3aBE)$({<;{)}_2^Z=vAyfQL1_&QeTk#^X z!?jNruT*g2*R;dMrL#Xa{7ref>B=eV+}7vAe;6MOYB1hL3Qdp!&$-TPuhxDKHKw0? zuj+Ra*lBT1lL@Z0`J3GnwbP`$%&5+qdXq@8Tb14hS%W#0E)9TZwiod z$Qk3uumpc9_*23E02dd+w#^Nlf?mSsIMibg{{WznJ-gR?qkMh8nnhbp7fZHxJ3&ZD z$@Jyxml=>l5hqfO(|g(39-6>KMMX(JCXcVQ`2H7oWyIQkkp=C-@~qJ`m_EO}I3G|e zw(z%)AH~sXs@Ac=XKxyX3VG*uQ~v+~^skM)JMkM^*EL&z?F&S-v3?A&+iYHk9Gvwy z?_Wmv7U!$B3>8BXU9pKBqs()ISO= z+V5G0H6Js$QS~*YXhtt%=P60b2{ZIV#!U=90r0F4TE$}1gN>QqO~_$7b|o~^Q{w9`%a}2c}N+K4$wLMEAJoKqfAfj9}c1} z(6F@F{{VoW@vn`1J@BhhwAUb0KAj`6;6bU|%17X?Ywv&A?@3KI{>(Vb+iAoW9W$I~ z^flR>O+yDObtz$_u@vvJXU^ZW$HpB~!~QeXg|>&`yUS<0l?1wmi*Iou3d90g*C!x% z&3xald|lIgNug_&TAq{P%?nd|M>bl9m!PatGmcC|#UdsNzuMx)bGbi?znx)Vla3qYQ_v^a8J@J=`blq!LxxJ4_k4iGP7Pb`^y()|9Z_nOusiseTW)5~tJ+}|=s^;?0 z^onoA$M{!~B%8gDr;jy;O?1zZ$TeTgV0g_cs9ju}|o#J;3+S`d8AApZbmkLgqm-Mq6vA&ymj<0e7~$KWdUnat1r>;C{FPCpTy zMWxF3&H#-60I(}pNt1S;0RI4JipSJW7A~K1wKO4{2#@<``qxz-;xt4R%}CgW#cS!8 z&lz2(YkG>rC+4d*(-l2?*Q*xdMB#LOL;ErONU+d6P_`P~lzNVxsm5(2igXU8ivu1( zAbs$oB=MZr)ZPvF!KG+EG`D>^3wup1)Il}9vEjyZxDQd!*FN?6x1#HfVQ~|yV1^jM z#d`hki{-wwveoTh%9nO0Soreg9Zo$MbN>K+4%PM;EH)n>MpUQqTfU$0=YAg-3Rqf{ zX0_;j{l?2UdCYBeaFuf@r}uc=MCzoiujx2hr*T7^+dk2%yyHuB#DRmm-Nqd zJdl2)wolT(vtR88ZFi@C!a3qcS#;^f*yNj$5j{cA@RRv<>6~`|02n?BNiLZ^){|)# zqhTV3F}@k2T!MCbSp??tX7y56MyDaO&}UuE*!oc)stzI^0jE zI5-s#E*dY zHy594(d6?%$ToAGk}32V;Qs(R^ZR=}Z^D-?YW5Fq$lGL!L^)zVygJv~P?b88f4F+p|OFL3d!ves;FG!1uzi>;C`(718TnEZ4MKiLNZQS#LC=yW(ln z%_?vX$J{cfIUN4A!HeO#Ri(`c@A5r)WH`J&xN4V=X=;6Ht?+kJ1)EE2cRY}SLH_`= z5l@D1g!*G{x6w?jy&86MKUc4b6XW*11cWuMgP&7xgZdh6-^YIuPZ=<+syC!|HtiIYS!;{{VFq*OB))_|@V430P=)90>h4L2dlV>t0>)FXMRB0#B>mstAA7 z+Ow$nkNY5#_>o^9>mL-nPpa-o^%=tSD6BvO=qek@XVtVlKIoQtp=OFh>&{gExcn>B z!0`Sal>MvKqtL=(Yhu0H&)w>lhobn^+fu#W(b~x@{{S$OaM&P|$Yo*QJw<7JD)8Q+ zXRL{3iYSC&zQlZj7oI&n?QuGHi#16S&dl4za)<-T3?qO@kwqV zxm#nw&gjWy`A@h2=l$$w8aR1fS=&R?&NBS74}^1~+Iavax z%zvGJM-O_e<>q|l8h*}&Dt=e{&VNa_dFE9EB%1o;!CoxTGz}X=vri4dbE!pb8p(3- zqcgu;@(J&c!oGO;F1{MO@k|hSo?S{S2jNbe6mI*y4)z!x_%-$>k0-)?D)PWt>HZ+S zzAP37oWv9`I0b-ipM`yPTPQ}1`Qa&gZSy|wBcRl3RaWeK*0(udf;vc8#7}i9v5i1p zPUh%7g1$fakE-fXYuBr9b$1#EDiSFZXvZB1_OG#iA;BH5gM2${7-flzO|{P;U>twr z#=cJRTr%pbe?6|1XMH?waH@Aq*>1Z5$;N#vE*wfur0u(V`koa$46)eRrMgFw19^3J zvD`^~OSS_x(7%ocwS8Ieb5B_$@a#X{x(wg<(Ek7f`B%)AdTy_8uE1_=9>_D`t3~CE zepU6i!Cg4V;x7+JjzDQh{{VnF{p)IQbmD_KnO5so4FM3wSJp(t4!jPu^VIHavYK7*&N zdA~C`<5oRR4OC*N_%+e5h*~upH0u(_zuEKsYYSGMS?&a~La`D)>PN6~?Oc4)Zq_~j z0A(0ONjsLIO(|nmKWcV7@w5-?Pcvz#4kEc>+&s#l{!3Ennx>%Ep;}GBr+o|ec8nUHcKxC}kFBWLwN zSAG-fKiR(#ygNG_FWS~N&!c>&{{TX(siKQLPsZ9x44XkC#=g-^GyedNZlvF{#9zIQ z=~}K8MRdCSE@b#t2L-_&*ZNnccxunX(d!p?UL~61J2i*SiW^1CO!*mH_8j|t zYsc)aTH1K!U%ZS6uS|wWuOYRaSIzRbIZy9IKn?he*Xw*YiBqFG7qjx;Q^3R3`nD<+ z8q>`5Zwq{LMAf0w?5#huJU*m_wYMX49?b4}JoDS%HTH+Xtzy^WAAm0O3%1>q-4XA# zxd;9N-_pJW@HfJJSH;@0CWmh=%I79PHmVO&PeJcrRQLx|)BY4CrMT6U7D$?bn{6(#nuhsVXpG}x$_^egx&Nq#$@IU|bYq zjN_^?9X*Nl^fmG~#czWeJ^D1MX?3OC#!Aeh4a*aE%Bb7{>yQuA9XN7~(lWGXq}Gqr z{QCx_meqKAkKFq&^f)ht{{R)z-KBzf1;wLrEweTVIQ!~*5&dyrL3l&QGntn2!+Nvb zOB(0O`?nE}q!s=l>y5+L74l*DRefW0WYe{sIsX9K7m9}->ewUk73tptEpNOR@f$(a zH63?KSS_xRrBAgh5}CsRjEwCjzLPMcOBGI4TD-0DXVT&o9CTwDrl-OKT%#Tq)1p4w>zY`d63gf3#kwr!u6`*jzK9aKh3f!S~x=6a9?7l;f0vVFF6~Vy8i&OFg=N`+u`@ap`%=_=CXqCUXXt7%NdT`5sb_J)<1){ z@qcvtQ=v}@6$Gr8;&>RUH6cEFy0%a7%fkmo(Uw<7m&7`lD-LsuOKw9*f7*UjdM@Lf zvgh4A4dEu#Z*26NH6l2_eQ__pVtw4h%i+T*M>jvA5&kP9y-?~zPy!-XK^HBraM=n z{7m?RbK*T-_G#`K;#-Gic^u@qB$8{!b=kbwLw5%Tyq-^IPRo9$+2QEQy;oLCPK&ZJ zE+pJfJl39{<0R1Zb%RgR?V{BSF_Tl5_mY900t3QecO3hUm5DRvq|$WBHH}6qNE3Xs z94HmbPEvB^j_mr(JY@!ycV#=VNw6>0&T-u*oXFX&${y zHA*V;-IzoWc&%x_(mXwG{baY5k-yz;NA>*cGie>YD^p7bYdh;<$!NriJ=Em>nXeWb zxSa7av6Il#fT2!0)4&y;+7EGsPa?W+1I~WYb8b!psC6Gszs!DB&m4MH%>wi6TFtDT z5ualpW5@OVE1MAxdQwM59$b|ZI^Pi5{{WyFhu(>U56=hr))mBi?W8Jp<#z*~Ui+AF-NvV#E8WhdJt>VejIpfO`k?LZyZ;bF2!9XP{J?|OdnB$pL*uCt2p4*?!&1o zArdapo_qees~TLlc17CBq_YwYr(x^wUT?Lhg{yh$hZtGxWcb@bk4f<*)upJ+A1k8g zI|BfA=i4~?VE3vP`aII$zsLo47Cs!F=1t`p*^W!Mb6$<$Ux8jA@!i*vrD>Ahs5p5- z6^TFIbI0M(QKvU|WOc_2DQc1IH~#<*EbJy}qdLcgE(h@#&BeI(+`NJHHDc9# zaiYQYn@O#FPp6ELHIZ2kKi%Q8^v!z3lS4c~wEbbGw;dEZ%0Dxc`qf+gBHHRxEY`>* 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 k$hTfF({JvAMJDDv1ywxP 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

FVZR8)!Q4OZkzT#3_|sN! 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 Date: Fri, 6 Mar 2026 09:00:15 -0600 Subject: [PATCH 5/6] Set version to 2.6.0 = basic DynamicVRAM compatibility and bug/compatibility fixes --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index cc07ea7..6de1f20 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [project] name = "comfyui-multigpu" description = "Provides a suite of custom nodes to manage multiple GPUs for ComfyUI, including advanced model offloading for both GGUF and Safetensor formats with DisTorch, and bespoke MultiGPU support for WanVideoWrapper and other custom nodes." -version = "2.5.11" +version = "2.6.0" license = {file = "LICENSE"} [project.urls] From 82e693113edad419affb060a40ada785f3f10fae Mon Sep 17 00:00:00 2001 From: John Pollock Date: Fri, 6 Mar 2026 09:02:06 -0600 Subject: [PATCH 6/6] fix: change file permissions for ComfyUI-starter_multigpu.json to improve accessibility --- example_workflows/ComfyUI-starter_multigpu.jpg | Bin example_workflows/ComfyUI-starter_multigpu.json | 0 2 files changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 example_workflows/ComfyUI-starter_multigpu.jpg mode change 100755 => 100644 example_workflows/ComfyUI-starter_multigpu.json diff --git a/example_workflows/ComfyUI-starter_multigpu.jpg b/example_workflows/ComfyUI-starter_multigpu.jpg old mode 100755 new mode 100644 diff --git a/example_workflows/ComfyUI-starter_multigpu.json b/example_workflows/ComfyUI-starter_multigpu.json old mode 100755 new mode 100644