acceptodds
Under review as a conference paper at ICLR 2027

EvoKe: Progressive Hierarchical Evolution for Structural Exploration in Ascend C Kernel Synthesis

Abstract

Platform-native kernels are central to accelerator performance, yet developing them for an emerging programming stack remains heavily dependent on expert knowledge. LLM-based systems broaden source-level search, but typically treat an entire kernel project as the unit of generation and optimization. On a stack sparsely represented in pretraining data, this forces the model to coordinate platform knowledge with tiling, memory movement, pipelining, computation, aggregation, and host–device integration in a single context. It also entangles optimization decisions: when an assembled candidate regresses, several potentially useful changes may be discarded together, even when a structural redesign would become effective only after further refinement. We present EVOKE, a framework for structured construction and structured search of Ascend C kernels. It builds a task-conditioned knowledge workspace and progressively generates dependency-ordered semantic genes, each pairing a component design with executable code. During search, every action declares its intent, target genes, and required adaptations, so redesign, component refinement, recombination, and parameter tuning can be evaluated and retained separately. A non-stationary contextual bandit selects the next action from the current search state and experience accumulated across tasks, and assigns delayed credit to actions whose benefits emerge only after later refinement. Across 13 representative Ascend C operators on Ascend 910B, EVOKE produces correct implementations for all 13 tasks versus 9 for the whole-project baseline and achieves a 1.34× geometric-mean performance ratio on the nine tasks solved by both.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLM-based Code Generation,Kernel Synthesis,Contextual Bandit,Evolutionary Learning

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_iS3sOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper presents EVOKE, a framework for evolving native Ascend C kernels with LLMs. Instead of treating the whole kernel project as the unit of generation and optimization, it builds a task knowledge workspace, generates dependency ordered semantic genes pairing component designs with executable code, and searches over them with intent declared actions selected by a non stationary contextual bandit with delayed credit assignment. On 13 Ascend C operators, EVOKE solves all 13 tasks versus 9 for the whole project baseline, with a 1.34x geometric mean performance ratio on tasks solved by both.

Critical strengths
  • Well motivated. The paper identifies how whole project evolution entangles optimization decisions and proposes keeping the construction structure editable during search, an original and clearly articulated idea.

  • Principled design. The combination of progressive semantic gene construction, intent controlled search, and bandit scheduling with delayed credit is coherent and technically sound.

Critical weaknesses
  • Small, self built task set. The evaluation relies on 13 self constructed operators, far smaller than standard public benchmarks. With so few tasks, the main results have limited statistical power, and task selection bias cannot be ruled out.

  • Missing key baselines. The paper compares only against CANNBot, while several relevant systems including concurrent Ascend C generation methods and platform agnostic program evolution frameworks such as AlphaEvolve are neither included nor discussed as baselines. Without such comparisons, it is unclear whether the gains come from the proposed structure or simply from a weak baseline.

  • No evaluation on public benchmarks or other platforms. All experiments use a single self built Ascend setting, while the method's core components are tightly coupled to Ascend C. The claimed generality of the framework is therefore not supported by the evidence.

Questions for authors

Can EVOKE be applied to non-Ascend platforms, for example by evaluating it on KernelBench or similar public benchmarks?

Reviewer_TrwrOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

EVOKE constructs Ascend C kernels as dependency-ordered semantic components and preserves these components during scoped, intent-specific optimization. A contextual bandit selects search actions, with eligibility traces and transferable posteriors intended to capture delayed benefits and cross-task experience. On 13 operators, the paper reports 13 versus 9 correctness-valid solutions for CANNBot and a 1.34x geometric-mean performance ratio over nine common successes.

Critical strengths

S1. Keeping component designs, code, and interface contracts together makes a useful connection between initial generation and later optimization.

S2. The structural contribution is meaningfully tested (progressive initialization improves starting quality, while matched local-versus-global edits produce improvements more often). These controls support benefits beyond merely generating more candidates.

S3. Under the stated matched budgets, the full system also beats a baseline with multiple whole-program optimization actions on 11/12 paired cases.

Critical weaknesses

W1. EVOKE does better than choosing changes at random, but the paper does not test its extra learning features separately. Does remembering other tasks help? Does giving credit to an earlier change that only pays off later help? Comparing results with these features switched on and off would make their value clearer.

W2. Systematic repeated run results are not reported.

Questions for authors
  1. Does removing delayed rewards or starting without experience from other tasks change performance, or should these claims be narrowed?
  2. Across repeated matched runs, how consistent are the scheduler's wins and typical gains over random selection?
Reviewer_riMuOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

EvoKe constructs and optimizes Ascend C kernels through persistent semantic components that pair design descriptions with executable code. Dependency-ordered initialization uses retrieved platform knowledge; subsequent actions declare their optimization intent, target components, and required adaptations. A contextual Thompson-sampling scheduler combines immediate rewards, delayed credit, and potentially transferred experience. Additional studies examine initialization, editing scope, scheduling, and eight harder initialization tasks.

Critical strengths
  1. Using the same semantic components for construction and optimization is a useful design for a coupled native programming stack. Explicit contracts and adaptation scopes let the system preserve useful local changes while coordinating host/device dependencies. The comparison between Global-Single and Modular-Single fixes the initial candidate, action set, and trial budget and reports a higher positive-improvement rate, supporting the value of the representation (Section 5.3 and Table 3).

  2. The evaluation distinguishes feasibility from speed and reports unfavorable cases clearly. EvoKe solves four additional operators, wins eight of nine common successes, and increases the number of reference-beating implementations from four to seven (Table 2). These results help identify where structured generation is useful and where its gains are limited.

Critical weaknesses
  1. The PDF does not provide enough detail to verify the main matched-resource comparison. Sections 5 and B.1 state that model-call and hardware-evaluation budgets are matched, and B.1/B.8 include failed and timed-out attempts in cost accounting. However, the shared model, budget limits, evaluation protocol, and treatment of initial construction and repair are not specified sufficiently to assess that claim. The existing supplementary configurations may resolve this; the key information is requested below.

  2. The scheduler comparison does not specify the prior experience used during evaluation. Runs can start from saved posteriors, but Section 5.4 does not state which experience was used or how its cost was counted. This leaves it unclear whether the scheduler advantage holds under comparable resources.

Questions for authors
  1. Which LLM and version, numerical generation budget, and hardware-evaluation budget were used for EvoKe and the principal baselines? Please identify the shared configuration and clarify how initial construction and repair fit within those limits.

  2. What correctness and timing protocol was used to evaluate the reported kernels, and was it applied consistently across methods? Please summarize the key settings or identify the corresponding supplementary configuration.

  3. Were the evaluated schedulers initialized from fresh or saved posteriors? If prior experience was used, what experience did it contain and how was its cost accounted for in the comparison?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.