withdrawn919
diff --git a/‎tools/add_labels.py‎
Lines changed: 99 additions & 0 deletions b/‎tools/add_labels.py‎
Lines changed: 99 additions & 0 deletions
diff --git a/‎tools/run_tests.py‎
Lines changed: 97 additions & 13 deletions b/‎tools/run_tests.py‎
Lines changed: 97 additions & 13 deletions
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Standalone script to add operator labels from operators.yaml into summary.json.
+
+Usage:
+    python add_labels.py <result_dir>
+
+Where <result_dir> is the output directory produced by run_tests.py containing
+summary.json. The script reads conf/operators.yaml relative to the project root,
+builds a mapping of op_id -> labels, and injects the "labels" field into each
+operator entry in summary.json.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).parent.parent
+
+
+def pinfo(msg):
+    print(f"\033[32m[INFO]\033[0m {msg}")
+
+
+def perror(msg):
+    print(f"\033[31m[ERROR]\033[0m {msg}")
+
+
+def load_op_labels():
+    """Load operator labels from conf/operators.yaml."""
+    op_labels = {}
+    op_inventory = ROOT / "conf" / "operators.yaml"
+    try:
+        with open(str(op_inventory), "r") as f:
+            data = yaml.safe_load(f)
+            catalog = data.get("ops", [])
+    except Exception as e:
+        perror(f"Failed to load operator inventory: {e}")
+        return op_labels
+
+    for op_entry in catalog:
+        op_id = op_entry.get("id", "")
+        labels = op_entry.get("labels", [])
+        op_labels[op_id] = labels
+
+    return op_labels
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Add operator labels from operators.yaml into summary.json"
+    )
+    parser.add_argument(
+        "result_dir",
+        help="Path to the result directory containing summary.json",
+    )
+    args = parser.parse_args()
+
+    result_dir = Path(args.result_dir)
+    summary_path = result_dir / "summary.json"
+
+    if not summary_path.exists():
+        perror(f"summary.json not found in {result_dir}")
+        sys.exit(1)
+
+    # Load summary
+    with summary_path.open("r") as f:
+        summary = json.load(f)
+
+    op_data = summary.get("result", {})
+    if not op_data:
+        perror("No 'result' field found in summary.json")
+        sys.exit(1)
+
+    # Load labels from operators.yaml
+    op_labels = load_op_labels()
+    if not op_labels:
+        perror("No labels loaded from operators.yaml")
+        sys.exit(1)
+
+    # Inject labels into each operator entry
+    updated = 0
+    for op_id, op_entry in op_data.items():
+        labels = op_labels.get(op_id, [])
+        op_entry["labels"] = labels
+        updated += 1
+
+    # Write back
+    with summary_path.open("w") as f:
+        json.dump(summary, f, indent=2)
+
+    pinfo(f"Updated {updated} operators with labels in {summary_path}")
+
+
+if __name__ == "__main__":
+    main()
@@ -33,6 +33,7 @@
 ROOT = Path(__file__).parent.parent
 OUPUT_DIR = None
 OP_LIST = []
+DUMP_OUTPUT = False
 TIMEOUT = -100
 # A list of operators that can only run on GPU/DCUs
 NO_CPU_LIST = []
@@ -159,6 +160,7 @@ def init():
         repo = git.Repo(search_parent_directories=True)
         sha = repo.head.object.hexsha
         pinfo(f"flag_gems detected ... {version}+git{sha[:8]}")
+        ENV_INFO["flag_gems"]["commit_id"] = sha
     except RuntimeError as e:
         perror(f"{e}")
         sys.exit(-1)
@@ -188,21 +190,74 @@ def init():
         sys.exit(-1)
 
 
-def run_cmd(cmd, cwd=None, env=None, timeout=600):
+def run_cmd(
+    cmd,
+    cwd=None,
+    env=None,
+    timeout=600,
+    stdout_file=None,
+    stderr_file=None,
+):
+    """
+    Safe subprocess runner:
+    - No PIPE (avoid deadlock)
+    - Support timeout
+    - Kill full process group
+    - Persist stdout/stderr to file
+    """
+
+    stdout_fh = None
+    stderr_fh = None
+
     try:
+        if stdout_file:
+            stdout_fh = open(stdout_file, "w", buffering=1)
+        if stderr_file:
+            stderr_fh = open(stderr_file, "w", buffering=1)
+
+        stdout_target = stdout_fh if stdout_fh else subprocess.DEVNULL
+        stderr_target = stderr_fh if stderr_fh else subprocess.DEVNULL
+
         p = subprocess.Popen(
             shlex.split(cmd),
-            cwd=str(cwd),
+            cwd=str(cwd) if cwd else None,
             env=env,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
+            stdout=stdout_target,
+            stderr=stderr_target,
             start_new_session=True,
         )
-        p.wait(timeout=timeout)
-    except subprocess.TimeoutExpired:
-        os.killpg(os.getpgid(p.pid), signal.SIGTERM)
-        return TIMEOUT
-    return p.returncode
+
+        try:
+            p.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            try:
+                os.killpg(p.pid, signal.SIGTERM)
+            except Exception:
+                p.terminate()
+
+            try:
+                p.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                try:
+                    os.killpg(p.pid, signal.SIGKILL)
+                except Exception:
+                    p.kill()
+
+            return TIMEOUT
+
+        return p.returncode
+
+    except Exception as e:
+        perror(f"run_cmd failed: {e}")
+        return -1
+
+    finally:
+        if stdout_fh:
+            stdout_fh.flush()
+            stdout_fh.close()
+        if stderr_fh:
+            stderr_fh.flush()
+            stderr_fh.close()
 
 
 def parse_accuracy_data(result_file):
@@ -329,8 +384,19 @@ def run_accuracy(gpu_id, start, index, count):
     if result_file.exists():
         result_file.unlink()
 
+    op_dir = OUTPUT_DIR.joinpath(op)
+    ensure_dir(op_dir)
+    stdout_log = str(op_dir / f"accuracy_{op}_stdout.log") if DUMP_OUTPUT else None
+    stderr_log = str(op_dir / f"accuracy_{op}_stderr.log") if DUMP_OUTPUT else None
+
     start = time.time()
-    code = run_cmd(cmd, cwd=accuracy_dir, env=env)
+    code = run_cmd(
+        cmd,
+        cwd=accuracy_dir,
+        env=env,
+        stdout_file=stdout_log,
+        stderr_file=stderr_log,
+    )
     end = time.time()
 
     if code == TIMEOUT:  # Timeout
@@ -344,7 +410,6 @@ def run_accuracy(gpu_id, start, index, count):
             "errors": 0,
             "duration": end - start,
         }
-
     # There are rare cases where the pytest process aborts
     # with no result file generated.
     if not result_file.exists():
@@ -451,9 +516,20 @@ def run_benchmark(gpu_id, start, index, count):
     if result_file.exists():
         result_file.unlink()
 
+    op_dir = OUTPUT_DIR.joinpath(op)
+    ensure_dir(op_dir)
+    stdout_log = str(op_dir / f"performance_{op}_stdout.log") if DUMP_OUTPUT else None
+    stderr_log = str(op_dir / f"performance_{op}_stderr.log") if DUMP_OUTPUT else None
+
     start = time.time()
     cmd = f'pytest -m "{op}" --level core --record json --output benchmark_{op}.json'
-    code = run_cmd(cmd, cwd=benchmark_dir, env=env)
+    code = run_cmd(
+        cmd,
+        cwd=benchmark_dir,
+        env=env,
+        stdout_file=stdout_log,
+        stderr_file=stderr_log,
+    )
     end = time.time()
 
     # Not found
@@ -465,7 +541,6 @@ def run_benchmark(gpu_id, start, index, count):
         }
 
     # Move record log to output directory
-    op_dir = OUTPUT_DIR.joinpath(op)
     dest = op_dir / "performance_result.json"
     shutil.move(result_file, str(dest))
     result_file = dest
@@ -583,15 +658,24 @@ def get_ops_to_test(ops_file, ops_list, stages):
 def main():
     global OUTPUT_DIR
     global OP_LIST
+    global DUMP_OUTPUT
 
     parser = argparse.ArgumentParser()
     parser.add_argument("--op-list-file", required=False)
     parser.add_argument("--ops", required=False)
     parser.add_argument("--gpus", default="0")
     parser.add_argument("--output-dir", default=None)
     parser.add_argument("--stages", required=False, default="stable")
+    parser.add_argument(
+        "--dump-output",
+        action="store_true",
+        default=False,
+        help="Dump stdout/stderr of each test to log files",
+    )
     args = parser.parse_args()
 
+    DUMP_OUTPUT = args.dump_output
+
     # Probe environment setttings
     init()