perf(runtime): Idle state machines stop redoing work that can't change anything (#14508) 30c30acec9
* perf(runtime): skip transition searches on settled state machine layers

Every layer of every state machine searched all of its transitions at least
twice a frame, even when nothing its conditions read had changed. In an idle
400-row component list with view model conditions, that search was ~40% of
the frame.

A layer whose search finds nothing now settles: later searches return at once
until its state changes or something its conditions read does. Only states
whose transitions use view model conditions alone can settle (classified once
per state in StateMachine::onAddedClean). State machine inputs, random states,
and component, artboard, focus and scripted conditions keep the full search.
Settled layers wake on any dirtied state machine data bind, on data context
changes (new DataBindContainer::dataContextChanged), and on main view model
swaps; none settles while a dirtied bind is still unapplied. Editor builds
never settle, since transitions change there after import.

Memory: StateMachineLayerInstance stays 80 B (its flags are now bit-fields)
and StateMachineInstance 288 B (two bools in existing padding). LayerState
grows 104 -> 112 B per state definition.

Under TESTING every skipped search is re-run and aborts if it would have
transitioned: the full suite checks 1.7M skips with no mismatch.
ArtboardFrame benches: a 400-tile list scene -33% idle (-22% with the
RiveRenderer), bidirectional_binding_idle -85%, the rest neutral.

* perf(runtime): freeze settled layers in states that key nothing

A settled layer still advanced and applied its current state every frame.
For entry, exit and any states, and for animation states whose animation
keys nothing (including the empty animation that stands in for a missing
one), that work only moves a clock and applies no values. In an idle
400-row component list it was ~30% of the frame.

Such a layer is now frozen: once settled, fully mixed and no longer keeping
itself going, its advance returns what it would have without advancing,
mixing, applying or searching. The one reader of that clock is exit time,
so a state with any enabled exit-time transition never freezes
(LayerState::transitionsIgnoreTime, classified in onAddedClean). Whether a
state keys anything is checked on the live instance instead: an artboard's
last layer only resolves its animations once the next layer is read, which
can be after the artboard initializes.

No size change: the new LayerState flag sits in existing padding.
Idle-frame benches vs settled layers alone: a 400-tile list scene -31%
steady-state advance, -22% advance + draw (-47% vs master);
bidirectional_binding_idle -24%; the rest neutral.

* perf(runtime): add state machine bind clones once their target is set

StateMachineInstance added each cloned data bind before pointing it at its
per-instance bindable. addDataBind then saw no target, decided a toSource
bind couldn't push, and put it on the polling list, so every listener bind
in every state machine was re-read on each updateDataBinds pass. The state
machine never applies target to source in those passes (it always passes
false; listener actions push their value explicitly), so the polling did
nothing but keep updateDataBinds from returning early.

Adding the clone after its target is set puts such binds on the push path:
they are processed only when the listener's bindable actually changes.

* perf(runtime): skip the per-frame work of quiet list rows

Every row of an ArtboardComponentList advanced its state machine, searched
its transitions, updated its data binds, advanced its artboard and reset it
several times a frame, even when none of that did anything. With 400 settled,
frozen tile rows that bookkeeping was ~95% of the frame.

A row whose per-frame work would do nothing is now marked quiet and skipped by
every pass (advance, settle, updateDataBinds, reset, and the update pass)
until something wakes it. Quiet means: its state machine's layers are all
frozen with nothing pending (inputs, binds, reports, focus and semantic
queues, draw order), and its artboard has no dirt, bind work, layout or host
transform change, and only advancing components that report being idle
(AdvancingComponent::quietState). Rows with scripts, nested artboards,
joysticks, resettables, text inputs, scroll constraints or converters that
advance never go quiet, and neither do rows of lists with duplicate items.
Unrealized rows count as quiet: they have no work until realized.

Rows are woken through Artboard::wakeIfQuietRow, from the artboard's dirt,
data binds, data context, layout and host transform, and from its state
machine (markNeedsAdvance, focus and semantic queues, reports, unsettling,
reset) and every listener's performChanges, which keyboard and text
listeners otherwise use without marking anything. Rows are reset before
their instances change (updateList, setRowsForItem, addArtboardAt, clear).
The list keeps one bit per row, so passes step over quiet rows 64 at a time.

Item view models of number-bound lists are still advanced for every row:
skipping that needs a changed flag on view model instances.

Memory: Artboard gains a row index in existing padding (size unchanged);
each list gains two bit vectors.

Under TESTING every skipped row pass still runs after the pass and aborts
if the row stopped being quiet without waking or did any work; the suite
checks 22,847 of them. Idle-frame benches vs frozen layers: a 400-tile list
scene -92% steady-state advance (68 -> 5.6 us), -60% advance + draw;
component_list_virtualized_long -16%, its scroll -4%; the rest neutral.

* fix(runtime): don't wake a quiet row from a state machine's destructor

A state machine's destructor unbinds its data context, which unsettles its
layers and so woke its artboard's quiet list row, reading the artboard. When
an ArtboardComponentList cleared its pools it destroyed the pooled artboards
before the pooled state machines, so that read hit freed memory (caught by
ASan in "Artboard lists with child artboard origin offset"). A host can also
destroy an artboard before its state machine.

The state machine now stops waking its row once its destructor starts, and
the list destroys pooled state machines before pooled artboards, as it
already does for its realized rows. m_bindsPending, m_anySettled and the new
m_destroying are bit-fields sharing the byte after m_needsAdvance, so
StateMachineInstance stays 288 B.

Co-authored-by: hernan <hernan@rive.app>