Version 1.1.14

Included in Version 1.1.14

Summary

We implemented a complete memory-management upgrade for ETUR refiners (PRO + CE) to support low-spec systems and very large tile counts.

This combined plan delivers:

1. meaningful 3-profile memory modes,

2. clear PRO tooltip text explaining tradeoffs,

3. CE forced to lowest-memory behavior,

4. RAM-based automatic fallback (cross-platform),

5. strict `Ultra Low` mode that unloads/reloads models between stages/tiles for minimum VRAM usage.

Target scenario: 100 tiles, 2048x2048 input, denoise mask + image stabilizer + Redux + 3 ControlNets.

---

PRO node input change

We replaced the boolean `Low_Vram` with enum `VRAM_Profile`.

Final profile names

1. `Fast Cache (Max Speed)`

2. `Low VRAM Cache (Unload Models)`

3. `Ultra Low Memory (Per-Tile Streaming)`

### PRO tooltip (final text)

- `Fast Cache (Max Speed)`: Precomputes full tile conditioning (text + Redux + ControlNet) for all tiles and keeps models loaded. Fastest sampling, highest RAM/VRAM usage.

- `Low VRAM Cache (Unload Models)`: Precomputes full tile conditioning, then unloads models to reduce VRAM. RAM can still be high with many tiles.

- `Ultra Low Memory (Per-Tile Streaming)`: Caches repeated text conditioning only; Redux/ControlNet are rebuilt per tile and released immediately. Also unloads/reloads models between steps/tiles for minimum VRAM. Slowest mode; best for very low-spec systems.

CE node behavior

- No new CE UI input.

- Force CE internally to `Ultra Low Memory (Per-Tile Streaming)`.

Backward compatibility

Map legacy workflows with `Low_Vram`:

- `True` -> `Low VRAM Cache (Unload Models)`

- `False` -> `Fast Cache (Max Speed)`

- If CE path has no field -> force Ultra Low.

---

## 2) Runtime Profile Semantics

### A. Fast Cache (Max Speed)

- Full precompute for all selected tiles:

  - text conditioning

  - Redux conditioning

  - ControlNet conditioning

- Keep models resident.

- Highest memory usage, best speed.

### B. Low VRAM Cache (Unload Models)

- Same full precompute as Fast Cache.

- Then unload models / soft-empty cache before tile sampling loop.

- Lower VRAM than Fast Cache, RAM still high due to full caches.

### C. Ultra Low Memory (Per-Tile Streaming)

- Precompute text-only deduplicated cache.

- For each tile:

  - build dynamic conditioning on demand (Redux + ControlNet)

  - consume immediately

  - drop refs + unload models + flush cache

- Between stages and between tiles:

  - aggressive unload/reload cycle.

- Slowest, lowest VRAM and significantly lower RAM.

---

## 3) RAM-Based Auto Fallback (PRO)

Scope

- RAM-based only (not VRAM-based), per your requirement.

- Applied to PRO before heavy precompute starts.

### Cross-platform RAM probing

Primary:

- `psutil.virtual_memory().available` and `.total`

Fallbacks if `psutil` unavailable:

- Windows: `ctypes` `GlobalMemoryStatusEx`

- Linux: parse `/proc/meminfo` (`MemAvailable`)

- macOS: `vm_stat`/page-size parsing (+ `sysctl hw.memsize` for total)

If all probes fail:

- Log warning; run selected profile without auto-fallback.

Decision rule

- Estimate required RAM for selected profile.

- Safety threshold:

  - require `available_ram >= estimate * 1.25 + 1.5GB`

- If unsafe:

  - auto-switch to `Ultra Low Memory (Per-Tile Streaming)`

  - log decision and numbers.

- If selected profile already Ultra Low:

  - no upward fallback.

---

## 4) Estimation Model

### Fast / Low VRAM Cache estimate

- Baseline process overhead

- + per-tile unified conditioning cache estimate (all tiles):

  - sample tensor dimensions from representative tile

  - dtype factor

  - conditioning structure overhead multiplier

Ultra Low estimate

- Baseline

- + text-only cache estimate

- + one-tile transient working set (not multiplied by tile count)

## 5) Code Changes

Files

- [`py/nodes/UpscalerRefiner/TBG_Nodes_PRO.py`](a:/SD/ComfyUI_070_cu128/ComfyUI/custom_nodes/ComfyUI-TBG-ETUR/py/nodes/UpscalerRefiner/TBG_Nodes_PRO.py)

- [`py/nodes/UpscalerRefiner/TBG_Nodes_CE.py`](a:/SD/ComfyUI_070_cu128/ComfyUI/custom_nodes/ComfyUI-TBG-ETUR/py/nodes/UpscalerRefiner/TBG_Nodes_CE.py)

