| import json, uuid, time, tempfile |
| import os |
| import traceback |
| import numpy as np |
| import sys |
| import re |
| from pathlib import Path |
| from pydantic import BaseModel, Field |
|
|
| class KernelProperties(BaseModel): |
| """ |
| Single Kernel Execution |
| """ |
| compiled: bool = False |
| correct: bool = False |
| runnable: bool = False |
| metadata: dict = Field(default_factory=dict) |
|
|
| |
| def load_module_from_path(file_path): |
| parent_dir = str(Path(file_path).parent) |
| if parent_dir not in sys.path: |
| sys.path.append(parent_dir) |
| import importlib.util |
| spec = importlib.util.spec_from_file_location("module", file_path) |
| if spec is None or spec.loader is None: |
| raise ImportError(f"Could not load module from {file_path}") |
| module = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(module) |
| return module |
|
|
|
|
| def l2norm_allclose(v_k, v_r, rel_tol=1e-5): |
| return np.linalg.norm((v_k - v_r).astype(np.float64)) < rel_tol * np.linalg.norm(v_r.astype(np.float64)) |
|
|
| def check_correctness_numpy(output_nki, output_task, res, rel_tol=2e-5): |
| |
| |
| if not isinstance(output_task, tuple): |
| output_task_tuple = (output_task,) |
| else: |
| output_task_tuple = output_task |
| is_correct = True |
| if len(output_nki) != len(output_task_tuple): |
| res.metadata.setdefault("correctness_error", []).append( |
| f"Num outputs mismatch: nki={len(output_nki)} vs ref={len(output_task_tuple)}" |
| ) |
| res.correct = False |
| return |
| for i, (v_k, v_r) in enumerate(zip(output_nki, output_task_tuple)): |
| if hasattr(v_r, "shape") and hasattr(v_k, "shape"): |
| if v_k.shape != v_r.shape: |
| res.metadata.setdefault("correctness_error", []).append(f"Output {i} shape mismatch, expected {v_r.shape}, got {v_k.shape}; ") |
| is_correct = False |
| if not l2norm_allclose(v_k, v_r, rel_tol=rel_tol): |
| max_diff = np.amax(np.abs(v_k - v_r)) |
| avg_diff = np.mean(np.abs(v_k - v_r)) |
| max_rel_diff = np.amax(np.abs(v_k - v_r) / np.abs(v_r)) |
| l2norm_diff = np.linalg.norm((v_k - v_r).astype(np.float64)) |
| l2norm_ref = np.linalg.norm(v_r.astype(np.float64)) |
| l2norm_rel_diff = l2norm_diff / l2norm_ref |
| res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, max diff {max_diff:.6f}, avg diff {avg_diff:.6f}, max rel diff {max_rel_diff:.6f}, l2norm diff {l2norm_diff:.6f}, l2norm ref {l2norm_ref:.6f}, l2norm rel diff {l2norm_rel_diff:.6f}") |
| is_correct = False |
| else: |
| |
| if np.issubdtype(type(v_r), np.floating) or np.issubdtype(type(v_k), np.floating): |
| if not l2norm_allclose(v_k, v_r, rel_tol=rel_tol): |
| res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, expected {v_r}, got {v_k};") |
| is_correct = False |
| else: |
| if v_k != v_r: |
| res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, expected {v_r}, got {v_k}; ") |
| is_correct = False |
| res.correct = is_correct |
|
|
| def check_precision_and_correctness(program_path, output_nki, output_task, res, rel_tol): |
| with open(program_path, 'r') as f: |
| program_code = f.read() |
| |
| program_code = re.sub(r'#.*', '', program_code) |
| |
| if "float16" in program_code: |
| res.metadata["correctness_error"] = "Float16 is used in the program." |
| res.correct = False |
| return |
| check_correctness_numpy(output_nki, output_task, res, rel_tol=rel_tol) |
|
|
| import neuronxcc.nki as nki |
|
|
| def get_latency(nki_kernel_fn, nki_inputs, artifact_dir): |
| kernel_id = uuid.uuid4() |
| neff_path = os.path.join(artifact_dir, f"neff_{kernel_id}.neff") |
| ntff_path = os.path.join(artifact_dir, f"ntff_{kernel_id}.ntff") |
| nki.baremetal( |
| nki_kernel_fn, |
| save_neff_name=neff_path, |
| save_trace_name=ntff_path, |
| additional_compile_opt="--disable-dge --logical-nc-config=1" |
| )(*nki_inputs) |
| summary_profile_path = os.path.join(artifact_dir, f"profile_{kernel_id}.json") |
|
|
| summary_profile_cmd = f"neuron-profile view --output-format summary-json -n {neff_path} -s {ntff_path} > {summary_profile_path}" |
| os.system(summary_profile_cmd) |
| summary = json.load(open(summary_profile_path, 'r')) |
| latency_ms = summary[next(iter(summary))]["total_time"] * 1e3 |
| return latency_ms |
|
|
| def benchmark_latency(warmpup_iterations, benchmark_iterations, nki_kernel_fn, nki_inputs, artifact_dir): |
| for _ in range(warmpup_iterations): |
| nki.baremetal( |
| nki_kernel_fn, |
| additional_compile_opt="--disable-dge --logical-nc-config=1" |
| )(*nki_inputs) |
| latency_ms_list = [] |
| for _ in range(benchmark_iterations): |
| latency_ms = get_latency(nki_kernel_fn, nki_inputs, artifact_dir) |
| latency_ms_list.append(latency_ms) |
| runtime_stats = { |
| "mean_ms": np.mean(latency_ms_list), |
| "min_ms": np.min(latency_ms_list), |
| "max_ms": np.max(latency_ms_list), |
| "rel_diffs": (np.max(latency_ms_list) - np.min(latency_ms_list)) / np.min(latency_ms_list) |
| } |
| return runtime_stats |
|
|
| class NKIKernel: |
| def __init__(self, program_path: str, base_numpy_path: str): |
| self.program_path = program_path |
| self.base_numpy_path = base_numpy_path |
| self.res = KernelProperties() |
| self.rel_tol = 2e-5 |
| self.perf_tol = 0.01 |
|
|
| def profile(self, save_fields: list[str] = []): |
|
|
| os.environ["NEURON_CC_FLAGS"] = "--auto-cast=none" |
| os.environ['NEURON_RT_NUM_CORES']= '1' |
| np.random.seed(42) |
| task_module = load_module_from_path(self.base_numpy_path) |
| task_fn = task_module.forward |
| task_np_input_fn = task_module.get_inputs |
| task_np_inputs = task_np_input_fn() |
| task_nki_output_fn = task_module.transform_nki_outputs |
| self.res = KernelProperties() |
| new_profile_name = f"nki_{uuid.uuid4()}" |
|
|
| with tempfile.TemporaryDirectory(dir="/tmp", prefix=f"{new_profile_name}_") as artifact_dir: |
| neff_path = os.path.join(artifact_dir, f"kernel_file.neff") |
| ntff_path = os.path.join(artifact_dir, f"kernel_profile.ntff") |
| try: |
| nki_kernel_module = load_module_from_path(self.program_path) |
| if hasattr(nki_kernel_module, "kernel"): |
| nki_kernel_fn = nki_kernel_module.kernel |
| elif hasattr(nki_kernel_module, "optimized_kernel"): |
| nki_kernel_fn = nki_kernel_module.optimized_kernel |
| else: |
| raise ValueError(f"No kernel function found in {self.program_path}") |
| |
| if hasattr(task_module, "transform_to_nki_inputs"): |
| task_nki_input_fn = task_module.transform_to_nki_inputs |
| else: |
| raise ValueError(f"No transform_to_nki_inputs function found in {self.program_path} or {self.base_numpy_path}") |
| nki_inputs = task_nki_input_fn(task_np_inputs) |
| |
| output_nki = nki.baremetal( |
| nki_kernel_fn, |
| save_neff_name=neff_path, |
| save_trace_name=ntff_path, |
| additional_compile_opt="--disable-dge --logical-nc-config=1" |
| )(*nki_inputs) |
| self.res.compiled = True |
| self.res.runnable = True |
| |
| except Exception as e: |
| print(f"Compilation failure. Error: {e}") |
| self.res.metadata["compilation_error"] = str(e) |
| self.res.metadata["compilation_traceback"] = traceback.format_exc() |
| return self.res |
|
|
| try: |
| for rnd_seed in [0, 21, 42, 63, 84]: |
| np.random.seed(rnd_seed) |
| task_np_inputs = task_np_input_fn() |
| nki_inputs = task_nki_input_fn(task_np_inputs) |
| output_task = task_fn(*task_np_inputs) |
| output_nki_raw = nki.baremetal( |
| nki_kernel_fn, |
| additional_compile_opt="--disable-dge --logical-nc-config=1" |
| )(*nki_inputs) |
| output_nki = task_nki_output_fn(output_nki_raw, output_task) |
| check_precision_and_correctness(self.program_path, output_nki, output_task, self.res, self.rel_tol) |
| if not self.res.correct: |
| break |
| except Exception as e: |
| print(f"Correct checking failure. Error: {e}") |
| self.res.metadata["correctness_error"] = str(e) |
| return self.res |
| |
| if not self.res.correct: |
| return self.res |
|
|
| try: |
| runtime_stats = benchmark_latency(2, 10, nki_kernel_fn, nki_inputs, artifact_dir) |
| rel_diff = runtime_stats["rel_diffs"] |
| rel_diff_list = [rel_diff] |
| runtime_stats_list = [runtime_stats] |
| while rel_diff > self.perf_tol: |
| print(f"Retry: {self.program_path } at {len(rel_diff_list)}; rel_diffs: {rel_diff_list}") |
| time.sleep(1) |
| |
| rel_diff_list.append(rel_diff) |
| runtime_stats_list.append(runtime_stats) |
| if len(rel_diff_list) > 2: |
| break |
| runtime_stats = runtime_stats_list[np.argmin(rel_diff_list)] |
| self.res.metadata["latency"] = runtime_stats["mean_ms"] |
| self.res.metadata["min_ms"] = runtime_stats["min_ms"] |
| self.res.metadata["max_ms"] = runtime_stats["max_ms"] |
| self.res.metadata["rel_diffs"] = runtime_stats["rel_diffs"] |
|
|
| summary_profile_path = os.path.join(artifact_dir, f"{new_profile_name}_summary_profile.json") |
| summary_profile_cmd = f"neuron-profile view --output-format summary-json -n {neff_path} -s {ntff_path} > {summary_profile_path}" |
| os.system(summary_profile_cmd) |
| summary = json.load(open(summary_profile_path, 'r')) |
| profile_result = summary[next(iter(summary))] |
| for field in save_fields: |
| if field in profile_result.keys(): |
| self.res.metadata[field] = profile_result[field] |
| except Exception as e: |
| print(f"Benchmarking failure. Error: {e}") |
| self.res.metadata["benchmarking_error"] = traceback.format_exc() |
| return self.res |
| return self.res |
