undid var name change + added vars back + pytest fix

Author: alexandraBara

nodescraper/plugins/inband/amdsmi/amdsmi_analyzer.py

@@ -177,7 +177,7 @@ def static_consistancy_check(self, amdsmi_static_data: list[AmdSmiStatic]):
             "subsystem_id": {gpu.asic.subsystem_id for gpu in amdsmi_static_data},
             "device_id": {gpu.asic.device_id for gpu in amdsmi_static_data},
             "rev_id": {gpu.asic.rev_id for gpu in amdsmi_static_data},
-            "num_compute_units": {gpu.asic.num_compute_units for gpu in amdsmi_static_data},
+            "num_compute_units": {str(gpu.asic.num_compute_units) for gpu in amdsmi_static_data},
             "target_graphics_version": {
                 gpu.asic.target_graphics_version for gpu in amdsmi_static_data
             },
@@ -330,10 +330,13 @@ def check_pldm_version(
         pldm_missing_gpus: list[int] = []
         for fw_data in amdsmi_fw_data:
             gpu = fw_data.gpu
+            if isinstance(fw_data.fw_list, str):
+                pldm_missing_gpus.append(gpu)
+                continue
             for fw_info in fw_data.fw_list:
-                if PLDM_STRING == fw_info.fw_name and expected_pldm_version != fw_info.fw_version:
+                if PLDM_STRING == fw_info.fw_id and expected_pldm_version != fw_info.fw_version:
                     mismatched_gpus.append(gpu)
-                if PLDM_STRING == fw_info.fw_name:
+                if PLDM_STRING == fw_info.fw_id:
                     break
             else:
                 pldm_missing_gpus.append(gpu)

nodescraper/plugins/inband/amdsmi/amdsmi_collector.py

@@ -388,18 +388,15 @@ def get_process(self) -> Optional[list[Processes]]:
                     enc=self._valueunit(eu.get("enc"), "ns"),
                 )
 
-                cu_occ = self._valueunit(entry.get("cu_occupancy"), "")
-
                 try:
                     plist.append(
                         ProcessListItem(
                             process_info=ProcessInfo(
                                 name=str(name),
                                 pid=pid,
-                                mem=mem_vu,
                                 memory_usage=mem_usage,
+                                mem_usage=mem_vu,
                                 usage=usage,
-                                cu_occupancy=cu_occ,
                             )
                         )
                     )
@@ -525,7 +522,7 @@ def get_firmware(self) -> Optional[list[Fw]]:
                     ver = e.get("fw_version")
                     normalized.append(
                         FwListItem(
-                            fw_name="" if fid is None else str(fid),
+                            fw_id="" if fid is None else str(fid),
                             fw_version="" if ver is None else str(ver),
                         )
                     )
@@ -593,6 +590,22 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
             )
 
             # ASIC
+            oam_id_raw = asic.get("oam_id")
+            if oam_id_raw in (None, "", "N/A"):
+                oam_id_val: Union[int, str] = "N/A"
+            elif isinstance(oam_id_raw, str):
+                oam_id_val = oam_id_raw
+            else:
+                oam_id_val = int(oam_id_raw) if oam_id_raw is not None else "N/A"
+
+            num_cu_raw = asic.get("num_compute_units")
+            if num_cu_raw in (None, "", "N/A"):
+                num_cu_val: Union[int, str] = "N/A"
+            elif isinstance(num_cu_raw, str):
+                num_cu_val = num_cu_raw
+            else:
+                num_cu_val = int(num_cu_raw) if num_cu_raw is not None else "N/A"
+
             asic_model = StaticAsic(
                 market_name=self._normalize(
                     asic.get("market_name") or asic.get("asic_name"), default=""
@@ -604,8 +617,8 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
                 subsystem_id=str(asic.get("subsystem_id", "")),
                 rev_id=str(asic.get("rev_id", "")),
                 asic_serial=str(asic.get("asic_serial", "")),
-                oam_id=int(asic.get("oam_id", 0) or 0),
-                num_compute_units=int(asic.get("num_compute_units", 0) or 0),
+                oam_id=oam_id_val,
+                num_compute_units=num_cu_val,
                 target_graphics_version=str(asic.get("target_graphics_version", "")),
             )
 
@@ -621,12 +634,14 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
             )
 
             # Driver
