fix(capacity): preserve CPU advice when GPU data is unknown

Author: HaoZeke

.github/workflows/ci_test.yml

@@ -200,6 +200,7 @@ jobs:
             --test stack_shadow \
             --test stack_shard \
             --test inode_footprints_snapshot \
+            --test planning_capacity \
             --test stack_shard_destinations \
             --test stack_admit \
             --test admission_forecast_lifecycle \

src/planning_capacity.rs

@@ -149,14 +149,19 @@ fn resource_pair(
 }
 
 impl Node {
-    fn resources(&self) -> Option<(Resources, Resources)> {
+    fn resources(&self, require_gpu: bool) -> Option<(Resources, Resources, bool)> {
         let cpu = resource_pair(self.cpus_total, self.cpus_allocatable, self.cpus_allocated)?;
         let mem = resource_pair(
             self.memory_mib_total,
             self.memory_mib_allocatable,
             self.memory_mib_allocated,
         )?;
-        let gpu = resource_pair(self.gpus_total, self.gpus_allocatable, self.gpus_allocated)?;
+        let gpu = resource_pair(self.gpus_total, self.gpus_allocatable, self.gpus_allocated);
+        if require_gpu && gpu.is_none() {
+            return None;
+        }
+        let gpu_known = gpu.is_some();
+        let gpu = gpu.unwrap_or((0, 0));
         Some((
             Resources {
                 cpus: cpu.0,
@@ -168,6 +173,7 @@ impl Node {
                 memory_mib: mem.1,
                 gpus: gpu.1,
             },
+            gpu_known,
         ))
     }
 
@@ -278,6 +284,7 @@ pub fn inspect(
     let mut free_slots = 0u64;
     let mut idle_nodes = 0u64;
     let mut free = Resources::default();
+    let mut gpu_unknown_nodes = 0u64;
     let mut excluded: BTreeMap<String, u64> = BTreeMap::new();
     let mut states: BTreeMap<String, u64> = BTreeMap::new();
     for node in &snapshot.nodes {
@@ -331,7 +338,7 @@ pub fn inspect(
                 continue;
             }
         };
-        let Some((configured, remaining)) = node.resources() else {
+        let Some((configured, remaining, gpu_known)) = node.resources(request.gpus > 0) else {
             *excluded
                 .entry("resources_unknown_or_inconsistent".into())
                 .or_default() += 1;
@@ -356,6 +363,9 @@ pub fn inspect(
                 .or_default() += 1;
             continue;
         }
+        if !gpu_known {
+            gpu_unknown_nodes += 1;
+        }
         free.add(remaining)?;
         let slots = remaining.slots(request);
         if slots > 0 {
@@ -429,6 +439,8 @@ pub fn inspect(
               "request":request,"partition_target_nodes":partition_target_nodes,
               "feature_eligible_nodes":eligible,"queue_fitting_nodes":queue_fitting,
               "idle_nodes":idle_nodes,"free_fitting_nodes":free_fitting,"free_slots":free_slots,
-              "known_free_resources":free,"state_counts":states,"excluded":excluded,"pending":pending}),
+              "known_free_resources":{"cpus":free.cpus,"memory_mib":free.memory_mib,
+                 "gpus":if gpu_unknown_nodes == 0 {Some(free.gpus)} else {None}},
+              "gpu_capacity_unknown_nodes":gpu_unknown_nodes,"state_counts":states,"excluded":excluded,"pending":pending}),
     )
 }

tests/planning_capacity.rs

@@ -172,3 +172,31 @@ fn malformed_constraints_duplicates_and_inconsistent_resources_are_not_accepted(
     value["cpus_allocated"] = json!(17);
     assert_eq!(report(&snapshot(vec![value]))["free_slots"], 0);
 }
+
+#[test]
+fn cpu_requests_do_not_require_gpu_observations() {
+    let mut n = node("cpu-only", &["IDLE"]);
+    n["gpus_allocatable"] = Value::Null;
+    n["gpus_allocated"] = Value::Null;
+    let mut req = request();
+    req.gpus = 0;
+    req.gpu_type = None;
+    let value = inspect(
+        &serde_json::to_vec(&snapshot(vec![n])).unwrap(),
+        &req,
+        "2026-01-01T12:00:10Z",
+        60,
+    )
+    .unwrap();
+    assert_eq!(value["free_slots"], 2);
+    assert_eq!(value["gpu_capacity_unknown_nodes"], 1);
+    assert!(value["known_free_resources"]["gpus"].is_null());
+    req.memory_mib = 0;
+    assert!(inspect(
+        &serde_json::to_vec(&snapshot(vec![])).unwrap(),
+        &req,
+        "2026-01-01T12:00:10Z",
+        60
+    )
+    .is_err());
+}