Skip to content

Keep a subroutine with no written lifetime static on the compiled tier - #970

Closed
philipaxer wants to merge 2 commits into
aionhw:mainfrom
philipaxer:up/fix-implicit-static
Closed

philipaxer wants to merge 2 commits into
aionhw:mainfrom
philipaxer:up/fix-implicit-static

Conversation

@philipaxer

@philipaxer philipaxer commented Nov 8, 2026 •

Copy link
Copy Markdown
Contributor

xezim only, based on main; the core pin is unchanged. Found while working on #952.

try_inline_task_args only refused an explicit static. A task or void function with no written lifetime is static too (§6.21, §13.3.1), and its variables retain their values between invocations (§13.3.2). Inlining gave them fresh registers on every call. Such a subroutine now stays interpreted when it has locals or non-input formals.

foreign in bytecode.rs is unchanged. A body in u.g called from u prints a different %m, so its %m fallback must not be emitted inline.

Results

Program Before After
block task static local, clocked (p26) 10 55
module task static local, clocked (a09) 10 55
automatic, static, implicit (x10) 10 55 10 10 55 55

Expected values come from the LRM. Verilator 5.055 agrees, except that an output formal of a static task does not retain its value there (1 for 10).

Suite before the rebase onto main: 6308 passed, 0 failed, 1 ignored (6297 / 0 / 1 before; 11 new tests, two of which hold behaviour that already worked).

After the rebase onto main, the 11 new tests (--test lrm implicit_static_subroutines_keep_their_variables_when_compiled) pass. CI runs the full suite.

Cost

Automatic tasks are unaffected (three benchmarks within 0.2%). A hot scalar task with no written lifetime and a loop local or output formal costs 7.65x and 4.65x in instructions, because the call goes back to the interpreter.

A more typical shape, two static tasks with integer loop locals and an array local called from a clocked always, costs 1.35x in instructions and 1.38x in wall time. No existing benchmark exercises this path.

A narrower guard that keeps inlining where fresh registers cannot be observed is planned as a follow-up.

Not covered

  • An implicit static local is not readable by path: t.i reads x (§13.3.1). An explicit static local reads back.
  • A static task that suspends is not shared across concurrent activations: 1 2 where 2 2 is right (§13.3.2).
  • A static local in an explicitly automatic task under a clocked process prints 10 for 55.
  • A static local in a block task of an automatic module prints 10 for 55.

The series

This PR is one part of a stacked series for #952. This section is the same in every part, so each PR can be read on its own.

Problem. A generate block is a scope (§23.9, §27.5, §27.6), but xezim resolved names in generate blocks by string. The elaborator renamed declarations textually (f → g.f) from per-block name lists, and the simulator retried a missed name by its last segment at run time. Each fix to that scheme, including the one for #897, broke other legal programs: a local hiding a block function was renamed anyway, items outside the copied list kept the bare name, two unlabelled blocks with the same variable collided, a child instance's call reached the wrong parent, and disable g.t matched by leaf.

Approach.

  • Core builds a scope tree for each definition: its generate blocks, all arms included, each with its declarations (scope_tree.rs).
  • A binder resolves every simple name against that tree and writes the result on the identifier: a declaration, a local or other hiding name, or "upward" (§23.8.1) (elaborate/bind.rs).
  • The generate rename then follows the binding instead of name lists. The names it produces (g.f, u.g[1].x, genblk2.t) are the keys the runtime already uses, so xezim needs almost no source change.
  • XEZIM_BIND_AUDIT=1 prints each binding next to what the rename did, so every disagreement can be listed.

Parts (core / xezim; each depends on the one before and repeats its commits until that merges):