- [`py/nodes/UpscalerRefiner/TBG_Refiner.py`](a:/SD/ComfyUI_070_cu128/ComfyUI/custom_nodes/ComfyUI-TBG-ETUR/py/nodes/UpscalerRefiner/TBG_Refiner.py)

- [`py/nodes/UpscalerRefiner/inc/vram_optimizing.py`](a:/SD/ComfyUI_070_cu128/ComfyUI/custom_nodes/ComfyUI-TBG-ETUR/py/nodes/UpscalerRefiner/inc/vram_optimizing.py)

- New helper: `inc/memory_probe.py` (or equivalent)

Patched the skippend Cnet Log bug in ETUR.

What I changed

I updated vram_optimizing.py:

Removed the invalid SELF.INPUTS.controlnetimage gate (that field is never set in this path). Just triggering a wrong log output confusing users

ControlNet preprocessors now validate real sources:

use custom_controlnet_image (noise_image) if provided

otherwise use per-tile image

Fixed a second bug: it now applies filtered_pipe (not the original pipe).

Why your log looked contradictory

You saw both:

Skipping ... no controlnetimage

and Depth model loading each tile

That happened because the code was logging skip during filtering, but still executed the original unfiltered cnet pipe afterward. The patch fixes that mismatch.

Changes made

Updated cnet.py:

Logs at tile start: how many ControlNet pipe entries will be processed.

Logs per entry before apply:

model

preprocessor

source (tile_image vs custom_controlnet_image)

effective strength, start, end

image_shape

Logs per entry after apply: conditioning applied.

Updated vram_optimizing.py:

Logs selected filtered entries per tile before precompute.

Keeps the earlier fix:

no bogus controlnetimage gate

uses filtered_pipe for execution.

Author: Ltamann

py/nodes/UpscalerRefiner/TBG_Nodes_CE.py

@@ -236,9 +236,10 @@ def INPUT_TYPES(self):
     OUTPUT_NODE = True
     FUNCTION = "fn"
 
-    @classmethod
-    def fn(self, **kwargs):
-        return {
-            "ui": {"value": [f"{kwargs.get('seed', None)}"]},
-            "result": (TBG_Refiner_v1.fn(**kwargs))
-        }
+    @classmethod
+    def fn(self, **kwargs):
+        kwargs["VRAM_Profile"] = "Ultra Low Memory (Per-Tile Streaming)"
+        return {
+            "ui": {"value": [f"{kwargs.get('seed', None)}"]},
+            "result": (TBG_Refiner_v1.fn(**kwargs))
+        }

py/nodes/UpscalerRefiner/TBG_Nodes_PRO.py

@@ -415,8 +415,26 @@ def INPUT_TYPES(self):
                 "Selected_Tiles_By_Numbers": ("STRING", {"label": "Selected_Tiles_Index_Numbers to process", "default": '',
                                                          "tooltip": "You can set a list of selected tiles to process like 1,2,3,6 and activate Selected_Tiles_Only"}),
 
