Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

6.4 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Up-front pinned slabs come from registered host memory; ``UNSLOTH_DIFFUSION_REGISTERED_SLABS=0`` restores torch's."""

import numpy as np
import pytest
import torch

from core.inference import diffusion_memory as dm
from core.inference import diffusion_pinned_arena as arena_mod


class _FakeHolder:
    """CPU-only stand-in for ``_RegisteredHostBuffer``."""

    made: list = []

    def __init__(self, nbytes):
        self._arr = np.full(int(nbytes), 7, dtype = np.uint8)  # dirty, so the zero fill is observable
        self.__array_interface__ = self._arr.__array_interface__
        self.registered_after_zero = None
        _FakeHolder.made.append(self)

    def register(self):
        self.registered_after_zero = bool((self._arr == 0).all())


@pytest.fixture
def fake_registered(monkeypatch):
    _FakeHolder.made = []
    monkeypatch.delenv(dm.REGISTERED_SLAB_ENV, raising = False)
    monkeypatch.setattr(dm, "_fast_pin_supported", lambda: True)
    monkeypatch.setattr(dm, "_RegisteredHostBuffer", _FakeHolder)
    return _FakeHolder.made


def test_registered_pinned_empty_zero_fills_before_registering(fake_registered):
    buf = dm.registered_pinned_empty(4096)
    assert buf is not None and buf.dtype == torch.uint8 and buf.numel() == 4096
    assert len(fake_registered) == 1 and fake_registered[0].registered_after_zero is True
    assert int(buf.sum()) == 0


@pytest.mark.parametrize("value", ["0", "off", "false", "no"])
def test_kill_switch_restores_the_pinned_allocator(fake_registered, monkeypatch, value):
    monkeypatch.setenv(dm.REGISTERED_SLAB_ENV, value)
    assert dm.registered_pinned_empty(4096) is None
    assert fake_registered == []


def test_unsupported_host_or_refused_registration_falls_back(fake_registered, monkeypatch):
    monkeypatch.setattr(dm, "_fast_pin_supported", lambda: False)
    assert dm.registered_pinned_empty(4096) is None
    monkeypatch.setattr(dm, "_fast_pin_supported", lambda: True)

    def refuse(self):
        raise RuntimeError("cudaHostRegister failed")

    monkeypatch.setattr(_FakeHolder, "register", refuse)
    assert dm.registered_pinned_empty(4096) is None
    assert dm.registered_pinned_empty(0) is None


def test_arena_slabs_come_from_registered_memory(fake_registered):
    weights = [
        torch.randn(64, 32),
        torch.arange(100, dtype = torch.int8),
        torch.randn(7, dtype = torch.float16),
    ]
    arena = arena_mod.PinnedArena(slab_bytes = 1 << 14)
    copies = [arena.pin(w) for w in weights]
    assert len(fake_registered) == len(arena._slabs) >= 1
    slab_ptrs = {s.untyped_storage().data_ptr() for s, _ in arena._slabs}
    for w, c in zip(weights, copies):
        assert torch.equal(w, c)
        assert c.untyped_storage().data_ptr() in slab_ptrs


def test_arena_uses_torch_pinned_allocator_when_registration_is_off(fake_registered, monkeypatch):
    monkeypatch.setenv(dm.REGISTERED_SLAB_ENV, "0")
    seen = []

    def fake_empty(
        n,
        dtype = None,
        pin_memory = False,
    ):
        seen.append(pin_memory)
        return torch.zeros(n, dtype = dtype)

    monkeypatch.setattr(torch, "empty", fake_empty)
    arena_mod._alloc_slab(1 << 12)
    assert seen == [True] and fake_registered == []


def test_h3_conditioner_pin_in_place_uses_registered_arenas(fake_registered):
    from core.inference.video_minimax_h3_te import pin_module_in_place

    m = torch.nn.Sequential(torch.nn.Linear(16, 32), torch.nn.Linear(32, 8))
    m.register_buffer("q", torch.arange(64, dtype = torch.int8).view(8, 8))
    expect = {k: v.detach().clone() for k, v in m.state_dict().items()}
    pinned = pin_module_in_place(m, arena_bytes = 1 << 14)
    assert pinned == sum(t.numel() * t.element_size() for t in expect.values())
    assert len(fake_registered) == 1
    for k, v in m.state_dict().items():
        assert torch.equal(v, expect[k]), k


def test_h3_conditioner_pin_fills_each_arena_before_registering(fake_registered, monkeypatch):
    """The copies write the arena before it is registered (they fault its pages, no separate zero pass); the bytes
    no tensor uses are zeroed, as the zero fill left them."""
    from core.inference import video_minimax_h3_te as te

    zeroed = []
    real_zero = torch.Tensor.zero_
    monkeypatch.setattr(
        torch.Tensor, "zero_", lambda self: (zeroed.append(self.numel()), real_zero(self))[1]
    )
    m = torch.nn.Sequential(torch.nn.Linear(16, 32), torch.nn.Linear(32, 8))
    m.register_buffer("q", torch.arange(-32, 32, dtype = torch.int8).view(8, 8))
    expect = {k: v.detach().clone() for k, v in m.state_dict().items()}
    seen = {}

    def register(holder):
        seen[id(holder)] = holder._arr.copy()

    monkeypatch.setattr(_FakeHolder, "register", register)
    te.pin_module_in_place(m, arena_bytes = 1 << 14)
    assert len(fake_registered) == 1
    arr = fake_registered[0]._arr
    assert np.array_equal(seen[id(fake_registered[0])], arr), "registered before the copies landed"
    for k, v in m.state_dict().items():
        assert torch.equal(v, expect[k]), k
    unused = np.ones(arr.size, dtype = bool)
    base = arr.ctypes.data
    for v in m.state_dict().values():
        start = v.data_ptr() - base
        unused[start : start + v.numel() * v.element_size()] = False
    assert sum(zeroed) == unused.sum() > 0
    assert not arr[unused].any(), "a byte no tensor uses kept the dirty fill"


def test_registered_fill_errors_propagate(fake_registered):
    def boom(buf):
        raise RuntimeError("copy failed")

    with pytest.raises(RuntimeError, match = "copy failed"):
        dm.registered_pinned_empty(4096, fill = boom)
    buf = dm.registered_pinned_empty(4096, fill = lambda b: b.fill_(3))
    assert bool((buf == 3).all()) and fake_registered[-1].registered_after_zero is False


@pytest.mark.skipif(not torch.cuda.is_available(), reason = "needs CUDA")
def test_real_registered_slab_is_pinned_and_uploads_exactly(monkeypatch):
    monkeypatch.delenv(dm.REGISTERED_SLAB_ENV, raising = False)
    if not dm._fast_pin_supported():
        pytest.skip("registered pinning unsupported on this host")
    buf = dm.registered_pinned_empty(1 << 20)
    assert buf is not None and buf.is_pinned()
    src = torch.randint(0, 255, (1 << 20,), dtype = torch.uint8)
    buf.copy_(src)
    dev = buf.to("cuda", non_blocking = True)
    torch.cuda.synchronize()
    assert torch.equal(dev.cpu(), src)