better reason strings

Signed-off-by: Bill Nell <[email protected]>

Author: bnellnm

tests/kernels/moe/modular_kernel_tools/common.py

@@ -215,17 +215,21 @@ def is_valid(self) -> tuple[bool, Optional[str]]:
                 int(self.is_per_tensor_act_quant) +
                 int(self.quant_block_shape is not None)) > 1:
             # invalid quant config
-            return False, "Bad quant_config."
+            return False, f"Bad quant_config {self.quant_config}."
 
         # check type support
         if self.quant_dtype is None:
             if (self.dtype not in self.pf_supported_types()
                     or self.dtype not in self.fe_supported_types()):
-                return False, "Unsupported type 1."
+                return False, (f"Unsupported type {self.dtype} not in "
+                               f"{self.pf_supported_types()} and "
+                               f"{self.fe_supported_types()}.")
         else:
             if (self.quant_dtype not in self.pf_supported_types()
                     or self.quant_dtype not in self.fe_supported_types()):
-                return False, "Unsupported type 2."
+                return False, (f"Unsupported quant type {self.quant_dtype} "
+                               f"not in {self.pf_supported_types()} and "
+                               f"{self.fe_supported_types()}.")
 
         # Check block quanization support
         is_block_quatized = self.quant_block_shape is not None
@@ -241,11 +245,11 @@ def is_valid(self) -> tuple[bool, Optional[str]]:
 
         # Check dependencies (turn into asserts?)
         if self.needs_deep_ep() and not has_deep_ep():
-            return False, "Needs DeepEP."
+            return False, "Needs DeepEP, but DeepEP not available."
         if self.needs_deep_gemm() and not has_deep_gemm():
-            return False, "Needs DeepGEMM."
+            return False, "Needs DeepGEMM, but DeepGEMM not available."
         if self.needs_pplx() and not has_pplx():  # noqa: SIM103
-            return False, "Needs PPLX."
+            return False, "Needs PPLX, but PPLX not available."
 
         return True, None
 

tests/kernels/moe/test_modular_kernel_combinations.py

@@ -160,12 +160,15 @@ def is_nyi_config(config: Config) -> bool:
 def generate_valid_test_cases(world_size: int,
                               prepare_finalize_types) -> list[tuple[Any, ...]]:
     cases = []
+    total = 0
 
     for k, n, e, dtype, quant_config, combination, chunk_size in product(
             Ks, Ns, Es, DTYPEs, MK_QUANT_CONFIGS,
             product(prepare_finalize_types, MK_FUSED_EXPERT_TYPES),
             FUSED_MOE_CHUNK_SIZEs):
 
+        total = total + 1
+
         config = Config(
             Ms=Ms,
             K=k,
@@ -180,24 +183,26 @@ def generate_valid_test_cases(world_size: int,
             world_size=world_size,
         )
 
-        # TODO
+        # TODO(bnell): figure out how to get verbose flag here.
         verbose = False  #pytestconfig.getoption('verbose') > 0
 
         valid, reason = config.is_valid()
 
         if not valid:
             if verbose:
-                print(f"Tests config {config} is not valid: {reason}")
+                print(f"Test config {config} is not valid: {reason}")
             continue
 
         if is_nyi_config(config):
             if verbose:
-                print(f"Tests config {config} is nyi.")
+                print(f"Test config {config} is nyi.")
             continue
 
         cases.append((k, n, e, dtype, quant_config, combination[0],
                       combination[1], chunk_size, world_size))
 
+    print(f"{len(cases)} of {total} valid configs generated.")
+
     return cases