-                "Low_Vram": ("BOOLEAN", {"label": "Low Vram", "default": True, "label_on": "on", "label_off": "off",
-                                        "tooltip": "Reduced VRAM Usage achieves lower memory consumption through conditioning compression, process separation, model unloading, and automatic memory cleanup."}),
+                "VRAM_Profile": (
+                    [
+                        "Fast Cache (Max Speed)",
+                        "Low VRAM Cache (Unload Models)",
+                        "Ultra Low Memory (Per-Tile Streaming)",
+                    ],
+                    {
+                        "label": "VRAM Profile",
+                        "default": "Low VRAM Cache (Unload Models)",
+                        "tooltip": (
+                            "Fast Cache (Max Speed): Precomputes full tile conditioning (text + Redux + ControlNet) "
+                            "for all tiles and keeps models loaded. Fastest sampling, highest RAM/VRAM usage. "
+                            "Low VRAM Cache (Unload Models): Same full precompute, then unloads models to reduce VRAM. "
+                            "RAM can still be high with many tiles. "
+                            "Ultra Low Memory (Per-Tile Streaming): Caches repeated text conditioning only; Redux/ControlNet "
+                            "are rebuilt per tile and released immediately. Also unloads/reloads models between steps/tiles "
+                            "for minimum VRAM. Slowest mode; best for very low-spec systems."
+                        ),
+                    },
+                ),
 
             },
             "hidden": {

py/nodes/UpscalerRefiner/TBG_Refiner.py

@@ -11,7 +11,20 @@
 
 
 
-import comfy.model_management as model_management
+import comfy.model_management as model_management
+from ....utils.log import log
+
+
+def _controlnet_label(controlnet_model):
+    if controlnet_model is None:
+        return "None"
+    name = getattr(controlnet_model, "name", None)
+    if name:
+        return str(name)
+    model_file = getattr(controlnet_model, "model_file", None)
+    if model_file:
+        return str(model_file)
+    return type(controlnet_model).__name__
 
 
 def stitch(
@@ -177,14 +190,22 @@ def stitch(
 
 
 
-def apply_controlnets_from_pipe(self,SELF, cnetpipe, positive, negative, full_image, tile_image, vae, index):
-    controlnet_node = nodes.ControlNetApplyAdvanced()
-    for control in cnetpipe:
-        controlnet_model = control["controlnet"]
-        strength = control["strength"]
-        start = control["start"]
-        end = control["end"]
-        preprocessor = control["preprocessor"]
+def apply_controlnets_from_pipe(self,SELF, cnetpipe, positive, negative, full_image, tile_image, vae, index):
+    controlnet_node = nodes.ControlNetApplyAdvanced()
+    tile_no = index + 1
+    total_entries = len(cnetpipe) if cnetpipe is not None else 0
+    log(
+        f"[TBG][ControlNet] Tile {tile_no}: precompute start with {total_entries} pipe entries",
+        None,
+        None,
+        f"Node {self.node_id}",
+    )
+    for entry_idx, control in enumerate(cnetpipe):
+        controlnet_model = control["controlnet"]
+        strength = control["strength"]
+        start = control["start"]
+        end = control["end"]
+        preprocessor = control["preprocessor"]
         canny_high_threshold = control["canny_high_threshold"]
         canny_low_threshold = control["canny_low_threshold"]
         noise_image = control["noise_image"]
@@ -197,27 +218,46 @@ def apply_controlnets_from_pipe(self,SELF, cnetpipe, positive, negative, full_im
                 cnet_image = np.array(cnet_image)
 
         grid_cnetstrength = self.PROMPTER.output_cnet_js[index]
-        if grid_cnetstrength is not None and isinstance(grid_cnetstrength, (float, int)):
-            strength = grid_cnetstrength  * self.KSAMPLER.cnet_multiply
-        else:
-
-            strength = strength * self.KSAMPLER.cnet_multiply
-
-        # Preprocessero
-
-        if preprocessor == "DepthAnythingV2":
-            model = DepthAnythingV2Detector.from_pretrained(filename="depth_anything_v2_vitl.pth").to(model_management.get_torch_device())
+        if grid_cnetstrength is not None and isinstance(grid_cnetstrength, (float, int)):
+            strength = grid_cnetstrength  * self.KSAMPLER.cnet_multiply
+        else:
+
+            strength = strength * self.KSAMPLER.cnet_multiply
+
+        source = "custom_controlnet_image" if noise_image is not None else "tile_image"
+        model_label = _controlnet_label(controlnet_model)
+        cnet_shape = tuple(cnet_image.shape) if hasattr(cnet_image, "shape") else "unknown"
+        log(
+            f"[TBG][ControlNet] Tile {tile_no} entry {entry_idx + 1}/{total_entries}: "
+            f"model={model_label}, preprocessor={preprocessor}, source={source}, "
+            f"strength={float(strength):.4f}, start={float(start):.3f}, end={float(end):.3f}, "
+            f"image_shape={cnet_shape}",
+            None,
+            None,
+            f"Node {self.node_id}",
+        )
+
+        # Preprocessero
+
+        if preprocessor == "DepthAnythingV2":
+            model = DepthAnythingV2Detector.from_pretrained(filename="depth_anything_v2_vitl.pth").to(model_management.get_torch_device())
             cnet_image = common_annotator_call(model, cnet_image, resolution=1024, max_depth=1)
             del model
         if preprocessor == "Canny Edge":
             cnet_image = common_annotator_call(CannyDetector(), cnet_image, canny_low_threshold=canny_low_threshold, canny_high_threshold=canny_high_threshold, resolution=1024)
-        positive, negative = controlnet_node.apply_controlnet(
-            positive, negative, controlnet_model, cnet_image, strength, start, end, vae
-        )
-        if preprocessor == "ControlNetInpaintingAliMama":
-            from .image import TBG_Image
-            inpaintmask = \
-                TBG_Image().mask_get_fusion_mask(SELF,
+        positive, negative = controlnet_node.apply_controlnet(
+            positive, negative, controlnet_model, cnet_image, strength, start, end, vae
+        )
+        log(
+            f"[TBG][ControlNet] Tile {tile_no} entry {entry_idx + 1}/{total_entries}: conditioning applied",
+            None,
+            None,
+            f"Node {self.node_id}",
+        )
+        if preprocessor == "ControlNetInpaintingAliMama":
+            from .image import TBG_Image
+            inpaintmask = \
+                TBG_Image().mask_get_fusion_mask(SELF,
                                                  cnet_image.shape[1],
                                                  cnet_image.shape[2],
                                                  SELF.SIZE.cols_qty,
@@ -243,8 +283,8 @@ def apply_controlnets_from_pipe(self,SELF, cnetpipe, positive, negative, full_im
 
         #if self.lowvram:
         #    UnloadOneModelNode.route(controlnet_model)
-
-    return positive, negative
+
+    return positive, negative
 
 def get_canny_mask_inverted(image,canny_low_threshold=100,canny_high_threshold=150):
     resolution = min(image.shape[1],image.shape[2])

py/nodes/UpscalerRefiner/inc/cnet.py

@@ -0,0 +1,127 @@
+import ctypes
+import os
+import platform
+import subprocess
+
+
+def _ram_info_psutil():
+    try:
+        import psutil
+
+        vm = psutil.virtual_memory()
+        return {
+            "ok": True,
+            "available_bytes": int(vm.available),
+            "total_bytes": int(vm.total),
+            "source": "psutil",
+        }
+    except Exception as e:
+        return {"ok": False, "reason": f"psutil failed: {e}"}
+
+
+def _ram_info_windows_ctypes():
+    class MEMORYSTATUSEX(ctypes.Structure):
+        _fields_ = [
+            ("dwLength", ctypes.c_ulong),
+            ("dwMemoryLoad", ctypes.c_ulong),
+            ("ullTotalPhys", ctypes.c_ulonglong),
+            ("ullAvailPhys", ctypes.c_ulonglong),
+            ("ullTotalPageFile", ctypes.c_ulonglong),
+            ("ullAvailPageFile", ctypes.c_ulonglong),
+            ("ullTotalVirtual", ctypes.c_ulonglong),
+            ("ullAvailVirtual", ctypes.c_ulonglong),
+            ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+        ]
+
+    stat = MEMORYSTATUSEX()
+    stat.dwLength = ctypes.sizeof(MEMORYSTATUSEX)
+    if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat)):
+        return {
+            "ok": True,
+            "available_bytes": int(stat.ullAvailPhys),
+            "total_bytes": int(stat.ullTotalPhys),
+            "source": "windows_ctypes",
+        }
+    return {"ok": False, "reason": "GlobalMemoryStatusEx failed"}
+
+
+def _ram_info_linux_proc():
+    path = "/proc/meminfo"
+    if not os.path.exists(path):
+        return {"ok": False, "reason": "/proc/meminfo not found"}
+    values = {}
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            if ":" not in line:
+                continue
+            k, v = line.split(":", 1)
+            num = v.strip().split()[0]
+            if num.isdigit():
+                values[k] = int(num) * 1024
+    if "MemAvailable" in values and "MemTotal" in values:
+        return {
+            "ok": True,
+            "available_bytes": int(values["MemAvailable"]),
+            "total_bytes": int(values["MemTotal"]),
+            "source": "linux_proc_meminfo",
+        }
+    return {"ok": False, "reason": "MemAvailable/MemTotal not found"}
+
+
+def _ram_info_macos_vmstat():
+    try:
+        total = int(
+            subprocess.check_output(["sysctl", "-n", "hw.memsize"], text=True).strip()
+        )
+        vm_out = subprocess.check_output(["vm_stat"], text=True)
+        page_size = 4096
+        for line in vm_out.splitlines():
+            if "page size of" in line:
+                parts = line.split("page size of", 1)[1].strip().split(" ", 1)
+                if parts and parts[0].isdigit():
+                    page_size = int(parts[0])
+                break
+
+        free_pages = 0
+        inactive_pages = 0
+        speculative_pages = 0
+        for line in vm_out.splitlines():
+            norm = line.strip().replace(".", "")
+            if ":" not in norm:
+                continue
+            key, val = norm.split(":", 1)
+            num = val.strip().split(" ")[0].replace(".", "")
+            if not num.isdigit():
+                continue
+            n = int(num)
+            if key == "Pages free":
+                free_pages = n
+            elif key == "Pages inactive":
+                inactive_pages = n
+            elif key == "Pages speculative":
+                speculative_pages = n
+
+        available = (free_pages + inactive_pages + speculative_pages) * page_size
+        return {
+            "ok": True,
+            "available_bytes": int(available),
+            "total_bytes": int(total),
+            "source": "macos_vm_stat",
+        }
+    except Exception as e:
+        return {"ok": False, "reason": f"vm_stat failed: {e}"}
+
+
+def get_ram_info():
+    probe = _ram_info_psutil()
+    if probe.get("ok"):
+        return probe
+
+    system = platform.system()
+    if system == "Windows":
+        return _ram_info_windows_ctypes()
+    if system == "Linux":
+        return _ram_info_linux_proc()
+    if system == "Darwin":
+        return _ram_info_macos_vmstat()
+    return {"ok": False, "reason": f"unsupported platform: {system}"}