Skip to content

xezim-bin 0.11.0

Choose a tag to compare

@github-actions github-actions released this 28 Sep 14:45
· 4 commits to main since this release

Automated build of xezim-bin 0.11.0.

Upstream: https://github.com/aionhw/xezim/releases/tag/0.11.0

Upstream changes

0.11.0 — code coverage, reference-parity fixes, faster UVM (September 2026)

Correctness

  • UVM: a blocking task called on a function result
    (pool.get("x").wait_trigger()) suspends the caller;
    iface_array[i].handle = new constructs the object; $typename of class
    handles, this and class typedefs prints class [pkg::]name #(params);
    std::randomize(obj.member) with {...} works; queue and dynamic-array
    locals of class methods are per call; 2-state class properties and
    struct members drop X/Z on assignment (UVM register reads of a status
    field returned X); inline constraints tying rand sub-objects together
    are solved jointly; parked wait(cond) statements re-check only when a
    name they read changes; SIGTERM and Ctrl-C end a run stuck in a
    constraint solve within 5 s.
  • The --features jit build compiles again.
  • Functional coverage: covergroups work in instantiated modules,
    interfaces, packages, file scope, multi-top designs and classes declared
    in modules (each module instance gets its own covergroup, named u0.cg
    in xezim_cov.json). Cross bodies support binsof, intersect, !,
    &&, ||, with and cross ignore_bins/illegal_bins; bins x[N],
    transition sets, lists and repetitions work; option.at_least applies to
    automatic and cross bins; @(clk iff en) and named-event sampling work;
    cg_type::get_coverage(), (covered, total), start()/stop() and
    cg.option.<name> reads are supported; illegal_bins hits are errors
    (counted by --error-exit); unlabeled coverpoints are named after their
    variable; cover sequence counts every match; and assertion entries in
    xezim_cov.json carry file and line. Coverage numbers match the
    reference simulator. See docs/coverage-guide.md.
  • UVM examples that hung now finish: a clock generator on an interface
    member (BUS.clk) toggles its own signal; a non-root module drives
    members of its own interface array (assign INT[0].irq = ...); class
    handles in child instances start as null; semaphore s = new(N) as a
    class member gets N keys; new through a typedef of a parameterized
    class builds that specialization (UVM transaction event pools);
    a redeclared base-class property keeps its own initializer; fixed-size
    arrays declared in class methods are separate per call; a class
    property takes precedence over a same-named module signal; and
    randomize() with {} constraints on members of nested rand objects
    (register-model fields) are solved.
  • sv-tests: 98.9% pass (from 97.6%). Strict checks reject malformed UDP
    table rows, duplicate non-ANSI subroutine port declarations, constructor
    body port declarations, end labels on unnamed blocks, #([7:0] A) without
    parameter, for (var [7:0] i ...), void' of a non-call, mixed
    positional and named connections, inout port defaults, generate loops
    without a genvar, self and generate-local defparam targets, and more;
    non-ANSI port expressions (.b(a[2:1]), {a, b}) are supported, and a
    ranged non-ANSI subroutine port redeclared as a reg is one port.
  • obj.randomize() with {...} binds names in the object first and then in
    the calling scope (§18.7): caller locals, inherited members, array and
    queue elements, handle members and local:: names now work, and a
    caller local no longer hides an object member. A receiver-less
    randomize() with {...} in a class method applies its inline block.
  • Randomization semantics follow the reference simulator: dist weights
    hold in coupled constraint sets (:= weighs every declared value, :/
    the whole item), solve a before b picks a uniformly, randomize(a, b) makes exactly the named members random (even non-rand ones), and
    an inside {[hi:lo]} range with the bounds reversed is empty.
  • Processes waiting on a net driven by a continuous assignment (assign CLK2 = PCLK;) resume after those waiting on its source, and waiters on
    an interface's clock port after both, as in the reference simulator.
    Testbenches that race on this order (the uart UVM example's modem tests)
    now agree with it.
  • %m and the "Scope:" line of $info/$warning/$error name the
    declaring scope (pk.f, pk.C.show, tb.u.E.show); generate blocks,
    named always blocks and labelled assertions are scopes. Auto-detected
    tops run in source order. A class and an interface may share a name,
    a blocking randcase branch suspends its process, and package-scope
    initializers may call $sformatf.
  • Absolute hierarchical writes (tb.u.sig = v) inside tasks, functions
    and class methods take effect; a callee's local declaration no longer
    changes a same-named variable's type in the caller (a signed int read
    back through inout printed unsigned); arithmetic wider than 128 bits
    keeps every bit; a forked package task runs as its own process;
    s.h = new on a struct's class-handle member constructs it; defparam
    paths resolve upward; a bare name in a class method must be visible from
    that class (UVM 1.2's removed global factory is rejected, as the
    reference simulator does).
  • sv-tests: 97.7% pass (from 94.8%). New legality checks reject what the
    LRM forbids and the reference simulator rejects: enum, unpacked-array
    and class-handle assignment compatibility, subroutine argument binding,
    constant expressions in ranges/parameters/part-selects, automatic
    variables in NBAs and procedural assigns, enum base types, packed struct
    members, net output ports, replication counts and casting sizes, gate
    terminal counts, package exports and scoped names, and parameter
    overrides. Parser: min:typ:max delays, and #6 (q, a, b), net
    declaration delays after the data type, nameless UDP instances,
    this.super.x, and begin_keywords "1364-2001-noconfig".
  • UVM 1800.2 (2020.3) DPI: uvm_re_comp/uvm_re_exec/uvm_re_compexec/
    uvm_re_deglobbed follow UVM's C code, and uvm_hdl_signal_size and
    the uvm_polling_* value-change API are built in. UVM testbenches
    compiled without UVM_NO_DPI used to abort at time 0 on unresolved
    regex symbols.
  • An inout or output formal passes a virtual-interface handle back to
    its caller even when the actual was null on entry (uvm_resource_db:: read_by_name returned nothing), and a formal no longer leaks into a
    same-named class property.
  • An unconnected 2-state output port of an interface or module starts at
    0 instead of x, so a clock driven through one toggles.
  • Deferred immediate assertions (assert #0, assert final) run their
    action blocks at the end of the time slot; a report whose process
    resumes first is dropped, and one still pending at $finish prints a
    note instead.
  • A path-delayed output also delays its first change at time 0, as the
    reference simulator does.
  • randomize() with { ... } over struct members is about 13x faster.
  • UVM tables print their rows: copying a whole element out of a
    class-property collection of unpacked structs (row = m_rows[i], queue,
    dynamic, fixed or associative) gave zeros, so the topology print and
    sprint() tables were blank. Such elements now copy, return, compare and
    print with %p correctly, and this.q[i].m reads and writes them. %s
    of a string member reached through a select no longer pads, %p of a
    string-valued call prints the string, and %0p prints it unquoted.
  • Unpacked-struct locals in initial blocks and subroutines: member writes
    through selects, packed-member fields and declaration initializers take
    effect, 2-state members start at 0, and members that are arrays of
    structs survive whole-struct assignment.
  • Time-0 activation order follows the reference simulator: depth-first
    source order through the hierarchy, bound instances after their host's
    own items (several binds into one host in reverse order), and initial
    blocks that cannot suspend run as one group.
  • Assertions: named properties and sequences declared in sub-modules and
    interfaces work in assert property, every instance of an assertion
    interface evaluates its own assertions (only the first one did), bind
    accepts interface targets by name or path, and an action block reports
    its assertion's own scope.
  • A virtual interface can be bound to a nested interface instance by
    hierarchical path (a.d, g[0].a.d), and tasks can be called through a
    generate-block path.
  • UVM's DPI-C functions are built in, so +define+UVM_NO_DPI is optional:
    regular expressions and globs for config_db, resource_db, factory
    overrides and +uvm_set_* plusargs, the command-line processor, and the
    uvm_hdl_* backdoor (read, deposit, force, release by hierarchical
    path). A --dpi-lib that defines a symbol still takes precedence.
  • A second hierarchical write such as u_sub.sig = v went into a class
    object instead of the signal once any class object existed (every UVM
    testbench). 2-state variables in instantiated modules no longer hold x/z,
    and a released net takes its drivers' value immediately.
  • Specify path delays count the declaring module's timeunit (they ran 1000x
    short in a 1ns/1ps module). All path forms are modelled (*>, polarity,
    edge-sensitive, if/ifnone, 2/3/6/12-value delay lists), the delay is
    chosen per transition and enabled path, and outputs reject pulses
    narrower than the delay. SDF IOPATH still overrides them.
  • Identifiers declared nowhere in the design are an error inside task,
    function, class-method, package, interface and program bodies, as they
    already were elsewhere.
  • Untyped parameters take the width and signedness of their initializer
    (localparam C = {8'h1, 8'h2} is 16 bits, {4{B}} and string literals
    keep all their bits, parameter unsigned P = 5 is unsigned). A string
    parameter prints with %s like a string variable.
  • Several tops each act as their own root: the internal wrapper name no
    longer appears in %m, messages, VPI or VCD/FST/XTrace scopes, a
    defparam path may start at a top, and $bits(<type>) in a child
    instance uses that instance's parameters.
  • From the sv-tests suite (now 94.8%): `include of a function-like
    macro expands fully; paren-less aa.size counts entries; item.index
    works in locator with clauses; repeat rounds a real count; expect
    blocks until its attempt finishes; = @ev rhs without parentheses waits;
    input port defaults use the instance's own parameters; subroutines in
    labelled generate branches resolve; $bits of a class type parameter
    works in class constants. Strict mode rejects a second or mis-sized
    non-ANSI port redeclaration, specparam/module declarations inside
    generate blocks, class/string/chandle/event nets, and an unqualified
    interface-class typedef used by an implementing class.
  • Casts evaluate their operand at the cast type's width (IEEE 1800-2017
    §6.24.1): int'(a + b) over 8-bit operands is 300, not 44. This holds
    in procedural code, continuous assigns, constants, packed dimensions and
    constraints; signed'/unsigned' keep the operand's own width.
    pkg::T'(x) casts are no longer dropped, and interpreted / and %
    size by both operands ((a + b) / 3 gave 14 instead of 100).
  • Typed parameters use their declared width as the context of their value
    (localparam int P = A + B), and module header parameters keep their
    declared signedness (parameter bit [7:0] P = 200 read -56).
  • Reductions and sorts with a with clause work on class properties
    (o.arr.sum() with (item * 2), this.arr, objs[i].arr), and
    associative arrays reduce over their keys (aa.sum() returned 0).
  • Associative-array elements follow their declared type: a missing key
    reads 0 for int and x for integer/logic (function and task locals
    read a 1-bit x), stores take the element's signedness, and ++/--
    keep the operand's signedness (seen[k]++ on a new key gave x).
  • Specify-block timing checks are modelled: $setup, $hold,
    $setuphold, $recovery, $removal, $recrem, $skew, $timeskew,
    $fullskew, $period, $width and $nochange, with edge qualifiers,
    &&& conditions, notifiers (toggled in the NBA region, once per time
    step) and negative $setuphold/$recrem limits. A violation prints one
    ** Error: ... violation in <instance> at time <t> line, counts toward
    --error-exit, and does not stop the run. +notimingcheck(s) and
    +nospecify disable the checks (the flag used to be a no-op), and
    +no_notifier / +no_tchk_msg are honoured. A specparam declared
    inside a specify block is now a module-scoped constant instead of being
    dropped.
  • SDF TIMINGCHECK entries (with edges, COND and INSTANCE *)
    back-annotate check limits through --sdf and $sdf_annotate. SDF
    delays now scale to the simulation tick: designs with ps precision got
    delays 1000x too short.
  • A package parameter takes its signedness from its declared type:
    parameter bit B = 1 is 1, not -1, and a ranged untyped package
    parameter takes the declared range's width. The apb AVIP never built its
    master driver because of this.
  • A task of an interface or module instance, called in a forever loop
    through a virtual interface or a hierarchical path, keeps running. The
    loop used to stop silently or with a false "null receiver" error.
  • Clock generators keep first-in-first-out order with the other events of
    their time slot: a #delay scheduled after the generator's previous
    toggle resumes after this one. A reset asserted and released around a
    clock edge now spans that edge as it does in the reference simulator.
  • A one-element array of instances (bus_if b[1]) has its element b[0].
  • @(cb) for a clocking block declared in a module or interface instance
    waits for the block's clock inside that instance's tasks and processes
    instead of returning at once.
  • randomize() solves constraint sets that tie many variables together:
    an array sum() (including with (... item.index ...)), unique,
    orderings between elements or arrays, and ->/if around them. When
    the per-variable solver fails, a bounded joint search takes over.
    Infeasible sets of this kind return 0 promptly and leave the random
    variables, array elements included, unchanged. Sums such as
    a + b + c == K compare at the full context width instead of wrapping
    at the operand width. A random size variable tied to arr.size() is no
    longer pinned to the previous size, and item.index reads the element
    index inside reduction with clauses.
  • String methods on a subroutine formal or local (name.len(),
    name.getc(i), name.substr(i, j)) read that variable, not a same-named
    signal of some design instance (an interface's string name). UVM's
    resource-name check read the wrong string, so its UVM/RSRC/NOREGEX
    warning never fired on testbenches with such interfaces.
  • A module or interface task reached through a virtual interface or a
    hierarchical path resolves names in its own scope. Called from a class
    method, an unqualified call in its body used to bind to the calling
    class's method of the same name — which is how uvm_info inside a BFM
    task was attributed to the calling component instead of the global
    reporter.
  • Covergroup coverage numbers match the LRM: ignore_bins and
    illegal_bins values are excluded from array and automatic bins; an
    automatic cross has the product of its coverpoints' bins (not of their
    value ranges); a crossed variable without a coverpoint is an implicit
    coverpoint that is sampled and counts in the group; cg.cp.get_coverage()
    and cg.cp.get_inst_coverage() report that coverpoint or cross (they
    returned the group's number); type coverage averages the instances unless
    type_option.merge_instances is set; $get_coverage weights each type by
    its type_option.weight; a ref constructor formal reads its actual at
    every sample; bin bounds may be expressions of constructor formals.
  • A concurrent assertion clocked by an event without an edge (@(clk), or
    @clk on a checker's event formal) samples on every change of the clock,
    as §9.4.2 defines; it used to sample on the rising edge only.
  • A checker's event formal accepts an edge actual (chk u(v, posedge clk)),
    which used to be a parse error, and the checker's assertions clock on
    that edge.
  • A declaration after a statement in a begin-end or fork-join block
    or a subroutine body is rejected (§9.3.1); --no-strict still accepts it.
  • A replication whose count is a signed constant expression is read as
    signed: {$bits(T) - 1{1'b1}} in a type-parameterized class whose type
    parameter is unresolved replicates nothing instead of wrapping to about
    four billion copies, which never finished elaborating. Specializations
    keep their widths (int gives 31 ones, byte gives 7).
  • mailbox and semaphore objects are constructed by every form of
    new: a parenthesis-less mailbox mb = new; or mb = new;, and a
    declaration inside a block (automatic mailbox #(int) mb = new(2);,
    automatic semaphore s = new(1);). These left the mailbox null (the run
    stopped at "null mailbox handle") or the semaphore without its keys.
  • Reading an unpacked-array element with an out-of-range index yields x at
    the element's width (§7.4.6). Three paths produced a 1-bit x that the
    store then zero-extended to 0000000X: the fused memory-read flop
    (q <= mem[i]), a blocking read in a process (a = mem[i]) and the same
    read through a task output. Combinational reads were already right.
  • Selecting from a class property inside an always block or an assign
    reads the property instead of zero. bk.arr[i], bk.arr[3][0] and
    bk.arr[i][3:0] asked the interpreter for bk.arr alone, which is an
    array and does not reduce to one number, and then selected from that
    number; an accumulator fed by bk.arr[i] stayed at 0 while $display of
    the same expression printed the right element.

Usability

  • Code coverage: --code-coverage[=stmt,branch,toggle] (all three by
    default), --code-coverage-scope=<path>[,...] and XEZIM_CODE_COVERAGE
    turn on statement, branch (if/else and case arms including the implicit
    ones, ?:) and toggle (per-bit rise/fall) coverage; +cover[=sbt] and
    -coverage now enable it too. Results go in xezim_cov.json under
    code_coverage, per instance and per design unit, with a per-scope
    summary under --verbose. It is off by default and costs nothing when
    off. See docs/coverage-guide.md.
  • $fwrite/$fdisplay to regular files are buffered (64 KB per handle)
    and flushed on $fflush, $fclose, $finish, $system, $fopen,
    $readmem*/$writemem*, DPI/VPI calls and before any read of the same
    file; a 400k-line trace testbench went from 1.78 s to 1.15 s. A
    tail -f on a trace file now lags until the next flush.
  • The default simulation time limit is 100 ms instead of 100 µs, so UVM
    tests that run for milliseconds (for example 2–25 ms of simulated time)
    finish instead of stopping early. A design that never calls $finish
    still stops at the limit; --max-time sets a different one, and
    -do "run -all" runs until $finish.
  • Command lines written for other simulators run as-is: bare or work.
    top names, -F, -g/-G parameter overrides, -sv_seed,
    -sv_lib/-sv_root, -svNNcompat, and a -do subset (run -all,
    run <time>, quit, exit, do <file>; log, add wave and
    coverage save/report are accepted with a warning; anything else is an
    error). Library options (-work, -L, -lib) are ignored with one
    warning; -c and -l keep their xezim meanings. run -all runs past
    the default time cap, and after run <time> the closing line and
    final blocks see the stop time.
  • Runs are quiet by default. The transcript holds the design's output,
    warnings and errors, and one closing line, Simulation finished at time N ($finish called). The version banner, [PHASE] timings,
    [PROF]/[FUSE]/[EVENT-EDGE]/[COV] counters, [CACHE] hits and
    --compile's design summary now need --verbose (or XEZIM_VERBOSE=1,
    --profile or --sim-debug). The apb AVIP transcript went from 189 lines
    to 150.
  • Parse, preprocessor and elaboration errors print file:line:col with the
    source line and a caret. A line that came from an included file names
    that file, with an "In file included from" chain, and text produced by a
    macro names the macro invocation. Runtime locations (hang reports,
    port-width warnings) are no longer shifted by includes.
  • Preprocessor errors and warnings print once per run instead of once per
    pass. Parser warnings, such as an unsupported UDP table, now carry their
    location, and `__LINE__ after a multi-line define reports the right
    line.

