jambu-gpu 0.3.0__tar.gz → 0.3.1__tar.gz

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jambu-gpu
-Version: 0.3.0
+Version: 0.3.1
 Summary: Provider-agnostic CLI for provisioning and managing temporary GPU runtimes
 Project-URL: Homepage, https://github.com/jambuai/jambu-gpu
 Project-URL: Repository, https://github.com/jambuai/jambu-gpu

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/docs/CONFIG.md

@@ -86,6 +86,7 @@ each number comes from.
 | `gpu.count` | `1` | Number of GPUs on one machine. |
 | `gpu.name_filter` | – | Substring match, e.g. `A100`, `RTX 4090`. |
 | `gpu.cuda_min` | – | Minimum host CUDA version. `gpu` raises it to what the runtime image needs, read from its tag (`-cu129` means 12.9, vLLM's bare `v0.32+` and `latest` mean 13.0), so an image never lands on a driver too old to run it. |
+| `gpu.compute_cap_min` | – | Minimum GPU **compute capability** (architecture), e.g. `8.0` for Ampere. Distinct from `cuda_min`: a Pascal (GTX 10xx, 6.1) or Volta (V100, 7.0) card can sit behind a modern CUDA-13 driver — clearing `cuda_min` — yet still be too old for a runtime image whose kernels are built for newer architectures, which then crashes at engine startup. `gpu` raises this to what the runtime needs: a CUDA-13 vLLM image floors it at `8.0` (those wheels drop Volta), a CUDA-12 vLLM image at `7.0`. The cheapest Vast offers are often exactly these old cards, so without the floor the search keeps picking a GPU the image cannot run. |
 | `disk_gb` | `80` | Disk. Must fit the model weights plus the container. |
 | `region` | – | Comma-separated geolocations. |
 | `spot` | `false` | Use interruptible/bid capacity where supported. |

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/__init__.py

@@ -1,5 +1,5 @@
 """gpu: provider-agnostic GPU runtime provisioning and lifecycle CLI."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 __all__ = ["__version__"]

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/core/config.py

@@ -79,6 +79,11 @@ class GpuConfig(_Base):
     count: int = 1
     name_filter: Optional[str] = None
     cuda_min: Optional[str] = None
+    # Minimum GPU compute capability (architecture), e.g. 8.0 to require
+    # Ampere or newer. Raised to what the runtime needs; see
+    # ModelRuntime.required_compute_cap. Leave unset to accept the runtime's
+    # own floor.
+    compute_cap_min: Optional[float] = None
 
     @field_validator("count")
     @classmethod

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/core/engine.py

@@ -366,6 +366,7 @@ class Engine:
                 count=cfg.compute.gpu.count,
                 name_filter=cfg.compute.gpu.name_filter,
                 cuda_min=self.cuda_min(),
+                compute_cap_min=self.compute_cap_min(),
             ),
             disk_gb=cfg.compute.disk_gb,
             image=self.runtime.image(),
@@ -389,6 +390,18 @@ class Engine:
             return configured
         return f"{needed:.1f}"
 
+    def compute_cap_min(self) -> Optional[float]:
+        """The stricter of compute.gpu.compute_cap_min and the runtime's floor."""
+        candidates = [
+            c
+            for c in (
+                self.config.compute.gpu.compute_cap_min,
+                self.runtime.required_compute_cap(),
+            )
+            if c is not None
+        ]
+        return max(candidates) if candidates else None
+
     def _ports(self) -> list[int]:
         ports = list(self.runtime.ports())
         if self.config.lifecycle.watchdog.enabled:

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/core/models.py

@@ -91,6 +91,11 @@ class GpuSpec:
     count: int = 1
     name_filter: Optional[str] = None
     cuda_min: Optional[str] = None
+    # Minimum GPU compute capability (architecture), e.g. 8.0 for Ampere. The
+    # host driver's CUDA (``cuda_min``) is not the same thing: a Pascal/Volta
+    # card can sit behind a CUDA-13 driver yet still be too old for a runtime
+    # image built for newer architectures, which then dies at engine startup.
+    compute_cap_min: Optional[float] = None
 
 
 @dataclass
@@ -127,6 +132,9 @@ class Offer:
     score: Optional[float] = None
     # Highest CUDA version the host's driver supports, when the provider says.
     cuda_max: Optional[float] = None
+    # The GPU's compute capability (architecture), e.g. 8.6 for an RTX 3090,
+    # when the provider says. Distinct from cuda_max (the driver's CUDA).
+    compute_cap: Optional[float] = None
     # The physical machine behind the offer, when the provider says. Offers
     # on one machine share its network, disk and Docker daemon.
     host_id: Optional[str] = None

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/providers/vast/mapper.py

@@ -82,6 +82,12 @@ def _float_or_none(value: Any) -> Optional[float]:
         return None
 
 
+def _compute_cap(value: Any) -> Optional[float]:
+    """Vast's ``compute_cap`` is capability ×100 (860 → 8.6); normalize it."""
+    raw = _float_or_none(value)
+    return raw / 100.0 if raw else None
+
+
 def effective_min_cuda(spec: ComputeSpec, options: VastOptions) -> Optional[float]:
     """The stricter of the adapter's floor and what the spec (image) needs."""
     known = [
@@ -110,6 +116,8 @@ def map_offer(raw: dict[str, Any]) -> Offer:
         score=float(raw.get("score") or 0.0) if raw.get("score") is not None else None,
         # Highest CUDA the host driver runs; an image needing more dies at boot.
         cuda_max=_float_or_none(raw.get("cuda_max_good")),
+        # Vast reports compute capability ×100 (860 = 8.6); normalize to 8.6.
+        compute_cap=_compute_cap(raw.get("compute_cap")),
         host_id=host_id(raw),
         raw=raw,
     )
@@ -193,6 +201,12 @@ def build_search_query(
     min_cuda = effective_min_cuda(spec, options)
     if min_cuda:
         query["cuda_max_good"] = {"gte": min_cuda}
+    # Floor the GPU architecture, not just the driver's CUDA: Vast reports
+    # compute capability ×100, so 8.0 -> 800. Without this the cheapest offers
+    # (old Volta/Pascal cards behind modern drivers) pass cuda_max_good but
+    # crash a newer runtime image at engine startup.
+    if spec.gpu.compute_cap_min:
+        query["compute_cap"] = {"gte": int(round(float(spec.gpu.compute_cap_min) * 100))}
     # gpu_name is deliberately NOT sent server-side: Vast's field only
     # accepts an exact match ({"eq": ...}), but name_filter is documented and
     # used everywhere else (offer_matches below) as a case-insensitive
@@ -258,6 +272,10 @@ def offer_matches(offer: Offer, spec: ComputeSpec, min_cuda: Optional[float] = N
     # 1e-6: 12.9 must match a host reporting exactly 12.9.
     if min_cuda and offer.cuda_max is not None and offer.cuda_max + 1e-6 < min_cuda:
         return False
+    # Vast's compute_cap filter is advisory; verify the architecture floor too.
+    min_cc = spec.gpu.compute_cap_min
+    if min_cc and offer.compute_cap is not None and offer.compute_cap + 1e-6 < float(min_cc):
+        return False
     if offer.gpu_count < spec.gpu.count:
         return False
     if spec.gpu.min_vram_gb and offer.gpu_vram_gb + 0.5 < float(spec.gpu.min_vram_gb):

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/runtime/base.py

@@ -116,6 +116,16 @@ class ModelRuntime(ABC):
         """
         return cuda_from_tag(image_tag(self.image()))
 
+    def required_compute_cap(self) -> Optional[float]:
+        """Minimum GPU compute capability (architecture) the runtime needs.
+
+        None if unknown. The offer filter is raised to this, so an image whose
+        kernels are built for newer architectures is never placed on a GPU too
+        old to run them (which the host driver's CUDA alone does not catch: a
+        Volta card behind a CUDA-13 driver still fails at engine startup).
+        """
+        return None
+
     # -- on-instance liveness -------------------------------------------------
 
     def runtime_pid_path(self) -> Optional[str]:

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/jambu_gpu/runtime/vllm.py

@@ -123,6 +123,16 @@ class VllmRuntime(ModelRuntime):
     def required_cuda(self) -> Optional[float]:
         return vllm_image_cuda(self.image())
 
+    def required_compute_cap(self) -> Optional[float]:
+        # vLLM wheels built for CUDA 13+ drop Volta (sm_70) and need Ampere
+        # (8.0) or newer; those crash at engine-core init on a V100 or older.
+        # CUDA 12.x wheels still run Volta. Pascal (GTX 10xx, 6.1) is below
+        # vLLM's floor on any build.
+        cuda = self.required_cuda()
+        if cuda is None:
+            return None
+        return 8.0 if cuda >= 13.0 else 7.0
+
     def runtime_pid_path(self) -> str:
         return PID_PATH
 

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "jambu-gpu"
-version = "0.3.0"
+version = "0.3.1"
 description = "Provider-agnostic CLI for provisioning and managing temporary GPU runtimes"
 readme = "README.md"
 requires-python = ">=3.10"

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/tests/test_engine.py

@@ -462,6 +462,18 @@ def test_an_image_of_unknown_cuda_keeps_the_configured_floor(write_config):
     assert _engine(write_config, compute=pinned).build_spec().gpu.cuda_min == "12.4"
 
 
+def test_the_spec_floors_the_gpu_architecture_the_runtime_needs(write_config):
+    # Default CUDA-13 vLLM image -> Ampere (8.0).
+    assert _engine(write_config).build_spec().gpu.compute_cap_min == 8.0
+
+
+def test_a_stricter_configured_compute_cap_wins_and_a_looser_one_loses(write_config):
+    strict = _engine(write_config, compute={"gpu": {"compute_cap_min": 8.9}})
+    assert strict.build_spec().gpu.compute_cap_min == 8.9  # e.g. force Ada
+    loose = _engine(write_config, compute={"gpu": {"compute_cap_min": 7.0}})
+    assert loose.build_spec().gpu.compute_cap_min == 8.0  # runtime floor still wins
+
+
 def test_validate_warns_about_an_unpinned_image(write_config):
     for image in ("vllm/vllm-openai:latest", "vllm/vllm-openai"):
         result = _engine(write_config, compute={"image": image}).validate(check_provider=False)

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/tests/test_runtime_vllm.py

@@ -241,6 +241,19 @@ def test_vast_published_vllm_images_carry_their_cuda(write_config):
         assert VllmRuntime(write_config(compute={"image": image})).required_cuda() == cuda
 
 
+def test_a_vllm_image_floors_the_gpu_architecture(write_config):
+    """CUDA-13 vLLM wheels drop Volta and need Ampere (8.0); 12.x still runs Volta (7.0).
+
+    Caught on a live run: the CUDA-13 image kept landing on the cheapest offers
+    (V100, GTX 1080) whose driver cleared cuda_max_good but whose architecture
+    crashed vLLM's engine-core init."""
+    assert VllmRuntime(write_config(compute={"image": "vastai/vllm:v0.32.0-cuda-13.0"})).required_compute_cap() == 8.0
+    assert VllmRuntime(write_config(compute={"image": "vllm/vllm-openai:v0.32.0"})).required_compute_cap() == 8.0
+    assert VllmRuntime(write_config(compute={"image": "vastai/vllm:v0.29.0-cuda-12.9"})).required_compute_cap() == 7.0
+    # Unknown image CUDA -> no architecture claim.
+    assert VllmRuntime(write_config(compute={"image": "vllm/vllm-openai:nightly"})).required_compute_cap() is None
+
+
 def test_the_start_command_finds_the_python_that_has_vllm(config, tmp_path):
     """vastai/vllm puts a shim first on PATH; vllm lives under /usr/bin/python3."""
     import subprocess

{jambu_gpu-0.3.0 → jambu_gpu-0.3.1}/tests/test_vast_mapper.py

@@ -122,13 +122,18 @@ def test_unknown_provider_options_are_rejected_early():
 # -- CUDA: the image's floor and the adapter's floor, whichever is higher -----
 
 
-def _spec(cuda_min=None):
-    return ComputeSpec(gpu=GpuSpec(min_vram_gb=24, cuda_min=cuda_min), disk_gb=80)
+def _spec(cuda_min=None, compute_cap_min=None):
+    return ComputeSpec(
+        gpu=GpuSpec(min_vram_gb=24, cuda_min=cuda_min, compute_cap_min=compute_cap_min),
+        disk_gb=80,
+    )
 
 
-def _offer(cuda):
+def _offer(cuda, compute_cap=None):
     raw = {"id": 1, "gpu_name": "RTX 4090", "num_gpus": 1, "gpu_ram": 24564,
            "disk_space": 100, "dph_total": 0.3, "cuda_max_good": cuda}
+    if compute_cap is not None:
+        raw["compute_cap"] = compute_cap
     return mapper.map_offer(raw)
 
 
@@ -159,6 +164,33 @@ def test_a_host_whose_driver_is_too_old_for_the_image_is_rejected_client_side():
     assert mapper.offer_matches(_offer(12.0), _spec())
 
 
+def test_offers_carry_the_gpus_compute_capability():
+    # Vast reports compute_cap ×100 (860 = 8.6); we normalize it.
+    assert _offer(13.0, compute_cap=860).compute_cap == 8.6
+    assert _offer(13.0, compute_cap=700).compute_cap == 7.0
+    assert _offer(13.0).compute_cap is None
+
+
+def test_the_search_floors_the_gpu_architecture():
+    # ×100 the way Vast stores it: 8.0 -> 800.
+    opts = VastOptions()
+    assert mapper.build_search_query(_spec(compute_cap_min=8.0), opts)["compute_cap"] == {"gte": 800}
+    assert mapper.build_search_query(_spec(compute_cap_min=7.0), opts)["compute_cap"] == {"gte": 700}
+    assert "compute_cap" not in mapper.build_search_query(_spec(), opts)
+
+
+def test_a_gpu_too_old_for_the_image_is_rejected_client_side():
+    """Caught on a live run: a CUDA-13 vLLM image landed on a V100/GTX 1080
+    (whose driver cleared cuda_max_good) and crashed at engine startup."""
+    spec = _spec(compute_cap_min=8.0)
+    assert not mapper.offer_matches(_offer(13.0, compute_cap=700), spec)  # V100 (7.0)
+    assert not mapper.offer_matches(_offer(13.0, compute_cap=610), spec)  # GTX 1080 (6.1)
+    assert mapper.offer_matches(_offer(13.0, compute_cap=860), spec)      # RTX 3090 (8.6)
+    assert mapper.offer_matches(_offer(13.0, compute_cap=800), spec)      # exactly 8.0
+    assert mapper.offer_matches(_offer(13.0), spec)  # unknown: trust the server filter
+    assert mapper.offer_matches(_offer(13.0, compute_cap=700), _spec())   # no floor set
+
+
 def test_find_offers_applies_the_effective_floor(monkeypatch):
     from jambu_gpu.providers.vast.provider import VastProvider