Part Core xezim What it does
1 aionhw/xezim-core#171 #962 Scope tree; generate scope names (genblk<n>, §27.6 zero padding, §27.5 direct nesting) come from it
2 aionhw/xezim-core#172 #963 Binder and audit; no behaviour change
3 aionhw/xezim-core#173 #964 The rename follows the binding: a name a local, formal, class member or import hides keeps its spelling
4 aionhw/xezim-core#174 #965 The rename reaches final blocks, classes, gates, properties, sequences, let, covergroups, clocking and constraints
5 aionhw/xezim-core#175 #966 Bare upward calls from child instances resolve through the instance tree (§23.8.1)
6 aionhw/xezim-core#176 #967 disable by path and by label is bound like other names (§9.6.2)
7 aionhw/xezim-core#177 #968 Data of unlabelled generate blocks is scoped under genblk<n>
8 aionhw/xezim-core#180 #971 Data is renamed by binding at every position; the upward search continues past a variable
9 aionhw/xezim-core#181 #974 Typedefs of a block take the block's key
10 aionhw/xezim-core#182 #975 The binder covers the remaining legal bare names; no output change
11 aionhw/xezim-core#183 #981 Undeclared names are reported by binding: a bare name in an instance that nothing declares is an error, where it read a value found by its last segment
12 aionhw/xezim-core#184 #989 The generate rename takes its spelling from the binding; the name maps, the rename gate and the audit's comparison are removed (core -1,020/+454)
13 aionhw/xezim-core#185 #990 One generate walker instead of two; genvars are also substituted in properties, sequences, covergroups, gates and formal defaults of a loop (§27.4) (core -347/+101)

Independent of the series: #969 (time scope and clocking of a block in an instance) and #970 (a subroutine with no written lifetime stays static on the compiled tier).

Still to come.

  • Held until there is feedback: duplicate-declaration diagnostics.
  • Not planned: keys for classes in generate blocks. A class in a generate loop stays one class.

The run-time retries by leaf name stay. They serve shapes the binder cannot decide before the run (a class method calling its instance's task, g[k].f() with a variable index, virtual interfaces) and name resolution outside generate blocks (interface ports, $root, packages).

Size so far (parts 1 to 13 against main): core +4,476/-1,066 outside tests (net +3,410), +2,458 tests; xezim +198/-101 outside tests, mostly the core pin, +3,550 tests.

Testing. Every part passed the full xezim suite and the core suite before the rebase onto main. After the rebase, part 7 passed the full suites on main, and parts 8 to 13 passed the hierarchy and core suites. CI runs the rest. Each part's audit and artifact identity against the previous part are in its own text. Expected values come from IEEE 1800-2023 and are checked against Verilator 5.055 where it accepts the program.

Review order. Parts 1 and 2 are the base; the rest read from them. Reviewing those two first settles the direction.

…r (§6.21, §13.3.1, §13.3.2)

The compiled tier no longer inlines a task or void function with no written
lifetime when it has locals or non-input formals. Such a subroutine is static,
so its variables keep their values between calls. The call stays interpreted.
… §13.3.1, §13.3.2)

Static locals and output formals under a clocked process: module tasks, void
functions, block tasks bare and by path, generate-for and nested blocks in an
instance. Automatic tasks and automatic modules are the contrast. A function
with a result and a task without locals already worked and only hold that.
This was referenced Nov 8, 2026
aionhw pushed a commit that referenced this pull request Nov 9, 2026
aionhw pushed a commit that referenced this pull request Nov 9, 2026
aionhw added a commit that referenced this pull request Nov 9, 2026
aionhw added a commit that referenced this pull request Nov 9, 2026
aionhw added a commit that referenced this pull request Nov 9, 2026
…rty selects and edges, associative elements, static calls and faster foreach solving (#952, #970, #983, #980, #979, #973, #959, #955, #954, #951)
@aionhw

aionhw commented Nov 9, 2026

Copy link
Copy Markdown
Owner

Integrated by cherry-pick with @philipaxer's authorship preserved: 963c16b6 and the tests 2032df19.

Follow-up 22fcf628, dd8d7f29: with the change, every static task or void function with a local dropped off the compiled path. A clocked loop calling such a task went from 7.18 G to 199.8 G instructions. A static subroutine is now inlined unless a local or output formal can carry a value from one call to the next, and that loop is back at 7.18 G. The §13.3.1 behaviour is unchanged: a local read before it is written keeps its value.

Published in xezim 603c9bf3 with xezim-core 212dde0.
Validation: the full xezim suite passes (6610 tests, 0 failed, 1 ignored), with xezim-core 514 and parser 233 tests, the JIT smoke and DPI fallback tests, and a 1.92 MSRV check.

@aionhw aionhw closed this Nov 9, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants