Repository navigation
xezim-bin 0.11.0
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 = newconstructs the object;$typenameof class
handles,thisand class typedefs printsclass [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; parkedwait(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 jitbuild 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, namedu0.cg
inxezim_cov.json). Cross bodies supportbinsof,intersect,!,
&&,||,withand crossignore_bins/illegal_bins;bins x[N],
transition sets, lists and repetitions work;option.at_leastapplies 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_binshits are errors
(counted by--error-exit); unlabeled coverpoints are named after their
variable;cover sequencecounts every match; and assertion entries in
xezim_cov.jsoncarryfileandline. 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;newthrough 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-localdefparamtargets, and more;
non-ANSI port expressions (.b(a[2:1]),{a, b}) are supported, and a
ranged non-ANSI subroutine port redeclared as aregis 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 andlocal::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:
distweights
hold in coupled constraint sets (:=weighs every declared value,:/
the whole item),solve a before bpicksauniformly,randomize(a, b)makes exactly the named members random (even non-randones), and
aninside {[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. %mand the "Scope:" line of$info/$warning/$errorname the
declaring scope (pk.f,pk.C.show,tb.u.E.show); generate blocks,
namedalwaysblocks and labelled assertions are scopes. Auto-detected
tops run in source order. A class and an interface may share a name,
a blockingrandcasebranch 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 signedintread
back throughinoutprinted unsigned); arithmetic wider than 128 bits
keeps every bit; a forked package task runs as its own process;
s.h = newon 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 globalfactoryis 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, andbegin_keywords "1364-2001-noconfig". - UVM 1800.2 (2020.3) DPI:
uvm_re_comp/uvm_re_exec/uvm_re_compexec/
uvm_re_deglobbedfollow UVM's C code, anduvm_hdl_signal_sizeand
theuvm_polling_*value-change API are built in. UVM testbenches
compiled withoutUVM_NO_DPIused to abort at time 0 on unresolved
regex symbols. - An
inoutoroutputformal passes a virtual-interface handle back to
its caller even when the actual was null on entry (uvm_resource_db:: read_by_namereturned nothing), and a formal no longer leaks into a
same-named class property. - An unconnected 2-state
outputport 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$finishprints 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%pcorrectly, andthis.q[i].mreads and writes them.%s
of a string member reached through a select no longer pads,%pof a
string-valued call prints the string, and%0pprints it unquoted. - Unpacked-struct locals in
initialblocks 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), andinitial
blocks that cannot suspend run as one group. - Assertions: named properties and sequences declared in sub-modules and
interfaces work inassert 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_DPIis 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-libthat defines a symbol still takes precedence. - A second hierarchical write such as
u_sub.sig = vwent 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 = 5is unsigned). Astring
parameter prints with%slike 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
defparampath 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%):
`includeof a function-like
macro expands fully; paren-lessaa.sizecounts entries;item.index
works in locatorwithclauses;repeatrounds a real count;expect
blocks until its attempt finishes;= @ev rhswithout parentheses waits;
input port defaults use the instance's own parameters; subroutines in
labelled generate branches resolve;$bitsof 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) / 3gave 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 = 200read -56). - Reductions and sorts with a
withclause 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 forintand x forinteger/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,$widthand$nochange, with edge qualifiers,
&&&conditions, notifiers (toggled in the NBA region, once per time
step) and negative$setuphold/$recremlimits. 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
+nospecifydisable the checks (the flag used to be a no-op), and
+no_notifier/+no_tchk_msgare honoured. Aspecparamdeclared
inside a specify block is now a module-scoped constant instead of being
dropped. - SDF TIMINGCHECK entries (with edges,
CONDandINSTANCE *)
back-annotate check limits through--sdfand$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 = 1is 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
foreverloop
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#delayscheduled 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 elementb[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 arraysum()(includingwith (... item.index ...)),unique,
orderings between elements or arrays, and->/ifaround 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 == Kcompare at the full context width instead of wrapping
at the operand width. A random size variable tied toarr.size()is no
longer pinned to the previous size, anditem.indexreads the element
index inside reductionwithclauses.- 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'sstring name). UVM's
resource-name check read the wrong string, so itsUVM/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 howuvm_infoinside a BFM
task was attributed to the calling component instead of the global
reporter. - Covergroup coverage numbers match the LRM:
ignore_binsand
illegal_binsvalues 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()
andcg.cp.get_inst_coverage()report that coverpoint or cross (they
returned the group's number); type coverage averages the instances unless
type_option.merge_instancesis set;$get_coverageweights each type by
itstype_option.weight; arefconstructor 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
@clkon 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-endorfork-joinblock
or a subroutine body is rejected (§9.3.1);--no-strictstill 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 (intgives 31 ones,bytegives 7). mailboxandsemaphoreobjects are constructed by every form of
new: a parenthesis-lessmailbox mb = new;ormb = 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 to0000000X: 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
alwaysblock or anassign
reads the property instead of zero.bk.arr[i],bk.arr[3][0]and
bk.arr[i][3:0]asked the interpreter forbk.arralone, which is an
array and does not reduce to one number, and then selected from that
number; an accumulator fed bybk.arr[i]stayed at 0 while$displayof
the same expression printed the right element.
Usability
- Code coverage:
--code-coverage[=stmt,branch,toggle](all three by
default),--code-coverage-scope=<path>[,...]andXEZIM_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
-coveragenow enable it too. Results go inxezim_cov.jsonunder
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/$fdisplayto 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 -fon 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-timesets 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/-Gparameter overrides,-sv_seed,
-sv_lib/-sv_root,-svNNcompat, and a-dosubset (run -all,
run <time>,quit,exit,do <file>;log,add waveand
coverage save/reportare accepted with a warning; anything else is an
error). Library options (-work,-L,-lib) are ignored with one
warning;-cand-lkeep their xezim meanings.run -allruns past
the default time cap, and afterrun <time>the closing line and
finalblocks 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(orXEZIM_VERBOSE=1,
--profileor--sim-debug). The apb AVIP transcript went from 189 lines
to 150. - Parse, preprocessor and elaboration errors print
file:line:colwith the
source line and a caret. A line that came from anincluded 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 byincludes. - 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-linedefinereports 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 withoutformat!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>.pathreads (a testbench monitor ran on
the AST path with name lookups every clock),check_edgesreuses 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, andforeachover
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=0restores 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.shrun without a training command builds a
profile-guided binary from a bundled trainer (thetests/perfshapes,
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
intcounters — 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 writingv[g*8 +: 8]ormem[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'xreset 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.rsguards 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,- Kand| Kfold their constant
operand like+ Kalready did, a constant that only becomes one after
folding is fused too, andi = i + 1is 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 ownalwaysblock beside one forstatus[6:1], or
mem[0]besidemem[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].fieldand 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=1reports 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 alogic [N-1:0][W-1:0]loaded every bit ofmeminto 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.