EdgeKernelBench: Unified LLM-Driven Kernel Generation for Edge Backends

EdgeKernelBench. Unified LLM-Driven Kernel Generation for Edge Backends. By Yuhua Zheng and five others, from Westlake University and Zhejiang University. Published on the seventeenth of October. Its code repository is worked out: about ninety-five source files, with a readme and a licence.

Recent work shows that large language models can generate kernels with strong performance on server GPUs. Edge deployment is a different situation. The hardware is heterogeneous, the software stacks are fragmented, and the resource budgets are tight. Across that diversity of edge backends, kernel generation by language models has not yet been studied systematically, so there is no common ground on which to say how well it works.

EdgeKernelBench is meant to supply that ground. It measures two things that a single pass rate would merge: whether a generated kernel is functionally correct, reported as Correct at one, and whether it is actually fast, reported as Fast at one point zero. The benchmark is hierarchical, spanning progressively larger program scopes, from individual operators up to compact model graphs, drawn from representative edge application domains. A small operator and a whole compact model are very different jobs, and laying them out as levels lets the difficulty grow with the scope of the program.

Underneath the benchmark sits a unified IR deployment framework. The unified IR captures computation, scheduling and memory decisions in a reusable form, and it reaches each target backend through a compiler interface, so one representation can be deployed to many kinds of hardware. The authors instantiate the design with TVM as the reference compiler, and validate it across heterogeneous edge backends. The point of the shared layer is that the same generated decisions can be judged on every backend in the same way.

With a single generation attempt, the best model reaches sixty-four point five percent Correct at one. Its Fast at one point zero is only twenty-five point five percent. That gap is the central finding: functional correctness does not consistently translate into performance gains. Most of the kernels that work are not kernels that run faster, and a benchmark that counted only correctness would never have shown it.

In response, the authors introduce the Layered Edge Kernel Agent, LEKA, which organizes optimization through a layered IR. On the agent evaluation subset, LEKA reaches forty-three point five percent Fast at one point zero. Direct generation reaches thirteen percent, and Claude Code reaches twenty-six point one percent. LEKA and Claude Code share the same base model and the same optimization budget, so the difference sits in how the optimization is organized.

A kernel that compiles and returns the right numbers has passed one test, and EdgeKernelBench insists on a second. Scored that way, most generated edge kernels clear the first bar and fall at the next, and the benchmark and LEKA together are offered as a shared place to measure, and to narrow, that distance.