Skip to content

A GPU task manager for Windows, Linux, and WSL: per-process VRAM, GPU activity, and LLM model/KV-cache insights (Windows AMD and NVIDIA).

Python
6.6 KB
Raw Blame
from pathlib import Path
import struct
import tempfile
import unittest
import zipfile
import hashlib

import os
import stat
import tarfile

from tools.build_portable import (architecture, check_elf, check_executable, create_archive, create_linux_archive,
                                  nvidia_license, target, validate_version)


class PortableTests(unittest.TestCase):
    def write_executable(self, path, machine):
        header = bytearray(64)
        header[:2] = b"MZ"
        struct.pack_into("<I", header, 60, 64)
        path.write_bytes(header + b"PE\0\0" + struct.pack("<H", machine))

    def test_interpreter_architecture_not_host_architecture(self):
        self.assertEqual(architecture("win-amd64"), "x64")
        self.assertEqual(architecture("win-arm64"), "arm64")
        with self.assertRaises(ValueError):
            architecture("win32")

    def test_version_and_tag(self):
        validate_version("0.1.0", "v0.1.0")
        with self.assertRaises(ValueError):
            validate_version("0.1.0", "v0.2.0")
        with self.assertRaises(ValueError):
            validate_version("..\\outside")

    def test_inline_nvidia_license_is_preserved(self):
        notice = "#####\n# Copyright Example\n# Redistribution and use are permitted.\n#####\n"
        self.assertEqual(nvidia_license(notice + "import ctypes\n"), notice)
        with self.assertRaises(ValueError):
            nvidia_license("import ctypes\n")

    def test_executable_machine(self):
        with tempfile.TemporaryDirectory() as temporary:
            exe = Path(temporary) / "gputaskman.exe"
            for arch, machine in [("x64", 0x8664), ("arm64", 0xAA64)]:
                self.write_executable(exe, machine)
                check_executable(exe, arch)
            with self.assertRaises(ValueError):
                check_executable(exe, "x64")
            exe.write_bytes(b"not an exe")
            with self.assertRaises(ValueError):
                check_executable(exe, "x64")

    def test_archive_includes_complete_runtime_and_checksum(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            bundle = root / "bundle"
            (bundle / "_internal").mkdir(parents=True)
            self.write_executable(bundle / "gputaskman.exe", 0x8664)
            (bundle / "_internal" / "data.css").write_text("resource", encoding="utf-8")
            install_metadata = bundle / "_internal" / "gputaskman-0.1.0.dist-info"
            install_metadata.mkdir()
            (install_metadata / "direct_url.json").write_text(
                '{"url": "file:///private-build-path"}', encoding="utf-8",
            )
            archive = create_archive(bundle, root / "output", "0.1.0", "x64")
            with zipfile.ZipFile(archive) as zipped:
                self.assertEqual(set(zipped.namelist()), {
                    "gputaskman-0.1.0-windows-x64/gputaskman.exe",
                    "gputaskman-0.1.0-windows-x64/_internal/data.css",
                })
            expected = hashlib.sha256(archive.read_bytes()).hexdigest()
            self.assertEqual(
                archive.with_suffix(".zip.sha256").read_text(encoding="utf-8"),
                f"{expected}  {archive.name}\n",
            )

    def test_archive_rejects_driver_dlls(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            self.write_executable(root / "gputaskman.exe", 0xAA64)
            for dll in ("NVML.dll", "atiadlxx.dll", "amd_smi.dll"):
                (root / dll).write_bytes(b"driver")
                with self.assertRaisesRegex(ValueError, "must not be distributed"):
                    create_archive(root, root / "output", "0.1.0", "arm64")
                os.remove(root / dll)


class LinuxPortableTests(unittest.TestCase):
    def write_elf(self, path, machine):
        header = bytearray(64)
        header[:4] = b"\x7fELF"
        header[4], header[5] = 2, 1  # 64-bit, little-endian
        struct.pack_into("<H", header, 18, machine)
        path.write_bytes(bytes(header))
        path.chmod(0o755)

    def test_linux_interpreters_map_to_targets(self):
        self.assertEqual(target("linux-x86_64"), ("linux", "x64"))
        self.assertEqual(target("linux-aarch64"), ("linux", "arm64"))
        self.assertEqual(architecture("linux-x86_64"), "x64")
        with self.assertRaises(ValueError):
            target("linux-i686")

    def test_elf_machine(self):
        with tempfile.TemporaryDirectory() as temporary:
            exe = Path(temporary) / "gputaskman"
            for arch, machine in [("x64", 0x3E), ("arm64", 0xB7)]:
                self.write_elf(exe, machine)
                check_elf(exe, arch)
            with self.assertRaises(ValueError):
                check_elf(exe, "x64")
            exe.write_bytes(b"MZ not an elf")
            with self.assertRaises(ValueError):
                check_elf(exe, "x64")

    def test_tarball_keeps_executable_bit_and_has_checksum(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            bundle = root / "bundle"
            (bundle / "_internal").mkdir(parents=True)
            self.write_elf(bundle / "gputaskman", 0x3E)
            (bundle / "_internal" / "data.css").write_text("resource", encoding="utf-8")
            archive = create_linux_archive(bundle, root / "output", "0.1.0", "x64")
            self.assertEqual(archive.name, "gputaskman-0.1.0-linux-x64.tar.gz")
            with tarfile.open(archive) as packed:
                members = {m.name: m for m in packed.getmembers()}
            self.assertEqual(set(members), {"gputaskman-0.1.0-linux-x64/gputaskman",
                                            "gputaskman-0.1.0-linux-x64/_internal/data.css"})
            self.assertTrue(members["gputaskman-0.1.0-linux-x64/gputaskman"].mode & stat.S_IXUSR)
            self.assertEqual(members["gputaskman-0.1.0-linux-x64/gputaskman"].uid, 0)
            expected = hashlib.sha256(archive.read_bytes()).hexdigest()
            self.assertEqual(Path(f"{archive}.sha256").read_text(encoding="utf-8"), f"{expected}  {archive.name}\n")

    def test_tarball_rejects_driver_libraries(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            self.write_elf(root / "gputaskman", 0x3E)
            for lib in ("libnvidia-ml.so.1", "libcuda.so.1", "libamd_smi.so.0"):
                (root / lib).write_bytes(b"driver")
                with self.assertRaisesRegex(ValueError, "must not be distributed"):
                    create_linux_archive(root, root / "output", "0.1.0", "x64")
                os.remove(root / lib)


if __name__ == "__main__":
    unittest.main()