-            driver_model = None
-            if driver:
-                driver_model = StaticDriver(
-                    name=self._normalize(driver.get("driver_name"), default="unknown"),
-                    version=self._normalize(driver.get("driver_version"), default="unknown"),
-                )
+            driver_model = StaticDriver(
+                name=self._normalize(
+                    driver.get("driver_name") if driver else None, default="unknown"
+                ),
+                version=self._normalize(
+                    driver.get("driver_version") if driver else None, default="unknown"
+                ),
+            )
 
             # VBIOS
             vbios_model: Optional[StaticVbios] = None
@@ -640,8 +655,15 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
 
             # NUMA
             numa_node = int(numa.get("node", 0) or 0)
-            affinity = int(numa.get("affinity", 0) or 0)
-            numa_model = StaticNuma(node=numa_node, affinity=affinity)
+            affinity_raw = numa.get("affinity")
+            if affinity_raw in (None, "", "N/A"):
+                affinity_val: Union[int, str] = "N/A"
+            elif isinstance(affinity_raw, str):
+                affinity_val = affinity_raw
+            else:
+                affinity_val = int(affinity_raw) if affinity_raw is not None else "N/A"
+
+            numa_model = StaticNuma(node=numa_node, affinity=affinity_val)
 
             # VRAM
             vram_type = str(vram.get("vram_type", "") or "unknown")
@@ -672,7 +694,7 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
             cache_info_model = self._parse_cache_info(cache)
 
             # Clock
-            clock_model = self._parse_clock(clock)
+            clock_dict_model = self._parse_clock_dict(clock)
 
             try:
                 out.append(
@@ -691,7 +713,7 @@ def get_static(self) -> Optional[list[AmdSmiStatic]]:
                         vram=vram_model,
                         cache_info=cache_info_model,
                         partition=None,
-                        clock=clock_model,
+                        clock=clock_dict_model,
                     )
                 )
             except ValidationError as e:
@@ -928,10 +950,33 @@ def _fmt(n: Optional[int]) -> Optional[str]:
                 {"Level 0": level0, "Level 1": level1, "Level 2": level2}
             )
 
-            return StaticClockData(frequency=levels, current=current)
+            # Use the alias "current level" as defined in the model
+            return StaticClockData.model_validate(
+                {"frequency_levels": levels, "current level": current}
+            )
         except ValidationError:
             return None
 
