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) # Function to load module from file path 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): # output_nki is a list # output_task is a tuple or a single array 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: # abs_diff = np.abs(v_k - v_r) 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() # Remove all the comments program_code = re.sub(r'#.*', '', program_code) # If "bfloat16" or "float16" is used 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}") # Get the transform_to_nki_inputs function 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: # Just retry twice. In paper, we did 10 times. 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