[xcl-lens] Improve sys and env reports

projects/xcl-lens/src/xcl_lens/parser/rccl.py

@@ -62,49 +62,61 @@ class RcclLogParser:
             self.log_entries.add(("-", rank, content))
 
     def _report_sys(self):
-        """Search patterns and print pre-defined strings if matched"""
-        # Pattern -> output string or as-is
-        sys_patterns = {
-            r"kernel version": None,
-            r"ROCr version": None,
-            r"RCCL version": None,
-            r"Librccl path": None,
-            r"iommu": None,
-            r"Dmabuf feature disabled": "Dmabuf: disabled",
-            r"Disabled GDRCopy": "GDRCopy: disabled",
-            r"Using network IB": "NET/IB: enabled",
-            r"NET/Plugin: Could not find: librccl-net.so": "NET/Plugin: internal",
-            r"XDP is disabled": "XDP: disabled",
-        }
+        sys_specs = [
+            (r"kernel version\s*:?\s*(.+)", "kernel version", 1, None),
+            (r"ROCr version\s*:?\s*(.+)", "ROCr version", 1, None),
+            (r"RCCL version\s*:?\s*(.+)", "RCCL version", 1, None),
+            (r"Librccl path\s*:?\s*(.+)", "Librccl path", 1, None),
+            (r'(Missing "iommu=pt".*|iommu.*)', "iommu", 1, None),
+            (r"Dmabuf feature disabled", "Dmabuf", None, "disabled"),
+            (r"Disabled GDRCopy", "GDRCopy", None, "disabled"),
+            (r"Using network IB", "NET/IB", None, "enabled"),
+            (r"NET/Plugin: Could not find: librccl-net.so", "NET/Plugin", None, "internal"),
+            (r"XDP is disabled", "XDP", None, "disabled"),
+        ]
 
-        print("===> System Information:\n")
-        reported = set()
-        for _, _, content in self.log_entries:
-            for pattern, out in sys_patterns.items():
-                if re.search(pattern, content, re.IGNORECASE):
-                    reported.add(out if out is not None else content)
+        records = {}
+        for host, rank, content in self.log_entries:
+            for pattern, field, group_idx, literal in sys_specs:
+                m = re.search(pattern, content, re.IGNORECASE)
+                if not m:
+                    continue
+                value = literal if group_idx is None else m.group(group_idx).strip()
+                records.setdefault(field, {}).setdefault((host, rank), set()).add(value)
                 break
-        for line in sorted(reported):
-            print(line)
-        print()
+
+        self._print_consistency_report("System Information", records)
 
     def _report_user_envs(self):
-        """Search environment variables set by user"""
-        print("===> User-defined Environment Variables:\n")
-        env_vars = {}
         pattern = re.compile(r"((?:N|R)CCL_\w+)\s+set(?: by environment)? to\s+(.+)")
-        for _, _, content in self.log_entries:
+        records = {}
+        for host, rank, content in self.log_entries:
             m = pattern.search(content)
-            if m:
-                var_name, var_value = m.group(1), m.group(2)
-                env_vars.setdefault(var_name, set()).add(var_value)
-        for key, values in sorted(env_vars.items()):
+            if not m:
+                continue
+            var_name, var_value = m.group(1), m.group(2).strip()
+            records.setdefault(var_name, {}).setdefault((host, rank), set()).add(var_value)
+
+        self._print_consistency_report("User-defined Environment Variables", records)
+
+    def _print_consistency_report(self, title, records):
+        print(f"===> {title}:\n")
+
+        if not records:
+            print("  (No data found)\n")
+            return
+
+        for field in sorted(records):
+            entries = records[field]
+            values = sorted({value for field_values in entries.values() for value in field_values})
             if len(values) == 1:
-                print(f"{key}: {next(iter(values))}")
-            else:
-                print(
-                    f"{key}: {', '.join(sorted(values))} (WARNING: Different values across ranks)"
-                )
+                print(f"{field}: {values[0]}")
+                continue
+
+            print(f"{field}: (WARNING: Different values across ranks)")
+            for (host, rank), field_values in sorted(entries.items()):
+                joined = " | ".join(sorted(field_values))
+                print(f"  {host} rank {rank}: {joined}")
         print()
 
     def _report_net_ib_info(self):