+    def _parse_clock_dict(self, data: dict) -> Optional[dict[str, Union[StaticClockData, None]]]:
+        """Parse clock data into dictionary structure
+
+        Args:
+            data (dict): Clock data from amd-smi
+
+        Returns:
+            Optional[dict[str, Union[StaticClockData, None]]]: dictionary of clock data or None
+        """
+        if not isinstance(data, dict):
+            return None
+
+        clock_dict: dict[str, Union[StaticClockData, None]] = {}
+
+        clock_data = self._parse_clock(data)
+        if clock_data:
+            clock_dict["clk"] = clock_data
+
+        return clock_dict if clock_dict else None
+
     def collect_data(
         self,
         args: Any = None,

nodescraper/plugins/inband/amdsmi/amdsmidata.py

@@ -2,6 +2,7 @@
 from typing import Any, List, Mapping, Optional, Union
 
 from pydantic import (
+    AliasChoices,
     BaseModel,
     ConfigDict,
     Field,
@@ -156,12 +157,10 @@ class ProcessUsage(BaseModel):
 class ProcessInfo(BaseModel):
     name: str
     pid: int
-
-    mem: Optional[ValueUnit] = None
     memory_usage: ProcessMemoryUsage
+    mem_usage: Optional[ValueUnit]
     usage: ProcessUsage
-    cu_occupancy: Optional[ValueUnit] = None
-    na_validator = field_validator("mem", "cu_occupancy", mode="before")(na_to_none)
+    na_validator = field_validator("mem_usage", mode="before")(na_to_none)
 
 
 class ProcessListItem(BaseModel):
@@ -175,13 +174,13 @@ class Processes(BaseModel):
 
 # FW
 class FwListItem(BaseModel):
+    fw_id: str
     fw_version: str
-    fw_name: str
 
 
 class Fw(BaseModel):
     gpu: int
-    fw_list: List[FwListItem]
+    fw_list: Union[List[FwListItem], str]
 
 
 class AmdSmiListItem(BaseModel):
@@ -256,8 +255,8 @@ class StaticAsic(BaseModel):
     subsystem_id: str
     rev_id: str
     asic_serial: str
-    oam_id: int
-    num_compute_units: int
+    oam_id: Union[int, str]  # can be N/A
+    num_compute_units: Union[int, str]  # can be N/A
     target_graphics_version: str
 
 
@@ -320,8 +319,11 @@ class StaticBoard(BaseModel):
 
 
 class StaticPartition(BaseModel):
+    # The name for compute_partition has changed we will support both for now
 
-    compute_partition: str
+    compute_partition: str = Field(
+        validation_alias=AliasChoices("compute_partition", "accelerator_partition")
+    )
     memory_partition: str
     partition_id: int
 
@@ -345,7 +347,7 @@ class StaticXgmiPlpd(BaseModel):
 
 class StaticNuma(BaseModel):
     node: int
-    affinity: int
+    affinity: Union[int, str]  # can be N/A
 
 
 class StaticVram(AmdSmiBaseModel):
@@ -383,10 +385,10 @@ class StaticClockData(BaseModel):
     model_config = ConfigDict(
         populate_by_name=True,
     )
-    frequency: StaticFrequencyLevels
+    frequency_levels: StaticFrequencyLevels
 
-    current: Optional[int] = Field(..., alias="current")
-    na_validator = field_validator("current", mode="before")(na_to_none)
+    current_level: Optional[int] = Field(..., alias="current level")
+    na_validator = field_validator("current_level", mode="before")(na_to_none)
 
 
 class AmdSmiStatic(BaseModel):
@@ -397,16 +399,16 @@ class AmdSmiStatic(BaseModel):
     bus: StaticBus
     vbios: Optional[StaticVbios]
     limit: Optional[StaticLimit]
-    driver: Optional[StaticDriver]
+    driver: StaticDriver
     board: StaticBoard
     soc_pstate: Optional[StaticSocPstate]
     xgmi_plpd: Optional[StaticXgmiPlpd]
     process_isolation: str
     numa: StaticNuma
     vram: StaticVram
     cache_info: List[StaticCacheInfoItem]
-    partition: Optional[StaticPartition] = None
-    clock: Optional[StaticClockData] = None
+    partition: Optional[StaticPartition] = None  # This has been removed in Amd-smi 26.0.0+d30a0afe+
+    clock: Optional[dict[str, Union[StaticClockData, None]]] = None
     na_validator_dict = field_validator("clock", mode="before")(na_to_none_dict)
     na_validator = field_validator("soc_pstate", "xgmi_plpd", "vbios", "limit", mode="before")(
         na_to_none

test/unit/plugin/test_amdsmi_collector.py

@@ -277,7 +277,7 @@ def test_get_process(collector):
     p0 = procs[0].process_list[0].process_info
     assert p0.name == "python"
     assert p0.pid == 4242
-    assert p0.mem is not None and p0.mem.unit == "B"
+    assert p0.mem_usage is not None and p0.mem_usage.unit == "B"
     assert p0.usage.gfx is not None and p0.usage.gfx.unit == "ns"
 
     p1 = procs[0].process_list[1].process_info
@@ -300,7 +300,7 @@ def test_get_firmware(collector):
     assert fw is not None and len(fw) == 1
     assert fw[0].gpu == 0
     assert len(fw[0].fw_list) == 2
-    assert fw[0].fw_list[0].fw_name == "SMU"
+    assert fw[0].fw_list[0].fw_id == "SMU"
     assert fw[0].fw_list[0].fw_version == "55.33"
 
 
@@ -335,7 +335,9 @@ def test_get_static(collector):
     assert cache.cache_properties
 
     if s.clock is not None:
-        assert s.clock.frequency is not None
+        assert isinstance(s.clock, dict)
+        if "clk" in s.clock and s.clock["clk"] is not None:
+            assert s.clock["clk"].frequency_levels is not None
 
 
 def test_cache_properties_parsing(collector):