"""v6m memory policy: «Экономия памяти» (chunked feed-forward, own implementation) and releasing what a run does not need (ControlNet patch, preprocessors) with a short log line.""" import torch import pytest from h3s import h3s_core as core from h3s import h3s_gen as gen from h3s import h3s_control as control from h3s import h3s_memory as mem from fakes import tiny_patcher, FakeClip, FakeVAE from test_control import dirs, project, _video, _pinfo # noqa: F401 (fixtures) @pytest.fixture() def patcher(): return tiny_patcher() def test_chunked_ffn_equals_the_plain_mlp(patcher): import comfy.ops mlp = patcher.model.diffusion_model.blocks[0].mlp torch.manual_seed(1) for shape in ((1, 1031, 128), (1037, 128), (2, 600, 128)): x = torch.randn(*shape) ref = comfy.ops.linear_input_act(mlp.fc2, mlp.fc1(x), "swiglu") for chunks in (2, 3, 7): got = mem.chunked_ffn(chunks, 256)(mlp, x) assert got.shape == ref.shape and torch.allclose(got, ref, atol=1e-6, rtol=1e-5), (shape, chunks) small = torch.randn(1, 100, 128) # under the threshold: the plain path assert torch.equal(mem.chunked_ffn(4, 256)(mlp, small), comfy.ops.linear_input_act(mlp.fc2, mlp.fc1(small), "swiglu")) def test_modes_and_the_patched_clone(patcher): assert not mem.wants_ffn({"mode": "off"}, cn=True, tokens=10 ** 6) assert mem.wants_ffn({"mode": "auto"}, cn=True) and not mem.wants_ffn({"mode": "auto"}, cn=False, tokens=100) assert mem.wants_ffn({"mode": "auto", "threshold": 1000}, tokens=2001) and mem.wants_ffn({"mode": "on"}) assert mem.apply_ffn(patcher, {"mode": "off"}) is patcher m2 = mem.apply_ffn(patcher, {"mode": "on", "chunks": 2, "threshold": 512}) assert m2 is not patcher and not patcher.object_patches # the source patcher is untouched keys = [k for k in m2.object_patches if k.endswith(".mlp.forward")] assert len(keys) == len(patcher.model.diffusion_model.blocks) assert mem.apply_ffn(m2, {"mode": "on"}) is m2 # never stacked assert core.normalize_project({"settings": {"memsave": {"mode": "x", "chunks": 99, "threshold": 5}}})["settings"]["memsave"] == {"mode": "auto", "chunks": 16, "threshold": 256} def test_generation_with_memsave_gives_the_same_latents(patcher, dirs, monkeypatch): out, inp = dirs seen = [] real = mem.chunked_ffn def spy(chunks, thr): f = real(chunks, thr) def g(self, x): seen.append(int(x.shape[-2])) return f(self, x) g._h3zs_ffn = f._h3zs_ffn return g monkeypatch.setattr(mem, "chunked_ffn", spy) base = project() base["settings"]["cache"] = False base["settings"]["memsave"] = {"mode": "off"} a = gen.run_project(patcher, FakeClip(), FakeVAE(), base) assert not seen on = project() on["settings"]["cache"] = False on["settings"]["memsave"] = {"mode": "on", "chunks": 3, "threshold": 256} monkeypatch.setattr(core, "normalize_memsave", lambda v: {"mode": "on", "chunks": 3, "threshold": 8}) # tiny clips: force chunking b = gen.run_project(patcher, FakeClip(), FakeVAE(), on) assert seen and max(seen) > 8 va, vb = a[0], b[0] assert torch.allclose(va, vb, atol=1e-4, rtol=1e-4) class _FakePatcher: def __init__(self, name): self.name, self.model = name, object() def test_release_unloads_and_logs(monkeypatch, capsys): import comfy.model_management as mm gone = [] monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) mem.hold("cn_patch:x.safetensors", _FakePatcher("cn"), "ControlNet patch x") mem.hold("pre:pose", (_FakePatcher("sdpose"), None, _FakePatcher("rtdetr")), "SDPose + RT-DETR") control.release() assert sorted(gone) == ["rtdetr", "sdpose"] and mem.get("cn_patch:x.safetensors") is not None control.release_patch() assert gone[-1] == "cn" and not mem.HOT assert "[H3ZS] unloaded: SDPose + RT-DETR" in capsys.readouterr().out def test_preprocessors_are_released_right_after_the_control_video(dirs, monkeypatch): out, inp = dirs a = _video(inp) held = [] monkeypatch.setattr(control, "preprocess", lambda fr, mode, params: (mem.get("pre:da3:x") or mem.hold("pre:da3:x", _FakePatcher("da3")), fr)[1]) import comfy.model_management as mm monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a_, **k: held.append(p.name), raising=False) path = control.build_processed(str(inp / "h3labstudio" / a["file"]), "depth", core.normalize_control_params({})) assert path and held == ["da3"] and mem.get("pre:da3:x") is None def test_run_without_control_releases_the_patch(patcher, dirs, monkeypatch): import comfy.model_management as mm gone = [] monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) mem.hold("cn_patch:fake_2.0.safetensors", _FakePatcher("cn"), "ControlNet patch") gen.run_project(patcher, FakeClip(), FakeVAE(), project()) assert gone == ["cn"] and not any(k.startswith("cn_patch:") for k in mem.HOT) def test_run_with_control_keeps_the_patch_hot(patcher, dirs, monkeypatch): out, inp = dirs _video(inp) import comfy.model_management as mm import comfy_extras.nodes_minimax_h3 as nm gone, loads = [], [] monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) class FakeApply: @staticmethod def execute(model, patch, vae, strength, start, end, control_video=None): return (model,) monkeypatch.setattr(nm, "MiniMaxH3FunControlNetApply", FakeApply) monkeypatch.setattr(control, "patch_file", lambda: ("fake_2.0.safetensors", "/x")) monkeypatch.setattr(control, "patch_info", _pinfo("fake_2.0.safetensors")) import comfy_extras.nodes_model_patch as mp class FakeLoader: def load_model_patch(self, name): loads.append(name) return (_FakePatcher("cn"),) monkeypatch.setattr(mp, "ModelPatchLoader", FakeLoader) p = project({"mode": "gray", "clips": [{"asset": "v1", "start": 0.0, "in": 0.0, "length": 1.0}]}) p["settings"]["cache"] = False gen.run_project(patcher, FakeClip(), FakeVAE(), p) gen.run_project(patcher, FakeClip(), FakeVAE(), p) assert loads == ["fake_2.0.safetensors"] and gone == [] # same setup: loaded once, no churn control.release_patch()