268 lines
8.6 KiB
Python
268 lines
8.6 KiB
Python
import gc
|
|
import io
|
|
import sys
|
|
import unittest
|
|
from array import array
|
|
from unittest import mock
|
|
|
|
import torch
|
|
from PIL import Image
|
|
|
|
from sglang.srt.utils.common import (
|
|
_get_device_sm_via_nvml,
|
|
_load_image,
|
|
flatten_arrays_to_int64_tensor,
|
|
freeze_gc,
|
|
get_device_sm_nvidia_smi,
|
|
get_nvidia_driver_version_str,
|
|
)
|
|
from sglang.test.ci.ci_register import (
|
|
register_amd_ci,
|
|
register_cpu_ci,
|
|
register_cuda_ci,
|
|
)
|
|
from sglang.test.test_utils import CustomTestCase
|
|
|
|
register_cpu_ci(est_time=1, suite="base-a-test-cpu")
|
|
register_cuda_ci(est_time=10, stage="base-b", runner_config="1-gpu-small")
|
|
register_amd_ci(est_time=5, stage="stage-b", runner_config="1-gpu-small-amd")
|
|
|
|
|
|
@unittest.skipUnless(torch.cuda.is_available(), "requires CUDA")
|
|
class TestFlattenArraysToInt64Tensor(CustomTestCase):
|
|
"""`flatten_arrays_to_int64_tensor` is invoked by `prepare_for_extend`
|
|
to build the per-batch input_ids tensor (pinned, async H2D) from a
|
|
list of array.array('q') per-req get_fill_ids() slices. Tests the
|
|
full matrix of (device, pin) the production code paths through.
|
|
"""
|
|
|
|
DEVICES = ("cpu", "cuda")
|
|
PIN_OPTIONS = (False, True)
|
|
|
|
def _check(self, parts: list, expected: list[int]) -> None:
|
|
for device in self.DEVICES:
|
|
for pin in self.PIN_OPTIONS:
|
|
with self.subTest(device=device, pin=pin):
|
|
out = flatten_arrays_to_int64_tensor(parts, device, pin)
|
|
if device == "cuda":
|
|
torch.cuda.synchronize()
|
|
self.assertEqual(out.dtype, torch.int64)
|
|
self.assertEqual(out.device.type, device)
|
|
self.assertEqual(out.shape, (len(expected),))
|
|
self.assertEqual(out.cpu().tolist(), expected)
|
|
|
|
def test_single_part(self):
|
|
parts = [array("q", [1, 2, 3, 4, 5])]
|
|
self._check(parts, [1, 2, 3, 4, 5])
|
|
|
|
def test_multiple_parts(self):
|
|
parts = [
|
|
array("q", [10, 20, 30]),
|
|
array("q", [100, 200]),
|
|
array("q", [1000]),
|
|
]
|
|
self._check(parts, [10, 20, 30, 100, 200, 1000])
|
|
|
|
|
|
class TestNvidiaDriverVersionStr(CustomTestCase):
|
|
"""`get_nvidia_driver_version_str` is typed as `str | None`: it returns
|
|
`None` when nvidia-smi is missing, fails, or emits an empty string. These
|
|
tests exercise both the success and the None-return paths by monkey-
|
|
patching `subprocess.run`, so they don't require a GPU. The function is
|
|
`@lru_cache`d, so the cache is cleared around each test to make the patch
|
|
observable.
|
|
"""
|
|
|
|
def setUp(self):
|
|
get_nvidia_driver_version_str.cache_clear()
|
|
|
|
def tearDown(self):
|
|
get_nvidia_driver_version_str.cache_clear()
|
|
|
|
def test_returns_version_string(self):
|
|
import subprocess
|
|
|
|
class _R:
|
|
stdout = "595.58.03\n"
|
|
|
|
original = subprocess.run
|
|
subprocess.run = lambda *a, **k: _R()
|
|
try:
|
|
self.assertEqual(get_nvidia_driver_version_str(), "595.58.03")
|
|
finally:
|
|
subprocess.run = original
|
|
|
|
def test_returns_none_on_empty_output(self):
|
|
import subprocess
|
|
|
|
class _R:
|
|
stdout = "\n"
|
|
|
|
original = subprocess.run
|
|
subprocess.run = lambda *a, **k: _R()
|
|
try:
|
|
self.assertIsNone(get_nvidia_driver_version_str())
|
|
finally:
|
|
subprocess.run = original
|
|
|
|
def test_returns_none_on_called_process_error(self):
|
|
import subprocess
|
|
|
|
original = subprocess.run
|
|
|
|
def boom(*a, **k):
|
|
raise subprocess.CalledProcessError(1, "nvidia-smi")
|
|
|
|
subprocess.run = boom
|
|
try:
|
|
self.assertIsNone(get_nvidia_driver_version_str())
|
|
finally:
|
|
subprocess.run = original
|
|
|
|
def test_returns_none_on_file_not_found(self):
|
|
import subprocess
|
|
|
|
original = subprocess.run
|
|
|
|
def boom(*a, **k):
|
|
raise FileNotFoundError("nvidia-smi")
|
|
|
|
subprocess.run = boom
|
|
try:
|
|
self.assertIsNone(get_nvidia_driver_version_str())
|
|
finally:
|
|
subprocess.run = original
|
|
|
|
|
|
class TestGetDeviceSmNvidiaSmi(CustomTestCase):
|
|
"""`get_device_sm_nvidia_smi` parses nvidia-smi output into a (major,
|
|
minor) tuple and falls back to (0, 0) -- logging via `logger.error` --
|
|
when nvidia-smi fails. The success path needs a GPU; the fallback path is
|
|
covered here by forcing a failure and asserting the (0, 0) return. The
|
|
fallback path needs no GPU, so this test runs on CPU.
|
|
"""
|
|
|
|
def test_fallback_on_failure_returns_zero_zero(self):
|
|
import subprocess
|
|
|
|
original = subprocess.run
|
|
|
|
def boom(*a, **k):
|
|
raise subprocess.CalledProcessError(1, "nvidia-smi")
|
|
|
|
subprocess.run = boom
|
|
try:
|
|
self.assertEqual(get_device_sm_nvidia_smi(), (0, 0))
|
|
finally:
|
|
subprocess.run = original
|
|
|
|
|
|
class TestLoadImage(CustomTestCase):
|
|
def test_corrupt_image_bytes_raise_value_error(self):
|
|
buf = io.BytesIO()
|
|
Image.new("RGB", (16, 16), (10, 120, 200)).save(buf, format="PNG")
|
|
valid_png = buf.getvalue()
|
|
|
|
broken_chunk_png = bytearray(valid_png)
|
|
idat_pos = broken_chunk_png.index(b"IDAT")
|
|
broken_chunk_png[idat_pos - 1] -= 6
|
|
|
|
img = _load_image(image_bytes=valid_png, gpu_image_decode=False)
|
|
self.assertEqual(img.size, (16, 16))
|
|
|
|
cases = [
|
|
b"not an image",
|
|
b"",
|
|
valid_png[: len(valid_png) // 2],
|
|
bytes(broken_chunk_png),
|
|
]
|
|
for image_bytes in cases:
|
|
with self.subTest(length=len(image_bytes)):
|
|
with self.assertRaisesRegex(ValueError, "Could not decode image"):
|
|
_load_image(
|
|
image_bytes=image_bytes,
|
|
gpu_image_decode=False,
|
|
)
|
|
|
|
|
|
class _FakePynvml:
|
|
"""Records the NVML index it was asked for, so a test can tell which
|
|
physical GPU the helper would have reported."""
|
|
|
|
def __init__(self, capability=(9, 0)):
|
|
self.capability = capability
|
|
self.requested_index = None
|
|
self.initialized = False
|
|
|
|
def nvmlInit(self):
|
|
self.initialized = True
|
|
|
|
def nvmlShutdown(self):
|
|
pass
|
|
|
|
def nvmlDeviceGetHandleByIndex(self, index):
|
|
self.requested_index = index
|
|
return f"handle-{index}"
|
|
|
|
def nvmlDeviceGetCudaComputeCapability(self, handle):
|
|
return self.capability
|
|
|
|
|
|
class TestGetDeviceSmViaNvml(CustomTestCase):
|
|
"""The torch ordinal and the NVML index differ under CUDA_VISIBLE_DEVICES
|
|
and MIG; without that mapping the helper must return None, not GPU 0."""
|
|
|
|
def test_torch_exposes_the_mapping_api(self):
|
|
# The cases below install the private attribute themselves, so they stay
|
|
# green on a torch that dropped it while the helper silently falls back.
|
|
self.assertTrue(hasattr(torch.cuda, "_get_nvml_device_index"))
|
|
|
|
def test_maps_the_torch_ordinal_to_the_nvml_index(self):
|
|
fake = _FakePynvml(capability=(9, 0))
|
|
with (
|
|
mock.patch.dict(sys.modules, {"pynvml": fake}),
|
|
mock.patch.object(
|
|
torch.cuda, "_get_nvml_device_index", lambda index: 3, create=True
|
|
),
|
|
):
|
|
self.assertEqual(_get_device_sm_via_nvml(), 90)
|
|
self.assertEqual(fake.requested_index, 3)
|
|
|
|
def test_returns_none_when_the_mapping_api_is_absent(self):
|
|
fake = _FakePynvml()
|
|
saved = torch.cuda.__dict__.pop("_get_nvml_device_index", None)
|
|
try:
|
|
with mock.patch.dict(sys.modules, {"pynvml": fake}):
|
|
self.assertIsNone(_get_device_sm_via_nvml())
|
|
finally:
|
|
if saved is not None:
|
|
torch.cuda._get_nvml_device_index = saved
|
|
self.assertFalse(fake.initialized, "must not query NVML without the mapping")
|
|
|
|
def test_returns_none_when_the_mapping_api_raises(self):
|
|
fake = _FakePynvml()
|
|
|
|
def boom(index):
|
|
raise RuntimeError("no such device")
|
|
|
|
with (
|
|
mock.patch.dict(sys.modules, {"pynvml": fake}),
|
|
mock.patch.object(torch.cuda, "_get_nvml_device_index", boom, create=True),
|
|
):
|
|
self.assertIsNone(_get_device_sm_via_nvml())
|
|
self.assertFalse(fake.initialized, "must not query NVML without the mapping")
|
|
|
|
|
|
class TestFreezeGc(CustomTestCase):
|
|
def setUp(self):
|
|
self.addCleanup(gc.set_threshold, *gc.get_threshold())
|
|
self.addCleanup(gc.unfreeze)
|
|
|
|
def test_applies_configured_threshold(self):
|
|
freeze_gc("test", [700, 10, 1000])
|
|
self.assertEqual(gc.get_threshold(), (700, 10, 1000))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|