Performance (instruction counts, output identical)

  • UVM class code, round three: member reads, calls, member-target
    assignments and comparisons take direct paths, and flat names, handle
    keys and element names are built without format! or clones. UVM stress
    bench: 10.8 M -> 9.0 M host instructions per item (-17%); the six AVIPs
    run 13-15% fewer instructions (axi4 46.6 G -> 39.8 G).
  • RTL: process FSMs resolve <top>.path reads (a testbench monitor ran on
    the AST path with name lookups every clock), check_edges reuses its
    fired-edge buffers, and FSM wait terms are cached: c906 CoreMark 471.5 G
    -> 459.5 G (-2.5%), c906 memcpy -2.1%.
  • UVM class code, round two: formal snapshots by position, plain-type
    fast paths for locals and formals, per-class property-owner indexes,
    forward-declared classes (typedef class X;, 110 in UVM) on the plain
    paths, and name-set gates in member and call lookup. UVM stress bench:
    11.5 M -> 10.1 M host instructions per item (-12%); axi4 AVIP -6.2%.
  • c906 CoreMark -0.4% (elaboration -2.4 G): loop-feedback analysis only
    walks reads when a write reaches a combinational block, waiter wake
    ranks are tracked only once a nonzero rank fires, and the legality
    checker hashes scopes faster and builds messages lazily.
  • UVM class code: name-kind checks answer from per-design name tables and
    per-class memos, bare names read and write on direct paths, class task
    bodies are shared instead of cloned per call, and foreach over
    associative arrays uses the element index. UVM stress bench: 20.6 M ->
    11.5 M host instructions per sequence item (-44%); the six AVIPs run
    19-27% fewer instructions; c906 CoreMark unchanged.
  • A two-state block that reads an x or z bit no longer re-runs on the
    four-state VM: the same lowered stream runs on an x-plane executor that
    applies the VM's four-state rules (Kleene logic, &&/||/! through
    definite-1/definite-0/unknown, ambiguous equality, all-x arithmetic,
    plane shifts, an x selector merging its arms, if (x) taking the else
    arm, an x index reading all-x and writing nothing). On the SoC
    benchmarks three quarters of what the VM still executed were such
    re-runs — tiny muxes whose unselected arm or an unwritten register file
    holds x. XEZIM_TS_X=0 restores the VM re-run; x_plane_runs= counts
    them in the profile report.
  • Dynamically indexed reads of memory elements wider than 64 bits — a
    vector register file, a cache-line array — now run on the two-state
    executor, both as operands (vrf[rs] in wide logic) and as the fused
    memory-read flop (rdata <= line[raddr]). They were the largest labelled
    reason for a clocked or combinational block to stay on the four-state VM
    on both SoC benchmarks (21% of a C910 SoC's interpreted combinational
    evaluations, 31% of a C906's).
  • scripts/build-pgo.sh run without a training command builds a
    profile-guided binary from a bundled trainer (the tests/perf shapes,
    scripts/pgo-train, xezim-bench): about −0.5% host instructions on the
    SoC benchmarks, −12% on a loop-heavy DRAM model, output identical. It is
    the recommended release build; see README.
  • Loop-heavy clocked blocks with int counters — memory models that walk
    lanes, byte-lane writes into a packed memory, per-lane write pointers —
    now run on the two-state executor instead of the four-state VM. The
    counter's signed tag, its increment, a slice read at a run-time offset and
    range stores at a run-time offset (blocking and non-blocking, into
    vectors wider than 64 bits) all lower now. A DRAM-model reproducer runs
    in a third of the instructions.
  • Clocked blocks whose range-store bounds only become constants after
    folding — a generate arm writing v[g*8 +: 8] or mem[g][7:4] — now
    compile to constant range stores on the element, which the two-state
    executor runs; the dynamic and array forms they used to take kept the
    whole block on the four-state VM (16 such flops on a c906 SoC, 400 on a
    C910 SoC).
  • A block that bails on an x read every time it runs (an unwritten memory
    element it keeps reading) no longer pays the two-state entry and guard on
    every evaluation before running interpreted: after eight bails in a row
    it sleeps, doubling the sleep while the bails continue, and wakes for one
    attempt so a value that clears after reset gets its fast path back. x-read
    bails on a c906 SoC fall by 72%.
  • Combinational blocks with registers wider than 128 bits — up to 512 —
    run on the two-state executor by default now (XEZIM_TS_WIDE512=0
    restores the old behaviour). Three shapes that kept such blocks on the
    four-state VM lower as well: a bus read and then rewritten in the same
    block (bus = {bus[..], ..}), a mux between two wide values, and a
    wide 'x reset default ({N{1'bx}}). c906 memcpy runs 1.2% fewer
    instructions from the wide class alone, a C910 SoC 2.5%.
  • tests/perf/loop_block_counters.rs guards this path with work-counter
    ceilings (two-state admission, bytecode length, backoff engagement).
  • The bytecode such blocks compile to is leaner first: a loop variable's
    reads are forwarded into their consumers instead of being copied into a
    temporary each time, & K, * K, - K and | K fold their constant
    operand like + K already did, a constant that only becomes one after
    folding is fused too, and i = i + 1 is two instructions rather than
    five. The same reproducer executes 34% fewer VM instructions before the
    two-state gain above.
  • A clocked block whose inputs did not change may now skip an idle edge even
    when another block writes a different part of the same register or a
    different element of the same array. Generated logic that gives
    status[0] its own always block beside one for status[6:1], or
    mem[0] beside mem[1], used to keep every such block firing every
    cycle; each owns its own bits, so all may rest. Blocks that write
    overlapping bits, and any block beside a writer whose element index is
    computed at run time, still fire on every edge. A C910 SoC runs 6.6% fewer
    instructions, a c906 SoC 1.2%.
  • Writes that combine two dynamic steps into a packed vector now compile
    instead of falling back to the interpreter: q[i][j], mem[a][(i*W) +: W],
    s.arr[i].field and their blocking forms, with either index dynamic. A
    fallback inside a loop over a register-held variable demotes the whole loop,
    so these statements cost microseconds each; a memory model built from them
    runs 41x faster here, and a c906 run is unchanged.
  • Selects whose declared dimension does not start at zero or runs ascending
    compile instead of falling back: v[hi:lo], v[b +: w], v[b -: w] and
    bit selects on such a vector, and on an element of a packed array. A lane
    vector selected in a loop runs 11x faster here. An element of an UNPACKED
    array keeps the interpreter path, where its label mapping already agrees
    with the writes.
  • XEZIM_FALLBACK_SITES=1 reports every construct handed to the interpreter
    with its reason, source byte span and scope, so the statements worth
    compiling on a slow design can be found without guessing. It now also
    reports the expensive case, a statement that takes its whole loop to the
    interpreter because a fallback cannot be emitted inside one.
  • Merging same-sensitivity clocked blocks no longer costs the idle-edge
    skip. The blocks folded into a merged one keep their original statements,
    and the skip census still counted those writes, so every merged output
    looked like it had two drivers and the merged block was disqualified: on a
    c906 SoC only 618 of 3605 blocks could skip, and 55 million flop fires that
    used to be skipped ran. Merging is now worth 6.9% on that design instead of
    costing 18%.
  • Reading an element of a packed memory no longer copies the whole memory.
    mem[addr] on a logic [N-1:0][W-1:0] loaded every bit of mem into a
    register and selected the word from that, so each read cost as much as the
    memory is big: a 16x deeper memory cost 3x per read. The slice is taken
    where it lies now, read cost is flat in the memory's size, and a
    32-port read benchmark runs 42% faster.
  • Starting a design with large memories is faster again: deciding which
    clocked blocks may skip idle edges asked a hash map, once per element of
    every memory a block writes, whether anything else wrote it. A c906 SoC
    spent 1.8 seconds and several hundred megabytes on 19 million of those
    questions; one byte per signal answers them now, and whole arrays are
    counted as ranges. The pass went from 2.8 seconds to 30 milliseconds and a
    c906 run drops another 4%.
  • Designs with large memory arrays start simulating sooner: the pass that
    decides which clocked blocks may skip idle edges named every element of
    every memory a block writes, one string per element, and then read names it
    discarded. A c906 SoC spent 33 seconds there, a second per one-million-entry
    SRAM; that is now arithmetic on the element range, with the same skip
    decisions. The whole run drops 36% of its instructions.