Shipped against the alternatives
The price of a call says what a call costs against the plain JavaScript you would write instead. This page asks a different question: for each design the engine ships, how does it compare with another design for the same work? Most alternatives are designs that were rejected; some are a second shipped strategy for the same job. Each pair runs both sides on the same work.
Every figure here is generated from the published measurements
(npm run price:publish in packages/bench). No figure is typed by hand.
How to read a pair
- Shipped is the design in the engine. Alternative is the other design. The ratio is shipped over alternative, so it reads the other way up from a price: below 1.00 the shipped design is cheaper, above 1.00 the alternative is.
- A ratio close to 1.00 decides nothing. The alternative is timed twice in the pair's process, before and after the shipped side, and each card prints how far apart those two timings came out. The shipped side is timed a second time in its own process, and that gap is not published yet, so the printed gap covers only part of the ratio's error. The controls below show what the run as a whole could resolve.
- An alternative that comes out cheaper is a finding. For that task it is either a strategy the engine is missing or a trade-off the caveat names; see Performance.
- The caveat under each pair says what the two sides do differently, so a pair is never read as more than it measured.
The instrument
two units of arithmetic per iterationone unit of arithmetic per iterationWhat the two sides do differently
NOT A PRICE — an instrument check, and it is printed first because nothing below it means anything until it passes. The true ratio is a little UNDER 2: both sides pay the driving loop once, so the exact expectation is (2u + L) / (u + L) with L the loop and u one unit, which at sixteen dependent steps per unit puts it around 1.9. A reading below 1.5 means this process could not resolve a deliberate doubling, and the runner voids the report rather than printing prices under it.
one unit of arithmetic per iterationthe same body again, over its own copy of the same stateWhat the two sides do differently
NOT A PRICE — the noise floor. The two sides are identical code over identical, separately-allocated state, so the true ratio is 1.00 exactly and every departure from it printed here was produced by this machine at this moment. The rule that follows is the one the whole table is read under: NO RATIO CLOSER TO 1.00 THAN THIS GAP IS A READING. It also bounds the per-row noise figure, which is the same idea measured again inside every pair — each pair times its floor twice, once before our side and once after, and prints how far the two disagreed.
Published 2026-10-23T11:06:57.973Z.
Per relationship
effectService.createEffect(rootSlots, [], body) — a new TOIMEffect over 8 rootscreateLiteralEffect(channelSlot, rootSlots, body) — a literal over 8 roots, subscribed by a shared functionWhat the two sides do differently
THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. One operation is one effect created and subscribed to 8 roots; the disposal of the pass is in `reset`, untimed.
effectService.disposeEffect(effect) — a TOIMEffect over 8 rootsdisposeLiteralEffect(effect) — a literal over 8 rootsWhat the two sides do differently
THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. One operation is one effect unsubscribed from 8 roots; the pass's effects are created in `reset`, untimed, and one frame closes the pass.
map.get(key) — the identity already exists, the row is on itidentities.get(key) ?? mint and file one — the first subscription to that keyWhat the two sides do differently
A SUBSCRIPTION TURNING A KEY INTO AN IDENTITY, the first time each key is asked. Ours minted every identity at the load, so a resolve is one hash; the two-map store mints on demand, so the first resolve of a key is a miss, a mint and a second `Map.set`. The floor's identity map is emptied between passes, untimed, so every pass is that first resolve; a key resolved twice would cost the floor one hash, as ours. The mint ours paid at the load is priced by the write row, not here.
upsertEntity of a key that has none — the shipped fifteen-field entity slot literalREJECTED: a slot minted with its ten valued fields, the rest added on first useWhat the two sides do differently
THE FIRST OF THE TWO READINGS THIS DECISION ASKS FOR, AND IT IS THE ONE THAT SHOULD GO AGAINST US. `createOIMEntitySlot` returns fifteen fields, five of them born`undefined` — `effects`, `entity`, `columnSlotStore`, `data`, `indexKeys` — and the rejected design (a subclass overriding `createSlot`) leaves all five out and lets the engine add each on first assignment. So ours pays five stores per identity the floor does not, and if this row does not come back ABOVE 1.00 the two designs do not differ where the argument says they do. ONE OPERATION IS ONE `upsertEntity` OF A KEY THAT HAS NO VALUE — the whole first-load path: `writeContentByKey` minting the identity, the copying writer strategy, the store, the marks. The pass CONSUMES its fixture, so both sides declare `operationsPerPass` and rebuild an empty population in the untimed `reset`. ONE DIFFERENCE THAT IS NOT THE LITERAL, in the FLOOR'S disfavour: on the floor `slot.entity =` ADDS a property rather than storing into one, a map transition per row — which is what "added on first use" means. WHAT THIS ROW CANNOT SAY is what the unused fields COST in bytes; that is `npm run retained`, and this pair does not stand in for it. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
effectService.createEffect([slot], [], body) then effectService.disposeEffect(effect) — per subscriberemitter.subscribeOnKey(key, body) then the returned unsubscribe — 3.12.1What the two sides do differently
ONE OPERATION IS ONE SUBSCRIBER MOUNTED AND RELEASED, in batches of the churn family's largest count on one identity. Ours allocates a `TOIMEffect` per mount, appends it to the slot's `effects` array, holds the slot, and on dispose swap-removes it and unholds; 3.12.1 adds the handler to the carrier's `Set` and the carrier to the emitter's subscribed set, and its unsubscribe closure deletes both. Every body is a distinct closure, because the 3.12.1 `Set` collapses one function subscribed many times into one handler. Neither arm writes or flushes.
alt.subscription.channel-effect-vs-3.12.1-carrier-handler.mount-and-releasePublished 2026-10-23T11:06:57.973Z.
Per frame
mark the node at the write, recompute each marked node once when the frame closesrecompute the node at every writeWhat the two sides do differently
ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.
mark the node at the write, recompute each marked node once when the frame closesrecompute the node at every writeWhat the two sides do differently
ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.
mark the node at the write, recompute each marked node once when the frame closesrecompute the node at every writeWhat the two sides do differently
ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.
mark the node at the write, recompute each marked node once when the frame closesrecompute the node at every writeWhat the two sides do differently
ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.
a delivery list built at the write — the frame walks only what was markeda stamp written at the write — the frame scans every subscriber for this frame's stampWhat the two sides do differently
ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.
a delivery list built at the write — the frame walks only what was markeda stamp written at the write — the frame scans every subscriber for this frame's stampWhat the two sides do differently
ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.
a delivery list built at the write — the frame walks only what was markeda stamp written at the write — the frame scans every subscriber for this frame's stampWhat the two sides do differently
ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.
a delivery list built at the write — the frame walks only what was markeda stamp written at the write — the frame scans every subscriber for this frame's stampWhat the two sides do differently
ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.
push 1024 effects, then flush by swapping two listspush 1024 effects, then flush by draining an `Array.from` copyWhat the two sides do differently
ONE POINT OF A TWO-POINT LINE, READ WITH ITS SIBLING. The snapshot is proportional to the queue and the swap is constant, so the empty row is where the rejected design pays its minimum and the loaded row is where the saving is largest in absolute terms. The pushes are the same code on both arms and inside both numbers. NEITHER ARM IS SHIPPED CODE: `OIMChannel` keeps one pending list and empties it in place. The build throws unless one flush walks the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.
push 0 effects, then flush by swapping two listspush 0 effects, then flush by draining an `Array.from` copyWhat the two sides do differently
ONE POINT OF A TWO-POINT LINE, READ WITH ITS SIBLING. The snapshot is proportional to the queue and the swap is constant, so the empty row is where the rejected design pays its minimum and the loaded row is where the saving is largest in absolute terms. The pushes are the same code on both arms and inside both numbers. NEITHER ARM IS SHIPPED CODE: `OIMChannel` keeps one pending list and empties it in place. The build throws unless one flush walks the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.
OIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — wakes the TOIMEffects standing on that slotOIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — wakes the literal effects standing on that slotWhat the two sides do differently
THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. 1024 effects stand over 57 overlapping 8-row windows of 64 rows; one operation is one write and one frame, which runs every effect whose window holds the row (up to 8).
write 300 roots, then read 200 computeds that walk their 3 sources — chain depth 1the same writes, each marking its dependents dirty; each read is one boolean — depth 1What the two sides do differently
THE ROW THE RECOVERED RUN ACTUALLY COVERED, REBUILT SO THE OTHER TWO HAVE SOMETHING TO BE READ AGAINST. Its figure at this geometry was 0.72x in our favour [NO RUN BEHIND THIS FIGURE], and the whole reason the other two rows exist is that this one was the ONLY depth measured. At depth 1 push is at its strongest: a consumer is one boolean away from knowing it owes a derivation, and the sources under it are roots, which are current by definition — so the arm has nothing to descend and nothing to bring up to date. If the recovered figure is going to reproduce anywhere it is here, and a reading far from it on this row means the two runs are not measuring the same thing and the other two rows should not be quoted either [FIGURE STATED IN ADVANCE]. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.
the same frame over a computed reading a computed — chain depth 2the same frame, marked at the write and descended by the flag — chain depth 2What the two sides do differently
THE FIRST DEPTH THE RECOVERED RUN NEVER REACHED, AND THE ONE WHERE PUSH STARTS PAYING TWICE. A write now marks 200 nodes at level one and 200 more above them, and the walk is recursive; our arm's write is unchanged — it stamps a root and stops — while its READ grows by one level. So the two curves cross somewhere if they cross at all, and this row and the next are what say whether they do. WHAT DOES NOT CHANGE BETWEEN THE ROWS: the population, the fan-in, the number of consumers, the writes per frame and the derive body. Only the number of levels between the roots and the consumers moves, so this row minus the depth-1 row is one level, on both arms, in one process. IF THE RATIO RISES TOWARD 1.00 AS DEPTH GROWS THE VERDICT IS NARROWER THAN THE RECOVERED TABLE CLAIMED [FIGURE STATED IN ADVANCE], and if it crosses 1.00 the decision is wrong for deep chains and that is the finding this file was built to be able to report. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.
the same frame over a computed reading a computed reading a computed — chain depth 3the same frame, marked at the write through three levels — chain depth 3What the two sides do differently
THE DEPTH THE RECOVERY ENTRY NAMES BY HAND — "a computed over a computed over a computed was not measured" — and the far end of the only axis that could reverse the decision. 600 nodes now stand between 300 roots and 200 consumers. THE ARITHMETIC THE ROW IS CHECKING: push pays its marking over the whole cone at every frame's first write and then reads one boolean per node; we pay nothing at the write and one comparison per source at the read. Those are the same order of magnitude, so which wins is a question about constants and not about shapes, which is exactly the kind of question a measurement settles and an operation count does not. THIS IS THE ROW TO DISTRUST IF ANY: three levels of 200 nodes is deeper than most screens go, and a reader taking a verdict from here alone has chosen the extreme of the axis. Read the three rows as a table. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.
OIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — every effect on the slot runsemitter.markUpdatedKey(key); queue.flush() — every handler on the carrier runs — 3.12.1What the two sides do differently
ONE OPERATION IS ONE SUBSCRIBER WOKEN; a frame wakes the whole standing set, mounted before the clock. Ours stamps the slot, enlists each effect through its pending flag, and at the flush asks each effect whether its source moved since it last ran — a stamp compare — before calling its body. 3.12.1 marks the carrier dirty once, and its flush iterates the carrier's handler `Set` and calls each. Both arms were checked to wake every subscriber exactly once per write before the clock started. Neither arm goes through a collection write: this is the subscription cost alone, not the write stack in front of it.
Published 2026-10-23T11:06:57.973Z.
Per write
updateEntity(slot, patch) on the shipped walk — sixteen columns, all of them movingREJECTED: the same write with Object.keys(source) — sixteen columns, all movingWhat the two sides do differently
THE COUNTERWEIGHT TO THE ROW ABOVE, AND IT IS OWED. An unchanged re-send is the one write on which the shipped walk allocates nothing whatever, so measuring the rejected design only there would report its worst case as its case. Here every write moves all sixteen columns: BOTH arms allocate a changed-names array and push sixteen names into it, both assign sixteen columns, and both mark the row and its columns. The floor's names array is then one allocation among several rather than its only one, and if the shipped walk's advantage is really the allocation, this ratio is markedly closer to 1.00 than the unchanged row's. ONE OPERATION IS ONE `updateEntity` CARRYING SIXTEEN COLUMNS. The values advance by one of eight per pass and column `c` takes `titles[(round + c) & 7]`, so no write is ever handed a value the row already holds. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
updateEntity(slot, patch) on the shipped walk — for…in, own-property-ness proved onceREJECTED: the same write with Object.keys(source) and a walk of that arrayWhat the two sides do differently
THE SCENARIO THE SOURCE'S OLD FIGURE NAMED, GIVEN A DIRECTORY. The in-place writer's source once put the array-allocating form at 1.099 ms against 479 µs on "ten thousand rows rewritten with the values they already hold" [NO RUN BEHIND THIS FIGURE]. This row is that scenario: ONE OPERATION IS ONE `updateEntity` OF A ROW WITH A PATCH IT ALREADY MATCHES IN ALL SIXTEEN COLUMNS. The population is primed outside the clock so every row holds round zero's values, and the timed patch is round zero's — so every write enumerates sixteen columns, compares sixteen times, moves nothing, and returns having marked nothing. OPERATION COUNT, both arms: 16 `oimIsProtoKey` compares, 16 `oimSameValueZeroGuard` calls, 16 pairs of property loads, and no changed-names array. Ours additionally pays ONE `oimIsPlain` — one `getPrototypeOf` and two reference compares, per write. The floor pays ONE `Object.keys` — a sixteen-element array allocated, filled and abandoned per write. THE DIFFERENCE IS ONE PROTOTYPE PROBE AGAINST ONE SIXTEEN-ELEMENT ARRAY, plus whatever the two enumerations cost each other. THIS IS THE MOST FAVOURABLE SCENARIO THE SHIPPED WALK HAS, and that is why the row beside it exists. Read the two rows together or neither. A FLUSH CLOSES EACH PASS ON BOTH ARMS and is an empty one — nothing was marked. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
updateEntity(slot, patch) — one oimIsPlain per write, and a bare for…in after itREJECTED: hasOwnProperty.call per column, with no oimIsPlain probe at allWhat the two sides do differently
THE SECOND DESIGN THE SAME DECISION REFUSED. The writer's old source put the per-column probe at "a quarter of" an unchanged re-send — a share of a scenario, not a ratio, and no directory. This row is that scenario at sixteen columns. ONE OPERATION IS ONE UNCHANGED `updateEntity`, primed exactly as the first row of this file. OPERATION COUNT, ours: 1 `getPrototypeOf` and 2 reference compares, then 16 `oimIsProtoKey` compares and 16 equality calls. Floor: 16 `oimIsProtoKey` compares, 16 `Object.prototype.hasOwnProperty.call` invocations and 16 equality calls. THE DIFFERENCE IS ONE PROTOTYPE PROBE AGAINST SIXTEEN BUILTIN CALLS, per write. WHAT THE FLOOR BUYS IS NOT VISIBLE IN THIS NUMBER: unconditional correctness with no probe of the patch and no second rule for the non-plain payload. THE PATCH HERE IS A PLAIN OBJECT, the case the shipped design optimises for; on a class-instance patch ours takes the filtered walk and pays what the floor pays plus the probe. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.column-walk.probe-once-vs-hasownproperty-per-column.unchanged-resenda frame of 16 writes; all 256 derivations read 4 times each — deduped at the getterthe same frame — deduped in the channel, by a dependent walk and a frame stampWhat the two sides do differently
THE OTHER END, AND THE ONE THAT SHOULD GO AGAINST US: everything derived is wanted, and wanted repeatedly. Ours walks the four sources on the FIRST read of each of the 256 derivations — 1024 comparisons a frame — and answers the other three reads of each from the slot's `checkedAt` pair against the channel clock, through `getValueForSlot` and its `assertNotReleased` every time; the channel arm asks nothing on a read and recomputes only what the writes touched. BELOW 1.0x HERE IS EXPECTED [FIGURE STATED IN ADVANCE]; a row that came out above 1.0x at BOTH ends would mean one arm is not written in its best form and the pair must not be quoted. Read with the row above and never alone: the pair IS the answer, and either row by itself reads as a verdict on "dedup" that neither one supports.
a frame of 16 writes; 16 of 256 derivations read once each — deduped at the getterthe same frame — deduped in the channel, by a dependent walk and a frame stampWhat the two sides do differently
THE SHAPE AN APPLICATION USUALLY HAS, and the one the shipped arm is built for: far more derivations exist than any one frame reads. Ours settles 16 derivations and touches nothing else; the channel arm walks every dependent of all 16 written roots and recomputes each queued derivation whether or not it is read. ABOVE 1.0x HERE WOULD BE THE FINDING [FIGURE STATED IN ADVANCE], because it would mean the per-read source comparison costs more than recomputing derivations nobody wants. Both arms write through the same entity service and `OIMDB`, so the write path is common and cancels; what differs is only where the "already done this frame" question is asked. What no ratio here prices: the getter arm is what makes a derivation nobody reads cost nothing at all, which is a property of the whole engine and not of this frame.
if (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an arraypendingSet.add(carrier) — drained by iterating the Set and clearing itWhat the two sides do differently
ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.
if (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an arraypendingSet.add(carrier) — drained by iterating the Set and clearing itWhat the two sides do differently
ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.
if (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an arraypendingSet.add(carrier) — drained by iterating the Set and clearing itWhat the two sides do differently
ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.
if (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an arraypendingSet.add(carrier) — drained by iterating the Set and clearing itWhat the two sides do differently
ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.
a population built with one comparator for the whole row — asked on all sixteenREJECTED: a map from column name to predicate, plain === for the other fifteenWhat the two sides do differently
WHAT A CALLER REACHING FOR THE PARAMETER ALMOST ALWAYS ACTUALLY WANTS: the one column holding a value that needs more than `===` gets the comparison it needs without every other column of every row paying for it. Sixteen columns, one of which needs an equality that is not `===`, written both ways. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF SIXTEEN COLUMNS. Ours: 16 calls to the row comparator, of which 15 return on its `a === b` first line and one runs the expensive body. Floor: 16 `Map.prototype.get` probes, 15 inline `===` comparisons, and one call into the same expensive body. THE DIFFERENCE IS FIFTEEN CALLS AGAINST SIXTEEN MAP PROBES; the expensive comparison is charged once to both arms and cancels. THE EXPENSIVE COMPARATOR IS A CASE-INSENSITIVE STRING COMPARE AND NOT A DEEP EQUAL, on purpose: a deeper comparator would raise both nanosecond columns by the same amount and pull the ratio toward 1.00, so this row is the map design's best case. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.equality-predicate.row-comparator-vs-column-comparators.one-column-of-sixteenupdateEntity(slot, patch) — the shared default predicate, asked once per columnREJECTED: SameValueZero written into the walk, with no parameterWhat the two sides do differently
THE NEGATIVE READING A CALL-SITE DECISION IS OWED. The equality predicate is a parameter (`sameValueGuard`) so a caller can say what a change MEANS for their rows, and the argument for putting it on the hottest walk in the engine was that a shared default keeps the site monomorphic and therefore free. That is a ratio, and this row takes it. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock. Ours: 16 calls to `oimSameValueZeroGuard` through the shipped default writer's captured parameter. Floor: the same comparison — `a === b || (a !== a && b !== b)` — 16 times inline. Both: 16 `oimIsProtoKey` calls, one `oimIsPlain`, no allocation, and the early return. THE UNCHANGED WRITE IS WHERE THE PREDICATE IS THE WHOLE COLUMN; read this as the predicate's largest share of a write and not as its typical one. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.equality-predicate.shared-default-vs-inlined.unchanged-resendthe same write, in a process where one other population has its own comparatorREJECTED: SameValueZero written into the walk — nothing can spoil itWhat the two sides do differently
THE HALF OF THE ALTERNATIVE THE ROW ABOVE CANNOT SEE. `createOIMEntityWriterInPlace` returns a closure over ONE compiled `patchEntityInPlace` and ONE `changedColumns`, so the `sameValueGuard(entity[name], source[name])` inside it is one call site for the whole process — and one population built with its own comparator makes it polymorphic for every population that did not. A design with no parameter cannot be spoiled that way. HOW THE SPOILER IS APPLIED, outside the clock: a second population of 64 rows is built with `createOIMEntityWriterInPlace({ sameValueGuard: caseInsensitiveEquality })` and written to in this side's `reset`, which is never timed. The timed body touches only the measured population, so the WORK on the two arms is identical and the difference from the row above is the state of one inline cache. THE FLOOR IS THE SAME FLOOR AS THE ROW ABOVE, deliberately. A CAVEAT AGAINST THIS ROW: nothing here forces V8 to keep the site polymorphic; if the two rows come back identical within the noise floor, that is the first thing to suspect and the second is that polymorphism at this site is genuinely free. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.equality-predicate.shared-default-vs-inlined.with-a-second-comparator-presentupdateEntity(slot, patch) — one shared predicate called from the walkREJECTED: name !== "__proto__" written into the walk, with no call at allWhat the two sides do differently
THE ROW WHOSE EXPECTED ANSWER IS 1.00, STATED IN ADVANCE SO A RUN CAN REFUTE IT. `oimIsProtoKey` is module-level, monomorphic, one expression, no closure — the shape an optimiser removes — which is a claim that this ratio comes back inside the noise floor. If it does, centralising the rule is free; if it does not, the centralisation was bought with something. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF SIXTEEN COLUMNS, so the difference is sixteen call frames per write against none. THE FLOOR IS NOT A DESIGN ANYBODY SHOULD SHIP: it is the duplicated comparison the rule was centralised out of, here as a measurement instrument — the isolated cost of a call level. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
updateEntity(slot, patch) — oimIsProtoKey(name), whose whole body is one comparisonREJECTED: a Set of forbidden names, asked once per enumerated columnWhat the two sides do differently
WHAT THE RULE WOULD COST IF IT COULD GROW. The forbidden-name rule is one comparison against `OIM_PROTO_KEY`; a membership test against a collection is the shape it would take the day a second name joins it, and nothing has ever measured that. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock, so the predicate is asked sixteen times and the equality gate then ends every column — the arrangement that gives the predicate the largest share of a write it will ever have. OPERATION COUNT, ours: 16 monomorphic calls each doing one string compare. Floor: 16 `Set.prototype.has` calls, each probing a table of ONE entry. THE SET IS AT ITS BEST HERE AND THE READING IS THEREFORE THE REJECTED DESIGN'S FLOOR, NOT ITS TYPICAL COST. THE STRINGS ARE INTERNED ON BOTH ARMS, so the floor never pays a fresh hash and only pays a probe — in the floor's favour. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
handStore.delete(slot.key) on a Map of slotsmap.delete(row.id) on a Map of row copiesWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: reaching the key through the slot instead of the row; the key strings are the same objects.
slotStoreService.remove(store, slot.key)handStore.delete(slot.key)What the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the call through the shipped Map-driven slot store service.
writer.clearEntity(slot), isEmpty = true, slotStoreService.remove, isReleased = trueslotStoreService.remove(store, slot.key)What the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: clearing the value through the shipped in-place writer and marking the slot empty and released.
OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot), then the clear and unfilethe clear and unfileWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the channel write that stamps the slot.
assertNotFlushing and the released check, then the channel, clear and unfilethe channel, clear and unfileWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the two checks assertWritable runs.
the same inside one channel subframethe asserts, channel, clear and unfileWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: one channel openSubframe / closeSubframe around the step.
the same inside two nested channel subframesthe same inside one subframeWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: a second, nested subframe. The shipped deleteEntity opens none on its fast path; on its slow path deleteEntityInSubframe opens one and releaseSlotContent nests a second inside it when the slot holds an entity.
entityService.deleteEntity(slot)the same steps written by hand, in two nested subframesWhat the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the shipped door in place of the hand steps. On this fixture deleteEntity takes its fast path — assertWritable, the isOnFastPath read, writer.clearEntity, the channel write, markEmptiness and slot.owner.releaseSlotIfUnheld — and opens no subframe, runs no settleEmptiness and no dispatchContentChange, so the floor carries two subframes the door does not open.
assertWritable by hand, channel write, writer.clearEntity, isEmpty = true, slot.owner.releaseSlotIfUnheld (one slot.owner read per slot) — no subframeentityService.deleteEntity(slot)What the two sides do differently
One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: nothing over rung 8 in shape: the shipped deleteEntity is itself flat on this fixture, so this rung differs from it by about the isOnFastPath read, markEmptiness with a slotEmptiness.isEmpty call against a bare isEmpty = true, and the hand-inlined asserts against the assertWritable call; both keep the shipped release check and unfile.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)map.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the whole column door by key over a bare Map store, in this ladder's own loop.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)map.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Both sides share one fixture, as the catalogue pair does.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)map.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. The catalogue pair's body, copied verbatim.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)map.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. The catalogue shape with the round body moved to a module-level function.
map.get(id), skip when equal, store, queue once per framemap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the comparison with the old value and the once-per-frame queue a bare Map store does not do.
entityService.getSlotByKey(entityStoreSlot, id).entity, then the same compare, store and queuemap.get(id), skip when equal, store, queue once per frameWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: finding the entity through the collection instead of a Map of entities.
the same with oimSameValueZeroGuard instead of ===getSlotByKey, ===, store, queueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the SameValueZero comparison the shipped writer uses.
getSlotByKey, then the shipped writer's patchColumn, then the hand queuegetSlotByKey, SameValueZero, store, queue — written inlineWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the call through the shipped writer object: the __proto__ check and the store it does.
getSlotByKey, patchColumn, OIMChannelService.INSTANCE.writeWithoutFlushCheck; db.flush() per roundgetSlotByKey, patchColumn, hand stamp and queueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped channel instead of a hand stamp and queue.
the flush and released asserts, the column-slot check, patchColumn, the channel, releaseSlotIfUnheldgetSlotByKey, patchColumn, the channelWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the checks the door runs around the write, written by hand. The releaseSlotIfUnheld here is a full check the shipped updateEntityColumn does not run by default: it calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)the same steps written by handWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped door: entityService.slotContentService.updateEntityColumn → assertWritable, the isOnFastPath read, patchColumn, the channel and releaseWrittenSlotIfUnheld — not the full releaseSlotIfUnheld its floor runs.
entityService.slotContentService.updateEntity(entityService.getSlotByKey(entityStoreSlot, id), { title }) — the patch doorentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)What the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the patch object and the walk over it, instead of naming the column.
the catalogue shape, plus an Int32Array frame allocated beside the fixturemap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the frame array differs from 0d.
the catalogue shape, the round called with the ladder's argument ordermap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the argument order differs from 0d.
the catalogue shape, both sides built by one round factorymap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the shared round factory differs from 0d.
entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)map.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped column door today, in the same loop, for comparison.
getSlotByKey, flush guard, patchColumn (compares), channel only when the slot has effects — no clock tick, no stampmap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what a channel with no computeds would leave: the comparison stays, the revision stamp goes.
getSlotByKey, flush guard, and a plain store when the slot has no effectsmap.get(id).title = valueWhat the two sides do differently
One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what a collection with no computeds could do on an unwatched slot: no comparison, no stamp.
for…in over the patch, ===, queue once per frameentity.title = value after ===, queue once per frameWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: a patch object and a for…in over it instead of a named column.
the same walk with the `__proto__` check, hasOwnProperty and oimSameValueZeroGuardfor…in over the patch, ===, queue once per frameWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the two key guards and the SameValueZero comparison the shipped walk runs.
createOIMEntityWriterInPlace().patchEntity(slot, patch), queue once per framethe same walk written inlineWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the call through the shipped writer object instead of the walk inlined.
the shipped writer, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot); db.flush() per roundthe shipped writer, then a hand stamp and queue; drained per roundWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped channel instead of a hand-written stamp and queue.
OIMChannelService.INSTANCE.assertNotFlushing(channelSlot) and the released check, then the writer and the channelthe shipped writer, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot)What the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what assertWritable checks: no flush running, the identity not released.
the asserts, the column-store check, the writer and the channelthe asserts, the writer and the channelWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the three reads updateEntity makes before choosing its path: updatesEmptinessOnColumnWrite, whether the identity has column slots, and whether the collection has content-change listeners — here as fields of a hand-held object.
the asserts and checks, the writer, the channel, then slot.owner.releaseSlotIfUnheld(slot) (one slot.owner read per slot)the asserts and checks, the writer and the channelWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: a full releaseSlotIfUnheld after the write. The shipped updateEntity does not run it: its fast path calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots, so this rung prices a check the shipped door skips by default.
entityService.slotContentService.updateEntity(slot, patch); db.flush() per roundthe rung-5c steps written out by hand around the shipped writer and channelWhat the two sides do differently
One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped route instead of the hand helpers: entityService.slotContentService.updateEntity → assertWritable, the isOnFastPath read, the writer, the channel and releaseWrittenSlotIfUnheld — not the full releaseSlotIfUnheld its floor runs, so this pair prices the route minus that check.
publicService.writeBucketMember(slot, member), forwarding to the internal serviceinternalService.writeBucketMember(slot, member): one store and one channel callWhat the two sides do differently
A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a write: one array store and one channel call that stamps a revision.
entityService.updateEntity(slot, patch) with the shipped in-place writer — 1-field, guarded for…inthe same update with a writer whose patch walk is a for…in with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) on a 10-column entity, the patch moving every column — shipped in-place writer, guarded for…inthe same update with a writer whose patch walk is a for…in with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) on a 100-column entity, the patch moving every column — shipped in-place writer, guarded for…inthe same update with a writer whose patch walk is a for…in with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) with the shipped in-place writer — 3-field, guarded for…inthe same update with a writer whose patch walk is a for…in with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) on a 30-column entity, the patch moving every column — shipped in-place writer, guarded for…inthe same update with a writer whose patch walk is a for…in with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) with the shipped in-place writer — 1-field, guarded for…inthe same update with a writer whose patch walk is Object.keys with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
entityService.updateEntity(slot, patch) with the shipped in-place writer — 3-field, guarded for…inthe same update with a writer whose patch walk is Object.keys with no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.
slotContentService.insertBucketMemberSlotAt(bucket, 0, slot) into a list of 1024, membership kept in a Setthe same prepend, membership kept in a Map to positionsWhat the two sides do differently
THE OPERATION COUNT IS NOT IN DISPUTE. A prepend splices one member in at the front, which invalidates every position after it: the renumber is exactly `list.length - at` map writes, so 1025 of them here, against one memmove and one `Set.add` on our side. EACH OPERATION IS A PREPEND AND A REMOVAL OF THE TAIL, so the list stays the length it is named for; the removal renumbers nothing on either design. Ours is `OIMSlotContentBucketServiceArrayDriven` over `OIMBucketArrayMembershipUnique`; the floor is the same service subclassed to keep a positions map. DIRECTION: the bucket collection's own epilogue — the hold, the unhold, the `OIMChannelService.writeWithoutFlushCheck` and the emptiness update — is identical on both halves and inside both numbers, which pulls this toward 1.00. A LAZY positions map is a third design and this row does not refute it. The reading in `packages/bench/measurements/2026-08-20-alternatives/positions` was taken on a positional index and bucket mutator that are gone and is not re-attributed here.
entityService.upsertEntity(storeSlot, row) on a key that holds a value — the shipped in-place writer, guarded walksthe same upsert with a writer whose patch and departure walks run no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.
entityService.upsertEntity(storeSlot, entity) on a key holding a 10-column entity, every column moving — shipped in-place writer, guarded walksthe same upsert with a writer whose patch and departure walks run no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.
entityService.upsertEntity(storeSlot, entity) on a key holding a 100-column entity, every column moving — shipped in-place writer, guarded walksthe same upsert with a writer whose patch and departure walks run no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.
entityService.upsertEntity(storeSlot, entity) on a key holding a 30-column entity, every column moving — shipped in-place writer, guarded walksthe same upsert with a writer whose patch and departure walks run no guardWhat the two sides do differently
The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.
upsertEntity of a row missing one column — the replacement is built from the survivorsREJECTED: { ...entity }, then delete the departing column off the copyWhat the two sides do differently
The shipped side is the replacing `putEntity`: one pass over the stored row with a `hasOwnProperty` on the incoming value per column, and ONE new object built from the survivors. The rejected side keeps the two-step put the engine used to run — its spread-and-`delete` removal, then the shipped replacing `patchEntity`, which spreads a second copy — so it pays two objects where ours pays one. ONE OPERATION IS ONE `upsertEntity` OF A ROW THE POPULATION ALREADY HAS, and the passes ALTERNATE: a value without `c15`, then the whole value again — a column can only leave a row once. Both sides write the row to the channel once per upsert. THE SURROUNDING `upsertEntity` IS INSIDE BOTH NUMBERS — the marks and the content-change call — so the ratio is a LOWER BOUND on the difference between the two rebuilds. READINGS TAKEN BEFORE THE ENGINE HAD `putEntity` priced a different shipped side and do not describe this one. WHAT THIS ROW DOES NOT MEASURE is what the shipped side buys, which falls on every later READ of a row the `delete` took out of its shape. That is the row below. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.replacement-rebuild.survivors-vs-spread-and-delete.the-removalthe replacing writer: { ...entity }, then one store per column the walk recordedREJECTED: { ...entity, ...source } — the whole patch spread over the copyWhat the two sides do differently
THE ARMS OF THIS QUESTION SWAPPED SIDES. The shipped replacing writer used to spread the whole patch over the copy; `createOIMEntityWriterReplacing` now assigns only the names `changedColumns` recorded, so the spread is the rejected arm. ONE OPERATION IS ONE `updateEntity` CARRYING SIXTEEN COLUMNS OF WHICH EXACTLY ONE HAS MOVED — the shape a socket re-sending a whole row produces, and the shape that makes the two designs differ most. OPERATION COUNT. Both arms: the same `changedColumns` walk — 16 `oimIsProtoKey` calls, 16 equality calls, one names array with ONE push — the marks, and one record allocated. Ours then copies 17 values from the entity and does ONE store. The floor copies 17 from the entity and 16 from the patch — 33 stores, 15 of them writing a value the copy already held. THE DIFFERENCE IS SIXTEEN PROPERTY COPIES AGAINST ONE, per write. WHAT THE SPREAD WOULD BUY, and it is not a number: a caller's `sameValueGuard` may call two different objects equal, and the spread then stores the NEWER one while reporting nothing moved, where the shipped form keeps the older one. ONLY `c00` ADVANCES, by one of eight per pass; the other fifteen columns hold the values the population was primed with. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.replacing-build.assign-the-moved-vs-spread-the-patch.one-column-of-sixteenthe replacing writer: walk to decide, then one spread and one store per moved columnREJECTED: one spread of the entity up front, then assign each column as it is foundWhat the two sides do differently
WHAT THE SHIPPED ORDER COSTS WHEN THE WRITE REALLY CHANGES SOMETHING — a re-hydration, where every write changes something. ONE OPERATION IS ONE `updateEntity` MOVING ALL SIXTEEN COLUMNS. Both arms: 16 `oimIsProtoKey` calls, 16 equality calls, one changed-names array with 16 pushes, the marks, and exactly ONE record allocated with 17 values spread and 16 stored. The difference is that ours walks the patch to decide and then loops the 16 recorded names a second time to store them, where the floor stores as it walks. IF IT COMES BACK NEAR 1.00 the second loop is worth nothing and the rejected design loses on its own ground as well as on the unchanged-write contract. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.replacing-build.decide-first-vs-build-as-you-walk.every-column-movedthe replacing writer: walk, find nothing moved, allocate nothingREJECTED: copy the row up front, assign what moved, store the copy regardlessWhat the two sides do differently
THE WRITE THE SHIPPED ORDER EXISTS FOR. "Decide before you allocate" only differs from "build as you walk" on a write that moves NOTHING, and there it differs completely: ours returns false having allocated neither a row nor a names array, and the floor has already spread the row before it could know. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock. Both arms: 16 `oimIsProtoKey` calls, 16 equality calls, one `oimIsPlain`, no mark. The floor allocates one seventeen-property record, copies seventeen values into it and stores it on the slot — per write, abandoned. THE COPY IS STORED, so it escapes and V8 cannot elide it; storing it is also the faithful reading of the rejected design, which has no decision point at which to withhold the copy — and so hands readers a new reference on an unchanged write. THIS ROW MEASURES WHAT THAT COSTS AND NOT WHETHER IT IS ACCEPTABLE. Read with the `every-column-moved` row beside it. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.replacing-build.decide-first-vs-build-as-you-walk.unchanged-resenda hold on the four slot shapes the hold door sees (entity, bucket, push column, computed) in turnthe same hold on the four kinds minted with ONE shape: the 15-key header plus `content`What the two sides do differently
One operation is one holdCount increment, the body of OIMSlotOwner.holdSlot; an unhold is left out because an increment and a decrement of one field in one body can be folded away by the compiler. The hold door sees four shapes today (how-many-shapes-reach-the-write-door.test.ts), the pull column sharing the computed literal, which here carries computedValueService as createOIMComputedSlot does. Four shapes is the megamorphic edge.
the channel write door handed the four shipped slot shapes in turnthe same door reaching the common fields through one shared sub-object `slot.common`What the two sides do differently
As the one-shape pair, but the candidate keeps four kind shapes and moves the fields the door touches into one sub-object of one shape: one extra load per write buys a monomorphic one.
the channel write door handed the four shipped slot shapes (entity, bucket, column, computed) in turnthe same door handed four kinds minted with ONE shape: common fields plus one `content` fieldWhat the two sides do differently
One operation is one write; the pool cycles entity, bucket, column, computed. The door reads holdCount and effects and stamps two fields, as OIMChannel.writeWithoutFlushCheck does. Every slot is held, so the gate never returns early. Bodies are separate function literals so the two arms keep separate feedback.
the channel write door handed the three slot shapes that reach it today (entity, bucket, push column) in turnthe same door handed the same three kinds minted with ONE shape: the 15-key header plus one `content` fieldWhat the two sides do differently
One operation is one write; the pool cycles entity, bucket, push column, the only kinds whose slots reach OIMChannel.writeWithoutFlushCheck (how-many-shapes-reach-the-write-door.test.ts pins three). The literals copy the key order of createOIMEntitySlot, createOIMBucketSlot and OIMColumnOwnerPushDriven.createColumnSlot. Three shapes are still under the polymorphic ceiling of four, which is what this pair asks about. Every slot is held, so the gate never returns early.
updateEntity on a loaded population whose every slot has one shapeREJECTED: the same write where a slot’s shape depends on what has happened to itWhat the two sides do differently
WHERE THE SHIPPED LITERAL IS SUPPOSED TO EARN THE FIVE STORES THE ROW ABOVE CHARGES IT FOR. "Every slot of a population settles on a single hidden class" is only worth anything if something later reads those slots through a site that would otherwise go polymorphic — which is the write path: `OIMChannelService.writeWithoutFlushCheck` reads `effects`, `changedAtRevision` and `changedAtEpoch`, and the collection reads `entity` and `isReleased`, all through one compiled body per method. THE POPULATION IS DELIBERATELY HETEROGENEOUS THE WAY A SCREEN MAKES IT SO: one row in eight carries an effect (`effectService.createEffect([slot], [], body)`), which is what a mounted view of a list looks like. On ours that changes no shape — `effects` was there from birth. On the floor the subscribed slots gain a property the rest do not have, so the population holds two shapes and every one of those reads sees both. ONE OPERATION IS ONE `updateEntity` MOVING ONE COLUMN of a sixteen-column row, and the subscribed eighth really is woken — both arms subscribe the same rows to the same shared body, so the delivery is inside both numbers and cancels. THE FLOOR IS AT ITS BEST WITH TWO SHAPES; a column hold (`columnSlotStore`) or an index (`indexKeys`) adds another at the same sites, so this reading is a LOWER BOUND on what the shipped literal buys. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.
alt.slot-literal.complete-vs-grown.write-a-partly-subscribed-populationone write function handed three slot shapes — entity, bucket, columnthree write functions, one per slot kind, each handed only its own shapeWhat the two sides do differently
ONE OPERATION IS THREE WRITES, one slot of each kind, in the same order on both arms over the same pool of literals. The bodies are byte-identical and are SEPARATE FUNCTION LITERALS — closures minted from one literal share their feedback, so a factory would make the rejected arm polymorphic too and the row would price nothing. These three are the literals `how-many-shapes-reach-the-write-door.test.ts` pins at `OIMChannel.writeWithoutFlushCheck`, so our arm is as polymorphic as production. `isolate` keeps the two arms from sharing a heap history.
one write function handed the three shipped slot shapesone write function handed three slots minted with one unified shapeWhat the two sides do differently
THE HALF OF THE UNIFIED-SHAPE ARGUMENT THAT FAVOURS IT, and it must be read with `alt.slot-shape.three-shapes-against-one-at-the-mint`, which is the half that pays for it. One operation is three writes in the same order over the same pool size on both arms; the only difference is whether the site sees three hidden classes or one. The unified literal carries every field any kind needs, in one order, so it is one map. Above one is the shipped design losing at the write.
entityService.slotContentService.updateEntity(entityService.getSlotByKey(entityStoreSlot, id), patch)entityService.updateEntity(slotById.get(id), patch) — the same engine write, the slot found by a bare Map.getWhat the two sides do differently
Both sides run on the same population of priceDataset.batch entities and visit the same ids in the same order. The floor reaches the same slots through a hand-built Map<id, slot>; the engine reaches them through its store service. Ours finds the slot in the store with getSlotByKey and then runs updateEntity; the floor calls updateEntity on a slot it found itself. The lookup alone is priced by alt.lookup.get-slot-by-key-vs-map-get, so what this ratio adds over that one is the by-key door around the same write.
the one-channel method through the module writer, as a method on the probethe same steps as a plain function over the public members: assertNotFlushing, isReleased, columnSlotStore, the writer, the channelWhat the two sides do differently
Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: running the steps as a method on the probe, through the private pieces reached by the cast — assertWritable and isOnFastPath as calls — instead of inlining assertNotFlushing, isReleased and a columnSlotStore read over public members.
the one-channel method with releaseSlotIfUnheldthe same method without releaseSlotIfUnheldWhat the two sides do differently
Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: a full releaseSlotIfUnheld after a landed write, which the shipped updateEntity does not run by default: it calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots.
entityService.slotContentService.updateEntity(slot, patch) — the shipped doora probe method doing only the one-channel path: assert, column-reader check, writer, channel, releaseWhat the two sides do differently
Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: the shipped OIMSlotContentEntityService.updateEntity against one probe method, and releaseWrittenSlotIfUnheld — a no-op under the default AtEmpty policy — on the shipped side against the full releaseSlotIfUnheld the method runs; both sides read isOnFastPath.
the one-channel method with assertWritablethe same method without assertWritableWhat the two sides do differently
Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: assertWritable: the flush guard and the released check.
the one-channel method without release, writer read from the content service's entityWriterthe same method, the same writer object read from a module constantWhat the two sides do differently
Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: reading the writer off the probe field instead of a module constant.
Published 2026-10-23T11:06:57.973Z.
Per entity per write
64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.64-buckets-one-add-each8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.8-buckets-one-add-each1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
1 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.one-bucket-1-adds-with-a-listener64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.one-bucket-64-adds-with-a-listener8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.one-bucket-8-adds-with-a-listener64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.64-buckets-one-add-each8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.8-buckets-one-add-each1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
1 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-1-adds1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-1-adds-with-a-listener64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-64-adds64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-64-adds-with-a-listener8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-8-adds8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive armWhat the two sides do differently
8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-8-adds-with-a-listener64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
1 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive.one-bucket-1-adds-with-a-listener64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
64 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive.one-bucket-64-adds-with-a-listener8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
8 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release checkWhat the two sides do differently
8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.adaptive.one-bucket-8-adds-with-a-listener64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
1 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.channel-array.one-bucket-1-adds-with-a-listener64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
64 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.channel-array.one-bucket-64-adds-with-a-listener8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
8 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callbackWhat the two sides do differently
8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
alt.bucket-coalescing.channel-array.one-bucket-8-adds-with-a-listener1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
1 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
64 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
8 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callbackthe same adds, each one written to the channel, settled and announced at onceWhat the two sides do differently
8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.
mark a carrier: read its own effects list, compare its stamp, enlist, stamp itmark a key: probe a Map<key, handlers>, dedup the key in a Set, enlistWhat the two sides do differently
THE MARK, NOT THE DELIVERY. Ours transcribes the prefix of `OIMChannel.writeWithoutFlushCheck` — `slot.effects`, the stamp against the frame, the `isRunScheduled` check of `addEffectScheduledToRun` and the stamp store — without the clock wrap and the flush request; the floor is the self-contained emitter the post turned down, one hash to find the handlers and one string-`Set` insertion to dedup the key. Every key carries one standing effect and a frame marks 1024 distinct keys once each, so every mark enlists on both arms; closing the frame is inside both numbers once per 1024 marks. The build throws unless one frame enlists the same count on both. What the floor buys and ours does not: carriers know nothing about subscriptions, and a key with no carrier yet can be subscribed to. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.
effectService.createEffect(db, [entityService.holdColumn(slot, 'title')], [], body) — per roweffectService.createEffect(db, [slot], [], body) with the body comparing `title` against what it saw lastWhat the two sides do differently
ONE OPERATION IS ONE ROW WRITE, AND A PASS IS TWO OF THEM PER ROW: every row's `note` moves and a frame runs, then every row's `title` moves and a frame runs. One subscriber per row, mounted before the clock, cares only about `title`. Ours subscribes to the column's own identity, so the `note` frame wakes nobody — the write probes the row's column store and finds no `note` column — and the `title` frame wakes every subscriber; the rejected arm subscribes to the row, so BOTH frames wake every subscriber and its body filters the `note` frame out. Each arm was checked to report exactly one title change per row per pass. The two arms put different slot shapes through the same `slotContentService.updateEntity` and the same db, so the pair is isolated.
enqueue the effect itself, deduplicated by its own isPending flagenqueue a record and hand back a disposer closure that cancels itWhat the two sides do differently
OURS IS THE SHAPE `OIMChannel` SHIPS — the private `addEffectScheduledToRun` pushes the effect by reference and dedups on `effect.isRunScheduled` — transcribed rather than called, because the public `scheduleEffectRun` also requests a flush. The floor allocates a record and a closure per enqueue, which is what the post turned down; its disposers are sunk so neither allocation can be removed. A frame enqueues 1024 distinct effects once each and then drains, and the drain is inside both numbers once per frame. The build throws unless one drain runs the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.
compare the leaf's frame stamp, write it, push onto the frame array — no arrival is a repeatadd the leaf to the frame's Set, which dedups by containment — no arrival is a repeatWhat the two sides do differently
THE ROW WITH NOTHING TO DEDUPLICATE, AND IT IS HERE BECAUSE IT IS THE ONE THE STAMP SHOULD WIN LEAST. Every leaf reads one root, so all 200 arrivals of a frame are first arrivals: our stamp never takes its early return and the `Set` never probes an entry it already holds. What is left in the difference is a field compare plus a field store plus an array push against one hash insert, with no repeat path exercised on either side. A reader who wants to know what the stamp is worth when the graph is a tree — one consumer per root, which is what most screens are — reads this row and not the other two. It is also the row that says whether the recovered figures can be quoted at all: if the stamp does not lead here, the mechanism is not what the quoted per-arrival numbers were describing. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.
the same three lines, at fan-in 3 — two arrivals in three are repeatsthe same Set, at fan-in 3 — two arrivals in three are repeatsWhat the two sides do differently
THE GEOMETRY THE QUOTED FIGURES WERE TAKEN AT — 200 consumers, fan-in 3, 300 roots — and the row that answers whether 0.95 ns against 5.24 ns, a factor of 5.5x, is what this mechanism costs [NO RUN BEHIND THIS FIGURE]. ONE THING ABOUT THE MIX IS NOT THE SAME AND IS SAID RATHER THAN LEFT TO BE FOUND: the quoted run reported 370 arrivals per frame of which 182 were deduplicated, and this row writes EVERY root, so a frame here is 600 arrivals of which 400 are repeats [NO RUN BEHIND THIS FIGURE]. The unit is per arrival on both, which is what makes them comparable at all; the repeat FRACTION is higher here, and since a repeat is where the stamp is strongest, this row should read at least as favourably as the quoted one and a reading below it is the interesting outcome [FIGURE STATED IN ADVANCE]. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.
the same three lines, at fan-in 8 — seven arrivals in eight are repeatsthe same Set, at fan-in 8 — seven arrivals in eight are repeatsWhat the two sides do differently
THE WIDE END, WHERE ALMOST EVERY ARRIVAL IS A REPEAT AND THE TWO DESIGNS ARE FURTHEST APART PER ARRIVAL. A leaf reading eight roots is an ordinary derived view — a total over a group, a row joined from several records — and a frame that touches all of them offers it eight times. Our arm answers seven of those eight with one field compare and a branch; the `Set` answers each with a hash of the object identity and a bucket probe. THIS IS THE ROW TO DISTRUST IF ANY, and in the direction that flatters us: the frame's own walk and its teardown are shared by both arms and are amortised over 1600 arrivals here against 200 at fan-in 1, so the shared constant is at its smallest exactly where our margin is at its largest. Read the three rows as a table and the trend across them rather than any one of them as the price. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.
slot = map.get(key); slot.entity = row; stamp and deliverrows.set(key, row); then identities.get(key) because that map is no longer emptyWhat the two sides do differently
WHERE THE BILL FOR TWO MAPS ARRIVES. One subscriber stands on one key, mounted before the clock, so the identity map is not empty and EVERY write on the floor pays a second hash to learn whether its key is watched; ours resolved the slot with the one hash it needed to write, and the subscriber list is a field on it. Exactly one write per pass lands on the watched row and is delivered on both sides, so the difference is the per-row probe and not the delivery. Values alternate between two prepared sets, so no write re-sends what the store holds. Below one is the shipped shape winning.
alt.identity-store.one-map-vs-two.overwrite-while-one-subscriber-standsmap.set(key, slot) — mint the identity and put the row on it, one maprows.set(key, row) — and skip an identity map that is still emptyWhat the two sides do differently
A FIRST LOAD INTO AN EMPTY STORE, THE ROW THE TWO-MAP SHAPE WINS. Ours mints a slot per row and files it; the floor files the bare row and tests the identity map's size, which is zero, so it mints nothing. Both stores are rebuilt between passes, untimed, and the minted slots are collected outside the clock. Above one is expected and is the case for the rejected shape; read it with the overwrite row.
openContentSubframe/closeContentSubframe through OIMContentChangeDeliveryServiceevery step by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the content subframe — the channel call, the channel slot's content subframe depth and the delivery check at its outermost close — instead of the channel call and a counter.
assertWritable through the slot owner servicethe step below by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's assertWritable.
slotContentService.writeEntityWithoutSubframethe writer and the channel called by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: writeEntityWithoutSubframe: the entity-undefined check, fillEntity, dispatchColumnsChanged and its column-store check.
updateEntitySlotEmptiness through the content service and the slot owner servicethe step by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's settleEmptiness and settleWrite.
dispatchContentChange through the slot owner serviceno content-change callWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's dispatchContentChange with no listener.
releaseSlotIfUnheldAfterListeners through the slot owner servicethe check by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's release check after the write.
slotOwnerService.createSlotcreateOIMEntitySlot called by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: slotOwnerService.createSlot: the content service's private slotContentStrategy.createSlot behind the owner.
entityService.slotContentService.upsertEntity(storeSlot, entity)every step through the service's internal pieces, chained by handWhat the two sides do differently
One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: upsertEntity's selectKey and insertEntity itself: the store lookup, ownKey, createSlot, the isOnFastPath read and the fast-path insert, which on this fixture opens no subframe, runs no contentChanged and no release check and calls entityWriter.fillEntity directly, so the floor carries steps the door does not run.
map.set(id, oimCopyEntitySanitized(entity))map.set(id, { ...entity })What the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: oimCopyEntitySanitized instead of the bare spread: the spread plus the own-`__proto__` probe and its delete.
the release check after filingthe steps below without itWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: releaseSlotIfUnheldAfterListeners: the subframe-tail check, isReleasable and the policy question. The shipped insert runs no release check on its fast path, and on its subframe path calls releaseWrittenSlotIfUnheld instead.
every step inside OIMChannelService.INSTANCE.openSubframe/closeSubframe with try/catch, as insertEntityInSubframe runs themthe same steps without a subframeWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the subframe the insert opens around itself, and the try/catch around it.
entityService.upsertEntity(entityStoreSlot, entity); db.flush() per passthe same steps written by hand around the shipped piecesWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the shipped door, which on this fixture takes its fast path (insertEntity): no subframe, no dispatchContentChange and no release check, so the floor carries three steps the door does not run.
map.set(id, slot) with slot = createOIMEntitySlot(id, owner), slot.entity = the copymap.set(id, oimCopyEntitySanitized(entity))What the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the fourteen-field slot object the copy is stored in.
map.get(id) first, then map.set(id, slot)map.set(id, slot)What the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the probe writeContentByKey opens with, on the bare Map.
the store service: get, ownKey, setmap.get(id), then map.set(id, slot)What the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the store service in place of the bare Map for the probe and the filing (setByKey).
the key read through a selectKey functionthe key read as row.idWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the selectKey call upsertEntity makes before writeContentByKey.
the shipped writer fills the slot, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot); db.flush() per passthe copy assigned by hand, no channelWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: what insertEntity runs to land the entity: the shipped writer's fillEntity and the channel write that stamps the slot.
OIMChannelService.INSTANCE.assertNotFlushing(channelSlot) and the released check before filingthe writer and the channelWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: assertWritable.
the emptiness check and the release policy notified, as settleEmptiness doesthe assert, the writer and the channelWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: settleEmptiness: the emptiness strategy, the slot-stamp check, onSlotWritten, and the idle check of a slot nobody subscribes to.
the content-change step with no listenerthe steps below without itWhat the two sides do differently
One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: dispatchContentChange, which returns at once when the collection has no listener. The shipped insert calls it only on its subframe path (insertEntityInSubframe), not on the fast path this fixture takes.
a member leaves a bucket of 100 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)the same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)What the two sides do differently
A BUCKET OF 100, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 100 members and pushes all 100 back, and the collection holds 100 arrivals and unholds 100 departures. On the unordered half: `reconcileSlots` builds one Set of the 100 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 6, 12, … 90) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 64 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.
a member leaves a bucket of 10000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)the same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)What the two sides do differently
A BUCKET OF 10000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 10000 members and pushes all 10000 back, and the collection holds 10000 arrivals and unholds 10000 departures. On the unordered half: `reconcileSlots` builds one Set of the 10000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 625, 1250, … 9375) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 8 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.
a member leaves a bucket of 1000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)the same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)What the two sides do differently
A BUCKET OF 1000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 1000 members and pushes all 1000 back, and the collection holds 1000 arrivals and unholds 1000 departures. On the unordered half: `reconcileSlots` builds one Set of the 1000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 62, 124, … 930) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 64 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.
a member leaves a bucket of 50000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)the same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)What the two sides do differently
A BUCKET OF 50000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 50000 members and pushes all 50000 back, and the collection holds 50000 arrivals and unholds 50000 departures. On the unordered half: `reconcileSlots` builds one Set of the 50000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 3125, 6250, … 46875) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 2 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.
mint one slot, cycling the four shipped shapesmint one slot whose common fields live in a sub-object (every mint allocates two objects)What the two sides do differently
Both arms allocate inside the clock; the candidate allocates the common sub-object on every mint.
mint one slot, cycling the four shipped shapesmint one slot of the one shape; bucket and computed also allocate their content objectWhat the two sides do differently
Both arms allocate inside the clock; the candidate allocates a second object for a bucket or a computed slot (two of every four mints), which is the price the one-shape layout pays.
mint one slot of each of the three shipped shapesmint three slots of the one unified shapeWhat the two sides do differently
THE HALF OF THE UNIFIED-SHAPE ARGUMENT THAT PAYS FOR IT. One operation mints three literals; the unified one carries every field of every kind, so it is larger than every shipped kind, and a first load pays that once per entity. Both arms allocate inside the clock and the young-generation collections that follow are charged to whichever arm allocated more, which is the honest direction. Divide this pair's difference by the write pair's difference to get the writes per slot at which the unified shape breaks even.
Published 2026-10-23T11:06:57.973Z.
Per read
getValueForSlot on a computed slot over 1 source slot, refreshed against the channel clock — nothing written sincesettle it against one reading per source, held in an array beside the source listWhat the two sides do differently
THE QUIET READ, AND ON THE SHIPPED ENGINE IT DOES NOT WALK THE SOURCES AT ALL. `oimRefreshComputedSlot` returns on the slot's `checkedAt` pair matching the channel clock, which is only possible because the clock is ONE scale: nothing was written anywhere, so nothing a derivation reads can have moved. The per-slot arm has no such question to ask and must compare every source reading. At one source that walk is one element, so this row is the narrowest the gap can be. 1024 derivations are settled before the clock starts and read in rotation. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.
getValueForSlot on a computed slot over 3 source slots, refreshed against the channel clock — nothing written sincesettle it against three readings, held in an array beside the source listWhat the two sides do differently
THE QUIET READ AT THREE SOURCES. Ours still returns on the two-field `checkedAt` comparison whatever the fan-in; the rejected arm walks three readings. The recovered table put fan-in 3 at 1.14x to 1.18x in our favour [NO RUN BEHIND THIS FIGURE], measured on an engine that walked the sources on every settle, so it is not a prediction for this row. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.
getValueForSlot on a computed slot over 8 source slots, refreshed against the channel clock — nothing written sincesettle it against eight readings, held in an array beside the source listWhat the two sides do differently
THE WIDE END. 1024 derivations of eight sources use all 8192 rows of the fixture, so every row is a source of exactly one derivation. Ours compares two inline fields; the rejected arm indexes eight elements off a heap array it allocated per derivation. IF THIS ROW COMES BACK NEAR 1.00 THE QUIET-READ CLAIM IS DEAD [FIGURE STATED IN ADVANCE]. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.
write an entity no derivation reads, then getValueForSlot on a computed slot over 3 source slotsthe same write, then settle against three per-source readingsWhat the two sides do differently
THE QUIET ROWS' OTHER HALF, AND THE ONE TO READ BESIDE THEM. Any write anywhere moves the channel clock, so the `checkedAt` short-circuit misses and ours walks its three sources through `oimIsRevisionAfter` exactly as the rejected arm walks its readings — neither re-derives, because the written row is outside every source list. The write is the shipped `entityService.slotContentService.updateEntity` on BOTH arms and moves `title` on every call, so it is in both numbers alike. Without this row the quiet rows would price the short-circuit as if every frame were silent. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.
alt.clock.global-pair-vs-per-slot.read-after-an-unrelated-write.fan-in-3read a surviving column off an in-place row the engine deleted a column fromREJECTED: the same read off a row whose departed column was set to undefinedWhat the two sides do differently
EXPECTED TO GO AGAINST THE SHIPPED DESIGN. The blanked form keeps the hidden class its population settled on; the shipped in-place `putEntity` `delete`s and every later read pays for it. ONE OPERATION IS ONE PROPERTY READ of a SURVIVING column (`c07`) off one stored row, walked through the whole population with a mask. Both populations were loaded identically and given the same whole-row `upsertEntity` missing `c15`; ours ran the shipped in-place `putEntity`, which `delete`s it, the rejected one set it to `undefined`. The stored object is the SAME OBJECT on the in-place path on both arms. WHAT THE BLANKED FORM CANNOT DO, and it is not visible in this number: `c15` stays an own property, so the next whole-row `upsertEntity` finds the same column leaving again, reports it removed again and wakes its subscribers again — and a column a caller deliberately stored as `undefined` would stop being distinguishable from one that left. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.
the same read where one row in eight was deleted from — two shapes in one populationREJECTED: the same population blanked instead — one shape throughoutWhat the two sides do differently
THE POPULATION AN APPLICATION ACTUALLY HAS, AND THE SECOND THING THE SHIPPED `delete` COSTS. Here one row in eight has lost a column and seven have not, so ours reads through a site that sees two shapes while the floor's sees one — a blanked population cannot fragment. ONE OPERATION IS ONE PROPERTY READ of `c07` off one stored row, over the whole population with a mask. Both arms read the same column of the same rows in the same order and differ only in what the removal did. READ AGAINST THE ROW ABOVE: that one isolates the cost of the shape, this one adds the cost of two shapes at one site. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.
alt.column-left.delete-vs-blank.read-one-row-in-eight-lost-a-columnmap.get(key)?.entityrows.get(key)What the two sides do differently
ONE INDIRECTION MORE ON OUR SIDE: the row sits on the slot, so a read by key is a hash and a field load where the two-map store answers with the hash alone. Every key hits on both sides, and both stores were checked to hand back the same row object for every key before the clock started.
for (const slot of slotContentService.getBucketMemberSlots(bucket)) slot.entity — a Set of 10000, per memberthe same walk of the same members, kept as a list, per memberWhat the two sides do differently
THE SENTENCE UNDER TEST is the one printed above the published removal table: "Both iterate at around [NO RUN BEHIND THIS FIGURE] 2 ns per element, and the difference between them is a fraction of that." It is the half of the bucket service argument that says the choice is NOT an iteration question, and it had no measurement behind it either. THE BODY IS THE SAME ON BOTH HALVES, character for character: one `getBucketMemberSlots`, one for-of, one field load and one store into the sink per member. The only difference in the process is what `getBucketMemberSlots` hands back — a `Set` on ours, the service's own array on the floor — so this row is a property of two JavaScript containers reached through one library, which is exactly what the sentence claims to be about. NOTHING IS WRITTEN, NO MEMBERSHIP IS SET AND NO FRAME IS CLOSED, and neither service orders anything on a read: the list hands back the array `priceGroupIndex` filled, in the order it was written. What a pass pays outside the walk is one service call and one iterator, spread over 10000 members. DIRECTION, three ways: (1) ours is measured on a set that was FILLED and never deleted from, so its entry table has no tombstones to walk — a bucket that has churned iterates worse, and this row therefore flatters the unordered half; (2) `slot.entity` is loaded per member on both halves, because a reader that visits members without looking at them is not a reader, and it is the same monomorphic field load on each side; (3) a pass is a whole walk of the bucket, so the operation count may overshoot what the prober asked for by fewer than 10000 members out of the millions a [NO RUN BEHIND THIS FIGURE] 25 ms pass visits.
publicService.holdSlot(slot), forwarding to internalService.holdSlotinternalService.holdSlot(slot): holdCount++What the two sides do differently
A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a hold: one increment.
publicService.getBucketMemberSlotCount(slot), forwarding to the internal serviceinternalService.getBucketMemberSlotCount(slot): one field loadWhat the two sides do differently
A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a read: one field load, summed into a sink.
entityService.getSlotByKey(entityStoreSlot, id).entityslotById.get(id).entity — a bare Map.get over the same slotsWhat the two sides do differently
Both sides run on the same population of priceDataset.batch entities and visit the same ids in the same order. The floor reaches the same slots through a hand-built Map<id, slot>; the engine reaches them through its store service. No write and no flush: only the lookup and one property read.
getValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per writebody(list.rows) — the same body, called on every read, no nodeWhat the two sides do differently
THE SHAPE `churnChain` HAS: one field of one row, one read per write. The body is cheaper than the node's own bookkeeping, so ours loses by roughly the bookkeeping; no verdict about derivation can be taken from this cell alone. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.
getValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per writebody(list.rows) — the same body, called on every read, no nodeWhat the two sides do differently
THE CHEAP BODY READ SIXTEEN TIMES: what a memo saves is a field load, and what it costs per read is a clock compare, so the reads-per-write axis alone cannot rescue it here. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.
getValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per writebody(list.rows) — the same body, called on every read, no nodeWhat the two sides do differently
THE MEMO WITH NOTHING TO AMORTISE OVER: a filter and a sum over the list, read once per write, so ours derives on every read exactly as the floor does and pays the node on top. Above one is expected; this is the worst cell of the two axes for the shipped design. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.
getValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per writebody(list.rows) — the same body, called on every read, no nodeWhat the two sides do differently
THE CASE A MEMO IS FOR: the dear body, sixteen reads between two writes — or sixteen consumers reading once each, which is the same axis. Ours derives once and answers fifteen reads from the node; the floor walks the list sixteen times. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.
slotContentService.getBucketMemberSlotPosition(bucket, member) in a list of 1024 — a scanthe same question answered by a Map to positions — one hashWhat the two sides do differently
THE ONE ROW IN THIS FILE WHERE THE DESIGN WE REJECTED WINS, and it should: a hash against a scan of five hundred on average. It is here because a pair that only shows a rejected design losing is an argument and not a measurement. WHAT IT DOES NOT SHOW is the call site: `remove` asks for a position and splices with it immediately, and that splice is the same memmove for both designs, so the row above is what it costs to have the hash at all. The members are cycled through with a mask so the scan length is uniform over the list, and the build throws unless both designs place every member at the same position. The reading in `packages/bench/measurements/2026-08-20-alternatives/positions` was taken on the removed positional index and is not re-attributed here.
read a surviving column off a replacement built empty and filled with survivorsREJECTED: the same read off a replacement spread and then deleted fromWhat the two sides do differently
THE SECOND READING, AND THE ONE THE SHIPPED SIDE IS BUYING. `delete` on a plain object takes it out of the shape its population shares, and the rejected rebuild would hand readers a replacement born in that state on every removal. That cost is paid PER READ, for the life of the row. ONE OPERATION IS ONE PROPERTY READ of a SURVIVING column (`c07`) off one stored row, walked through the whole population with a mask. Every row of both populations has been through the same whole-row `upsertEntity` missing `c15`; ours built the replacement in the shipped replacing `putEntity`, the rejected one spread it and `delete`d `c15`. THE WORK IS IDENTICAL AND THE SHAPES ARE NOT. A SURVIVING COLUMN AND NOT THE REMOVED ONE, deliberately: `c15` reads `undefined` on both sides and would measure a miss. EVERY ROW LOST THE COLUMN, so each arm sees exactly one shape — the conservative form. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.
alt.replacement-rebuild.survivors-vs-spread-and-delete.read-afterslot.bucketSlotsStore on shipped bucket slotsslot.content.bucketSlotsStore on one-shape slots (one extra load)What the two sides do differently
The bucket hot read: every bucket door reads its store first. One operation is one read.
map.get(key).entity on shipped entity slotsmap.get(key).content on one-shape slotsWhat the two sides do differently
The find path: a key lookup and one field load. Same keys; only the slot layout and the field name differ. Every key hits.
Published 2026-10-23T11:06:57.973Z.