Download eval/bare_harness/Backend/services/ascendc_code_profiling_service.py from SLAI-AITP/AscendGYM: direct link, hf CLI and curl.
- Browser
- Download file 32.2 kB
-
https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/eval/bare_harness/Backend/services/ascendc_code_profiling_service.py
- Command line
-
hf download hf://datasets/SLAI-AITP/AscendGYM/eval/bare_harness/Backend/services/ascendc_code_profiling_service.py
-
curl -L -o ascendc_code_profiling_service.py https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/eval/bare_harness/Backend/services/ascendc_code_profiling_service.py
32.2 kB
| """ | |
| AscendC Profiling 服务 | |
| 功能:执行沙盒 profiling,编译测试验证和性能数据采集在一次调用中完成 | |
| """ | |
| import logging | |
| import os | |
| import re | |
| import subprocess | |
| from datetime import datetime | |
| from pathlib import Path | |
| from typing import Any, Dict | |
| from config.settings import SANDBOX_CONFIG, RUS_OP_PATH, RUS_OP_PATH_VERSION, PROFILING_CONFIG | |
| from services.profile_op_summary import profile_op_summary | |
| from utils.backup import snapshot_to_op_backup, update_best_snapshot, get_op_backup_version_info, ensure_op_in_version | |
| from utils.naming import to_snake_case_compact | |
| from utils.sandbox_output_parser import ( | |
| strip_ansi, | |
| extract_response_json, | |
| extract_compile_errors, | |
| extract_run_errors, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| def _to_camel_case(text: str) -> str: | |
| """将下划线分隔名转为驼峰,例如 sparse_attn_sharedkv -> SparseAttnSharedkv""" | |
| return ''.join(word.capitalize() for word in text.split('_')) | |
| class AscendCCodeProfilingService: | |
| """Profiling 采集服务:编译测试验证 + 性能数据采集合二为一""" | |
| def __init__(self): | |
| self.rus_op_path = RUS_OP_PATH | |
| self.rus_op_path_version = RUS_OP_PATH_VERSION | |
| self.profiling_config = dict(PROFILING_CONFIG) | |
| total_runs = self.profiling_config['profiling_runs'] | |
| warmup_runs = self.profiling_config['warmup_runs'] | |
| statistic = self.profiling_config.get('profiling_statistic', 'mean') | |
| if type(total_runs) is not int or total_runs < 1: | |
| raise ValueError(f"profiling_runs must be a positive integer, got {total_runs!r}") | |
| if type(warmup_runs) is not int or not 0 <= warmup_runs < total_runs: | |
| raise ValueError( | |
| f"warmup_runs must be in [0, profiling_runs), got " | |
| f"warmup={warmup_runs!r} total={total_runs!r}" | |
| ) | |
| if statistic != 'mean': | |
| raise ValueError(f"only profiling_statistic='mean' is supported, got {statistic!r}") | |
| self.profiling_protocol = { | |
| 'total_runs': total_runs, | |
| 'warmup_runs': warmup_runs, | |
| 'statistic': statistic, | |
| } | |
| logger.info( | |
| "AscendCCodeProfilingService initialized, rus_op_path=%s, rus_op_path_version=%s, " | |
| "ascend_c_path=%s, profiling_protocol=%s", | |
| self.rus_op_path, | |
| self.rus_op_path_version, | |
| self.profiling_config['ascend_c_path'], | |
| self.profiling_protocol, | |
| ) | |
| def _resolve_op_root(self, op_name: str): | |
| """ | |
| 按优先级查找算子代码根目录(即同时包含 op_host 和 op_kernel 的子目录): | |
| 1. rus_op_path_version 下 <op_name>/<op_snake>/ 是否存在 | |
| 2. rus_op_path 下 <op_name>/<op_snake>/ 是否存在 | |
| 3. 以上均不存在,返回 (None, None, 'code_not_exist')。 | |
| 新布局约定(无 _custom 后缀): | |
| <root>/<op_name>/<to_snake_case_compact(op_name)>/ | |
| ├── op_host/ | |
| └── op_kernel/ | |
| Returns: | |
| (op_root: Path, source: str, error_status: str | None) | |
| error_status 为 None 表示找到了有效目录。 | |
| """ | |
| op_snake = to_snake_case_compact(op_name) | |
| # ── 优先:版本路径 ── | |
| version_base = Path(self.rus_op_path_version) | |
| version_op_root = version_base / op_name / op_snake | |
| if version_op_root.is_dir(): | |
| logger.info("[%s] 在 version 路径下找到算子目录: %s", op_name, version_op_root) | |
| return version_op_root, 'version', None | |
| # ── 次优:原始 op_path ── | |
| base = Path(self.rus_op_path) | |
| op_root = base / op_name / op_snake | |
| if op_root.is_dir(): | |
| logger.info("[%s] 在 op_path 下找到算子目录: %s", op_name, op_root) | |
| return op_root, 'op_path', None | |
| # ── 未找到 ── | |
| logger.warning( | |
| "[%s] 未在 version_path=%s 或 op_path=%s 下找到算子目录 <%s>/<%s>", | |
| op_name, version_base, base, op_name, op_snake, | |
| ) | |
| return None, None, 'code_not_exist' | |
| def execute(self, op_name: str) -> Dict[str, Any]: | |
| """ | |
| 执行 profiling(编译测试验证 + 性能数据采集合二为一)。 | |
| Args: | |
| op_name: 算子名称(如 'SELU_Phase1_Version1') | |
| Returns: | |
| dict: 结果字典 | |
| """ | |
| if not op_name: | |
| return { | |
| 'status': 'failed', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': '参数错误: op_name 为空', | |
| 'errors': [{'type': 'validation_error', 'message': 'op_name 不能为空'}], | |
| } | |
| start_time = datetime.now() | |
| # ── Step 1: 按优先级解析算子目录 ──────────────────────────────── | |
| op_root, source, error_status = self._resolve_op_root(op_name) | |
| if error_status == 'code_not_exist': | |
| return { | |
| 'status': 'code_not_exist', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': ( | |
| f'未找到算子 "{op_name}" 的任何代码版本。' | |
| f'已查找路径: version_path={self.rus_op_path_version}, op_path={self.rus_op_path}。' | |
| '请先生成或上传算子代码后重试。' | |
| ), | |
| 'errors': [{'type': 'code_not_exist', 'message': f'算子 {op_name} 在两个路径下均未找到'}], | |
| } | |
| logger.info("[%s] 使用算子目录 (source=%s): %s", op_name, source, op_root) | |
| # 日志统一存储在 op-path-version/profiling/<op_name>/ 下 | |
| log_dir = Path(self.rus_op_path_version) / 'profiling' / op_name | |
| log_dir.mkdir(parents=True, exist_ok=True) | |
| timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') | |
| # ── Step 2: 推导 profiling 所需路径 ────────────────────────────── | |
| if not op_root.is_dir(): | |
| return { | |
| 'status': 'failed', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': f'算子目录不存在: {op_root}', | |
| 'errors': [{'type': 'file_not_found', 'message': f'算子目录不存在: {op_root}'}], | |
| } | |
| op_folder_path = str(op_root) | |
| kernel_name = _to_camel_case(op_root.name) | |
| # 查找 .py 执行脚本(在算子目录 op_root.parent 下,与 op_snake 子目录同级) | |
| # 命名约定:首选 {op_snake}_test.py(与 ascend 标准生成结果一致); | |
| # 找不到时回退到任意 *.py 取第一个,兼容历史/手写测试脚本。 | |
| op_dir = op_root.parent | |
| op_snake = to_snake_case_compact(op_name) | |
| preferred_test = op_dir / f'{op_snake}_test.py' | |
| if preferred_test.exists(): | |
| exec_code_path = str(preferred_test) | |
| else: | |
| py_files = sorted(op_dir.glob('*.py')) | |
| if not py_files: | |
| return { | |
| 'status': 'failed', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': ( | |
| f'在 {op_dir} 中既未找到首选测试脚本 {op_snake}_test.py,' | |
| f'也未找到任何 .py 文件' | |
| ), | |
| 'errors': [{ | |
| 'type': 'file_not_found', | |
| 'message': ( | |
| f'未找到测试脚本: {preferred_test} ;' | |
| f'回退 glob 在 {op_dir} 下也没匹配到 .py' | |
| ), | |
| }], | |
| } | |
| exec_code_path = str(py_files[0]) | |
| logger.warning( | |
| "[%s] 首选测试脚本 %s 不存在,回退到 %s", | |
| op_name, preferred_test.name, py_files[0].name, | |
| ) | |
| # profiling 输出目录:统一存储在 op-path-version/profiling/<op_name>/ 下 | |
| profiling_output_dir = str(log_dir / f'profiling_results_{kernel_name}_{timestamp}') | |
| os.makedirs(profiling_output_dir, exist_ok=True) | |
| logger.info( | |
| "[%s] op_folder=%s, kernel_name=%s, exec_code=%s, profiling_dir=%s", | |
| op_name, op_folder_path, kernel_name, exec_code_path, profiling_output_dir, | |
| ) | |
| # ── Step 3: 执行 profiling(编译测试验证 + 性能采集一次完成) ─── | |
| profiling_result = self._run_profiling( | |
| op_name=op_name, | |
| op_folder_path=op_folder_path, | |
| kernel_name=kernel_name, | |
| exec_code_path=exec_code_path, | |
| profiling_output_dir=profiling_output_dir, | |
| log_dir=log_dir, | |
| timestamp=timestamp, | |
| ) | |
| # 性能采集成功后,附加整体耗时字段、更新 best 快照、注入 version_info | |
| if profiling_result.get('status') == 'success': | |
| elapsed = (datetime.now() - start_time).total_seconds() | |
| profiling_result['op_source'] = source | |
| profiling_result['op_root'] = str(op_root) | |
| logger.info("[%s] Profiling 全流程完成,耗时 %.3fs", op_name, elapsed) | |
| # 若本次使用的是 op_path(原始路径),说明是首次 profiling 且 version 目录还未初始化。 | |
| # 在 profiling 成功后将算子迁移到 version 目录,确保后续所有写操作都在 version 路径进行, | |
| # 并让 best 快照、version_info 写入正确位置。 | |
| if source == 'op_path': | |
| try: | |
| ensure_op_in_version(op_name, self.rus_op_path, self.rus_op_path_version) | |
| logger.info("[%s] 首次 profiling 成功,已将算子迁移到 version 目录", op_name) | |
| except Exception as e: | |
| logger.warning("[%s] 迁移到 version 目录失败(不影响本次结果): %s", op_name, e) | |
| # 切换 op_root 到 version 目录,后续 operator_path 从这里找 | |
| op_root = Path(self.rus_op_path_version) / op_name | |
| # 成功 profiling 后快照整个算子文件夹到 op_backup,并更新 best 记录 | |
| try: | |
| snapshot_info = snapshot_to_op_backup(op_name, self.rus_op_path_version) | |
| profiling_result['op_backup'] = snapshot_info | |
| logger.info("[%s] op_backup snapshot: v%d -> %s", op_name, snapshot_info['version'], snapshot_info['snapshot_dir']) | |
| exec_time_us = profiling_result.get('exec_time_us') | |
| if exec_time_us is not None: | |
| eps = float(self.profiling_config.get('min_improvement_epsilon', 0.0)) | |
| best_result = update_best_snapshot( | |
| op_name, | |
| self.rus_op_path_version, | |
| exec_time_us, | |
| snapshot_info['version'], | |
| min_improvement_epsilon=eps, | |
| ) | |
| profiling_result['best_update'] = best_result | |
| logger.info( | |
| "[%s] best update: updated=%s, best_exec_time_us=%.2f (eps=%.4f)", | |
| op_name, best_result['updated'], | |
| best_result['best_exec_time_us'] or 0, eps, | |
| ) | |
| except Exception as e: | |
| logger.warning("[%s] op_backup snapshot 失败(不影响本次结果): %s", op_name, e) | |
| profiling_result['version_info'] = get_op_backup_version_info(op_name, self.rus_op_path_version) | |
| else: | |
| # 非成功状态也注入 version_info | |
| profiling_result['version_info'] = get_op_backup_version_info(op_name, self.rus_op_path_version) | |
| profiling_result.setdefault('profiling_protocol', dict(self.profiling_protocol)) | |
| profiling_result.setdefault( | |
| 'measured_runs', | |
| self.profiling_protocol['total_runs'] - self.profiling_protocol['warmup_runs'], | |
| ) | |
| return profiling_result | |
| # ────────────────────────────────────────────────────────────────────── | |
| # 内部方法 | |
| # ────────────────────────────────────────────────────────────────────── | |
| def _run_profiling( | |
| self, | |
| op_name: str, | |
| op_folder_path: str, | |
| kernel_name: str, | |
| exec_code_path: str, | |
| profiling_output_dir: str, | |
| log_dir: Path = None, | |
| timestamp: str = None, | |
| ) -> Dict[str, Any]: | |
| """执行 profiling 命令,验证编译测试结果,并生成 Markdown 报告。""" | |
| cfg = self.profiling_config | |
| ascend_c_path = cfg['ascend_c_path'] | |
| profiling_cmd = ( | |
| f"set -euo pipefail\n" | |
| f"cd {ascend_c_path}\n" | |
| f"python {cfg['main_py_path']} \\\n" | |
| f"--custom-op-dir {op_folder_path} \\\n" | |
| f"--exec-code-path {exec_code_path} \\\n" | |
| f"--host {cfg['host']} \\\n" | |
| f"--port {cfg['port']} \\\n" | |
| f"--compile-timeout {cfg['compile_timeout']} \\\n" | |
| f"--run-timeout {cfg['run_timeout']} \\\n" | |
| f"--profile \\\n" | |
| f"--profiling-runs {cfg['profiling_runs']} \\\n" | |
| f"--profiling-output-dir {profiling_output_dir}\n" | |
| ) | |
| logger.info("[%s] 执行 profiling 命令:\n%s", op_name, profiling_cmd) | |
| timeout_sec = int(cfg['run_timeout']) / 1000 + 60 | |
| profiling_log_path = None | |
| try: | |
| proc = subprocess.run( | |
| profiling_cmd, | |
| shell=True, | |
| capture_output=True, | |
| text=True, | |
| timeout=timeout_sec, | |
| ) | |
| except subprocess.TimeoutExpired: | |
| logger.error("[%s] Profiling 超时", op_name) | |
| return { | |
| 'status': 'profiling_failed', | |
| 'debug_status': 'profiling_failed', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': f'Profiling 执行超时 ({timeout_sec:.0f}s)', | |
| 'errors': [{'type': 'timeout', 'message': f'超时 {timeout_sec:.0f}s'}], | |
| } | |
| except Exception as e: | |
| logger.error("[%s] Profiling 执行异常: %s", op_name, str(e)) | |
| return { | |
| 'status': 'profiling_failed', | |
| 'debug_status': 'profiling_failed', | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': f'Profiling 执行异常: {str(e)}', | |
| 'errors': [{'type': 'system_error', 'message': str(e)}], | |
| } | |
| logger.info("[%s] Profiling 命令退出码: %d", op_name, proc.returncode) | |
| # 保存 profiling 日志(stdout + stderr) | |
| if log_dir is not None: | |
| ts = timestamp or datetime.now().strftime('%Y%m%d_%H%M%S') | |
| profiling_log_path = log_dir / f'profiling_{ts}.log' | |
| try: | |
| log_content = f"=== STDOUT ===\n{proc.stdout or ''}\n=== STDERR ===\n{proc.stderr or ''}" | |
| profiling_log_path.write_text(log_content, encoding='utf-8') | |
| logger.info("[%s] Profiling 日志已保存: %s", op_name, profiling_log_path) | |
| except Exception as e: | |
| logger.warning("[%s] Profiling 日志保存失败: %s", op_name, e) | |
| profiling_log_path = None | |
| # 验证编译测试结果(从 profiling 的同一份服务器响应中) | |
| validation = self._validate_profiling_response(op_name, proc.stdout, proc.stderr) | |
| if validation['status'] != 'success': | |
| logger.warning("[%s] Profiling 验证失败: %s", op_name, validation['status']) | |
| return { | |
| 'status': validation['status'], | |
| 'debug_status': validation['status'], | |
| 'debug_options': {'op_name': op_name, 'op_type': '2d'}, | |
| 'message': validation['message'], | |
| 'errors': validation['errors'], | |
| 'debug_output': validation.get('output', ''), | |
| 'compile_detail': validation.get('compile_detail'), | |
| 'run_detail': validation.get('run_detail'), | |
| 'profiling_stdout': proc.stdout[:2000] if proc.stdout else '', | |
| 'profiling_stderr': proc.stderr[:2000] if proc.stderr else '', | |
| 'profiling_log_path': str(profiling_log_path) if profiling_log_path else None, | |
| 'op_source': None, | |
| } | |
| # 提取 CSV 并生成 Markdown 报告 | |
| result = self._extract_and_build_report(op_name, profiling_output_dir) | |
| if profiling_log_path: | |
| result['profiling_log_path'] = str(profiling_log_path) | |
| return result | |
| def _validate_profiling_response(self, op_name: str, stdout: str, stderr: str) -> Dict[str, Any]: | |
| """从 profiling 命令的服务器响应中验证编译测试结果。 | |
| 验证逻辑与 SandboxCompileTestService._parse_output 一致: | |
| 1. HTTP 状态码检查 | |
| 2. 编译结果检查(return_code + 错误提取) | |
| 3. 运行结果检查(return_code + 错误提取) | |
| 4. 精度检查(PASS/FAIL 模式匹配) | |
| """ | |
| clean_output = strip_ansi(stdout or '') | |
| # 检查 HTTP 状态码 | |
| status_code_match = re.search(r'Status Code:\s*(\d+)', clean_output) | |
| if status_code_match: | |
| http_status = int(status_code_match.group(1)) | |
| if http_status != 200: | |
| return { | |
| 'status': 'failed', | |
| 'message': f'沙盒服务返回 HTTP {http_status},可能服务繁忙或超时', | |
| 'errors': [{'type': 'sandbox_http_error', 'message': f'沙盒服务返回 HTTP {http_status}'}], | |
| 'output': clean_output[:2000], | |
| } | |
| # 提取服务器响应 JSON | |
| response_json = extract_response_json(clean_output) | |
| if response_json is None: | |
| # 把 stdout 尾部 3000 字符塞进 errors.message,方便 LLM 看到真实输出 | |
| # 而不是只有一句"无法解析"——sandbox 各种异常都会卡在这一步。 | |
| tail = (clean_output[-3000:]).strip() | |
| return { | |
| 'status': 'failed', | |
| 'message': '无法解析沙盒输出', | |
| 'errors': [{ | |
| 'type': 'parse_error', | |
| 'message': '无法从沙盒输出中解析 JSON 响应\n' + tail, | |
| }], | |
| 'output': clean_output[:2000], | |
| } | |
| # SandboxError 兜底:sandbox 自身崩溃(不是用户代码错误)时, | |
| # response_json 会带 status=SandboxError 且 compile_result 为 null。 | |
| # 不做这层区分的话会被后续逻辑当成"无运行结果"汇报为 compile_failed, | |
| # 让 LLM 误以为是它的代码 bug。这里把 sandbox message 抽出来透传, | |
| # 让上层能看出是基础设施问题。 | |
| sandbox_status = response_json.get('status', '') | |
| sandbox_message = response_json.get('message', '') | |
| if sandbox_status == 'SandboxError' and response_json.get('compile_result') is None: | |
| error_msg = sandbox_message or 'SandboxFusion 内部异常,未产生编译结果' | |
| prefix = 'exception on running code ' | |
| if error_msg.startswith(prefix): | |
| colon_pos = error_msg.find(': ', len(prefix)) | |
| error_msg = ( | |
| error_msg[colon_pos + 2:].strip() if colon_pos != -1 | |
| else error_msg[len(prefix):].strip() | |
| ) | |
| error_msg = strip_ansi(error_msg)[:2000] | |
| return { | |
| 'status': 'compile_failed', | |
| 'message': f'SandboxFusion 内部异常: {error_msg[:200]}', | |
| 'errors': [{'type': 'sandbox_error', 'message': error_msg}], | |
| 'compile_detail': {'return_code': -1, 'execution_time': None}, | |
| 'run_detail': None, | |
| 'output': clean_output[:2000], | |
| } | |
| compile_result = response_json.get('compile_result') or {} | |
| run_result = response_json.get('run_result') | |
| # Triton 模式下 compile_result 为 null,跳过编译检查。其余情况 | |
| # (AscendC 编译阶段产物存在)走标准 return_code 判定。 | |
| # 注意:早期版本曾在 else 分支末尾错误地多写了一条 fallback return | |
| # 'compile_failed',导致编译成功 + 有运行结果时也被误判为编译失败 | |
| # (SparseAttnSharedkv Qwen3.6-27B 2026-06-25 trace 命中此 bug)。 | |
| # 这里改写为线性 fall-through:检查编译失败 → 返回;否则继续走 | |
| # run_result 判定。 | |
| if not compile_result and run_result is not None: | |
| compile_detail = {'return_code': None, 'execution_time': None} | |
| logger.info("[%s] Triton 模式:compile_result 为空,跳过编译检查", op_name) | |
| else: | |
| compile_return_code = compile_result.get('return_code', -1) | |
| compile_stdout = compile_result.get('stdout', '') | |
| compile_stderr = compile_result.get('stderr', '') | |
| compile_detail = { | |
| 'return_code': compile_return_code, | |
| 'execution_time': compile_result.get('execution_time'), | |
| } | |
| # ========== 编译失败 ========== | |
| if compile_return_code != 0: | |
| errors = extract_compile_errors(compile_stdout + '\n' + compile_stderr) | |
| return { | |
| 'status': 'compile_failed', | |
| 'message': '编译失败', | |
| 'errors': errors, | |
| 'compile_detail': compile_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| # 编译成功,fall through 到下面统一的 run_result 判定 | |
| # ========== 编译成功但无运行结果 ========== | |
| # 适用于 AscendC 编译成功后 Step 2 profiling 未产生输出, | |
| # 以及 Triton 分支理论上的 run_result=None(虽然该分支判定时 | |
| # 已要求 run_result is not None,但防御性保留此分支)。 | |
| if run_result is None: | |
| return { | |
| 'status': 'compile_failed', | |
| 'message': '编译成功但无运行结果', | |
| 'errors': [{'type': 'no_run_result', 'message': '编译成功但无运行结果'}], | |
| 'compile_detail': compile_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| run_return_code = run_result.get('return_code', -1) | |
| run_stdout = run_result.get('stdout', '') | |
| run_stderr = run_result.get('stderr', '') | |
| run_detail = { | |
| 'return_code': run_return_code, | |
| 'execution_time': run_result.get('execution_time'), | |
| 'stdout': run_stdout[:2000], | |
| 'stderr': run_stderr[:2000] if run_stderr else '', | |
| } | |
| # ========== 运行时崩溃 ========== | |
| if run_return_code != 0: | |
| errors = extract_run_errors(run_stdout, run_stderr) | |
| return { | |
| 'status': 'test_failed', | |
| 'message': '运行时异常', | |
| 'errors': errors, | |
| 'compile_detail': compile_detail, | |
| 'run_detail': run_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| # ========== 精度检查 ========== | |
| has_pass = bool(re.search(r'PASS', run_stdout)) | |
| has_fail = bool(re.search(r'FAIL', run_stdout)) | |
| # 完成标记有两族写法,都必须认: | |
| # (1) "All tests PASSED" / "ALL CHECKS PASSED (10 cases)"(rms_norm 等) | |
| # (2) "N/M checks passed"(hc_pre_sinkhorn / fused_gdn_gating / hc_post) | |
| # 只认 (1) 时,(2) 族算子即使 40/40 全过也会掉进下面的 "has_pass and not has_fail" | |
| # 分支被判 test_failed("测试未完整运行")——2026-09-26 定位:bare 批里这三个算子 | |
| # 100% 假失败、0 候选;native 侧评测器(sandbox_evaluator)认 "checks passed", | |
| # 所以同样算子在 claude/codex 下正常。N/M 形式要求每个匹配都 N==M, | |
| # 保留"跑了一部分用例后崩溃"的检出。 | |
| _nm_markers = re.findall(r'(\d+)\s*/\s*(\d+)\s+checks passed', run_stdout, re.IGNORECASE) | |
| has_completion_marker = bool(re.search( | |
| r'(?:All tests|ALL CHECKS)\s+PASSED(?:\s*\(\d+\s+cases\))?', | |
| run_stdout, | |
| re.IGNORECASE, | |
| )) or (bool(_nm_markers) and all(a == b for a, b in _nm_markers)) | |
| if has_completion_marker and not has_fail: | |
| return { | |
| 'status': 'success', | |
| 'message': '编译测试全部通过', | |
| 'errors': [], | |
| 'compile_detail': compile_detail, | |
| 'run_detail': run_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| if has_pass and not has_fail: | |
| return { | |
| 'status': 'test_failed', | |
| 'message': '测试未完整运行', | |
| 'errors': [{ | |
| 'type': 'incomplete_test_run', | |
| 'message': ( | |
| '测试输出包含部分 PASS,但缺少最终完成标记;' | |
| '可能在后续用例中发生运行时崩溃' | |
| ), | |
| }], | |
| 'compile_detail': compile_detail, | |
| 'run_detail': run_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| # ========== 精度不对齐 ========== | |
| # Full run_stdout: LLM needs to see which tensor / which element / | |
| # what tolerance was exceeded to fix the precision mismatch. The | |
| # legacy [:500] cut tail-off many cases where the actual numeric | |
| # diff lines appeared after a long header. | |
| errors = [{'type': 'precision_mismatch', 'message': f'精度校验失败: {run_stdout.strip()}'}] | |
| return { | |
| 'status': 'test_mismatch', | |
| 'message': '精度不对齐', | |
| 'errors': errors, | |
| 'compile_detail': compile_detail, | |
| 'run_detail': run_detail, | |
| 'output': clean_output[:2000], | |
| } | |
| def _extract_and_build_report(self, op_name: str, profiling_output_dir: str) -> Dict[str, Any]: | |
| """从 profiling 输出目录中定位 op_summary CSV,聚合多循环数据并生成 Markdown 报告。""" | |
| if not os.path.isdir(profiling_output_dir): | |
| return { | |
| 'status': 'profiling_failed', | |
| 'message': f'Profiling 输出目录不存在: {profiling_output_dir}', | |
| 'errors': [{'type': 'file_not_found', 'message': f'目录不存在: {profiling_output_dir}'}], | |
| } | |
| try: | |
| result = profile_op_summary( | |
| profiling_output_dir, | |
| output_name='profiling_report.md', | |
| write=True, | |
| verbose=True, | |
| op_name=op_name, | |
| total_runs=self.profiling_protocol['total_runs'], | |
| warmup_runs=self.profiling_protocol['warmup_runs'], | |
| statistic=self.profiling_protocol['statistic'], | |
| ) | |
| logger.info("[%s] Profiling 报告生成成功: %s", op_name, result.report_path) | |
| exec_time_us = _extract_exec_time_us(result) # 旧口径:按 (Op Type,shape,case) 分组求和 | |
| aligned = _extract_aligned_duration(result) # 与 native 对齐的口径 | |
| return { | |
| 'status': 'success', | |
| 'message': 'Profiling 报告生成成功', | |
| 'profiling_report_path': result.report_path, | |
| 'profiling_report': result.report, | |
| # 与 native 评测器同口径:按算子名分组、组内取均值、跨算子求和(单位 us)。 | |
| # 同一算子的多次 launch / 多 shape 只计一次,可直接与 native 的 duration_ms 比较。 | |
| 'exec_time_us': aligned, | |
| 'duration_ms': (aligned / 1000.0) if aligned is not None else None, | |
| # 旧口径(按 launch/shape/case 分组后直接求和)保留,便于和 2026-09-24 之前的历史数据对照。 | |
| 'exec_time_us_legacy': exec_time_us, | |
| 'profiling_protocol': dict(result.profiling_protocol), | |
| 'measured_runs': result.kept_loops, | |
| } | |
| except (NotADirectoryError, FileNotFoundError, ValueError, RuntimeError) as e: | |
| logger.error("[%s] Profiling 数据处理失败: %s", op_name, str(e)) | |
| return { | |
| 'status': 'profiling_failed', | |
| 'message': f'Profiling 数据处理失败: {str(e)}', | |
| 'errors': [{'type': 'extract_error', 'message': str(e)}], | |
| } | |
| except Exception as e: | |
| logger.error("[%s] 提取 profiling 字段时异常: %s", op_name, str(e)) | |
| return { | |
| 'status': 'profiling_failed', | |
| 'message': f'提取 profiling 字段时发生异常: {str(e)}', | |
| 'errors': [{'type': 'extract_error', 'message': str(e)}], | |
| } | |
| def _extract_aligned_duration(profile_result) -> float | None: | |
| """与 native 评测器同口径的耗时(微秒):按算子名分组 → 组内按样本数加权平均 → 跨算子求和。 | |
| 对照 native 侧 `sandbox_evaluator.parse_profiling`(:419-491): | |
| * native 用 Op Name(缺失退回 Op Type / Kernel Name)作为分组标签,把一个算子的所有 | |
| 采样(多个 launch、多 shape、多轮)池化成一个均值,然后对所有算子求和,再 /1000 得 ms; | |
| * 本模块的 groups 是按 (Op Type, shapes, case_idx) 分的,直接求和会把同一算子的 | |
| 多次 launch/多 shape 重复累加(历史上 bare 的数因此比 native 大一个量级), | |
| 这里按 op_name(缺失退回 op_type)重新聚合,得到与 native 可比的数。 | |
| """ | |
| groups = getattr(profile_result, 'groups', None) | |
| if not groups: | |
| return None | |
| per_op: dict[str, list[float]] = {} | |
| for g in groups.values(): | |
| value = g.mean('Task Duration (us)') | |
| if value != value: # NaN:该组没有可用采样 | |
| continue | |
| label = getattr(g, 'op_name', '') or getattr(g, 'op_type', '') or 'unknown' | |
| weight = max(1, int(getattr(g, 'samples', 1) or 1)) | |
| acc = per_op.setdefault(label, [0.0, 0.0]) | |
| acc[0] += value * weight | |
| acc[1] += weight | |
| if not per_op: | |
| return None | |
| return sum(total / count for total, count in per_op.values()) | |
| def _extract_exec_time_us(profile_result) -> float | None: | |
| """【旧口径,保留供对照】单轮端到端耗时(微秒)= 一次完整算子调用中所有 launch 的 Task Duration 之和。 | |
| 每个 group 已经是"某个 launch 在循环间的均值",把它们求和等于"一个循环内 | |
| 完整算子调用的耗时"。对不切 launch 的算子(基线常见)等于该 launch 的均值; | |
| 对切多个 launch 的算子(如 grid 越过 65535 上限)则正确累加。 | |
| """ | |
| if profile_result is None: | |
| return None | |
| groups = getattr(profile_result, 'groups', None) | |
| if not groups: | |
| return None | |
| durations = [ | |
| g.mean('Task Duration (us)') | |
| for g in groups.values() | |
| if g.mean('Task Duration (us)') == g.mean('Task Duration (us)') | |
| ] | |
| return sum(durations) if durations else None | |