Skip to content

fix: keep user code off the shared deadline-service thread - #282

Merged
unbalancedparentheses merged 13 commits into
mainfrom
fix/deadline-disposal
Nov 18, 2026
Merged

unbalancedparentheses merged 13 commits into
mainfrom
fix/deadline-disposal

Conversation

@unbalancedparentheses

@unbalancedparentheses unbalancedparentheses commented Nov 17, 2026 •

Copy link
Copy Markdown
Contributor

Closes the 0.8 known limitation "Deadline-service follow-up" (ROADMAP). The process-wide deadline thread used to run user code inline: a caller's waker, a payload destructor, the last reference to a job's done. One blocking callback could stall every other actor's deadlines and credit returns.

Design

The deadline thread now only decides expiry. It pops due entries, makes the terminal transition (OPEN -> TIMED_OUT, a job's JobDeadline notification, a scheduled emit's fire), returns the deferral credit, unparks a parked blocking receiver, and enqueues job messages on the owner's mailbox. Whatever can run user code goes to disposal workers: wakers, payloads routed to the owner's DropFailures, the last references to jobs, runs and the registry, and a due slot that may hold an unread reply.

  • reply/disposal.rs (new). While the service visits a registry, it collects deferrable items in a thread-local batch and then queues them one entry per item in an elastic pool. When queued items outnumber idle workers, a worker starts (one start in flight at a time, up to 64; idle ones exit after 10 s), and each worker re-checks when it takes an item. A blocked callback holds only the item it runs. While fewer than 64 callbacks are blocked at once, no other expiry, credit return or wake-up waits for it, whether from another actor or another caller of the same actor.

  • R6 (callers before payloads). A payload handed off is settled on the worker, under the hold lock: it is held if the owner's exit began, and dropped at its death point. A drop decided just before the exit is pre-exit work, like an inline discard. The exit never waits for it, because such a destructor could wait for this actor's callers (deferred-replies.md §5).

  • Cost. Requests that never expire take no new step. Empty payloads are not handed off. Due entries drop in place unless they may hold an unread reply.

  • What still runs on the service thread. These cases are documented in disposal.rs, deferred-replies.md §2 and semantics.md:

    • the owner's own executor wake;
    • dropping (not waking) a job's stored wakers;
    • tracing subscriber calls for a contained panic or the cap warning;
    • a panic payload's destructor;
    • the work itself, if no disposal thread can be spawned;
    • an unwinding job notification's run drop.

    Beyond the cap, later items queue.

Why a pool. Deferring to the owning actor would tie a caller's timeout wake-up to a possibly wedged owner. Deferring to the caller leaves no thread for an unpolled token. A single disposal thread just moves the stall.

Tests

  • concurrency/tests/deadline_service.rs. Subprocess regression tests with bounded waits:

    • a blocking payload destructor (tasks);
    • a blocking waker (tasks);
    • a blocking destructor (threads);
    • two callers of one actor, where the first caller's waker blocks.

    All of them fail on main. The same-actor test also fails with whole-batch queueing: the second caller is woken only after 3.0 s.

  • Pool unit tests (reply::disposal::tests):

    • a blocked item holds back neither the rest of its batch nor the next batch;
    • a panicking item is contained;
    • an unwinding visit still submits what it collected;
    • a deferral during thread-local teardown runs inline;
    • only last references are handed off;
    • a stress test of submissions racing workers going idle and exiting.
  • Loom. reply_slot_loom.rs service_expiry_with_handed_off_wake_vs_reply.

Models

  • verification/tla/Disposal.tla is a companion of DeferredReplies. It models:

    • per-entry Expire (transition and credit return on the service thread);
    • payload Release and Other hand-offs;
    • Submit, one entry per item;
    • the pool as disposal.rs runs it: worker states, the idle count, and the start rule after Submit and after every Take (one start in flight, the cap); Wait, Woke, Retire;
    • wake-ups run by workers;
    • two-step payload drops: Settle decides under the hold lock, then the destructor runs until Done;
    • Blocking items.
  • Invariants: CreditWithTransition, WakeAfterTransition, NoDropWhileHeld (on the decision), WithinCap, TimelyExpiry, TimelyWake. Liveness: EveryWakeRuns, EveryDueExpires.

  • Configurations:

    • MCDisposal, a blocking waker: 65,961 distinct states.
    • MCDisposalDrop, a blocking destructor: 535,521 distinct states.
    • MCDisposalCapped, one worker: 762 states. It checks a weakened TimelyWakeBelowCap; the full TimelyWake fails there.
  • Negative controls (each violates its invariant):

    Fault Breaks
    InlineDisposal TimelyExpiry
    WakeBeforeTransition WakeAfterTransition
    DropWhileHeld NoDropWhileHeld
    BatchSerial (the shared-batch bug) TimelyWake
    NoStartOnTake (stranding) TimelyWake

    InlineDisposal is also kept as a control in DeferredReplies.

  • Tied to the code. With lifecycle-trace (compiled out otherwise), every action is recorded at its linearization point:

    • a leading Pool snapshot, which becomes the model's InitIdle;
    • Expire, Defer (every other hand-off) and Submit with its start decision;
    • Begin, Take (with its start decision), Wait, Woke and Retire, all under the pool lock;
    • Run, Settle and Done, with worker and item ids;
    • Exit and Death.

    A worker running an item it never took, or a start the rule requires but the code skips, is rejected.

  • Trace scenarios (concurrency/tests/disposal_trace.rs):

    • expired callers woken;
    • payloads dropped;
    • a payload held until death (disposal.item failpoint);
    • workers retiring and starting (disposal.keep_alive);
    • a control recorded from code with the shared-batch bug switched on (disposal.batch_serial, written to controls/), which must be rejected.

    Five log-edit mutations are rejected as well.

  • Results on fede: 102/102 traces accepted, all controls pass, coverage 13/13 action keys (coverage_floor = 13), stability 25/25.

  • Model-sync passes with no waiver.

Performance (perf gate, callgrind Ir/op, fede, CI toolchain 1.93.0, 9 reps, on main with #284/#296)

benchmark base head change
async_ct_burst 3,476 3,479 +0.1%
async_ct_request_seq 2,982 2,982 0.0%
async_ct_request_conc16 2,215 2,215 0.0%
async_ct_send_p1 564 564 0.0%
async_ct_send_p2 559 559 0.0%
threads_request_seq 2,117 2,095 -1.0% (spread ±38)

PASS. After the rebase onto #284/#296, the first head measured +5.5% on async_ct_send. The cause was an extra generic method in Expirable for Slot<R>, instantiated per reply type in the caller's crate, which made LLVM stop inlining the tasks receive loop's poll_fn. The fix folds the decision into expire (it returns whether the last drop could run user code) and reads only the slot word in one non-generic function. I found the cause by bisecting the commits and testing variants on fede.

Review follow-ups

First review:

  1. Per-item queueing, with the same-actor regression test.
  2. TLS teardown is handled with try_with.
  3. An unwinding visit submits what it collected.
  4. The credit wording is fixed.
  5. Hand-offs happen only for the last reference.
  6. Reaching the cap logs disposal_workers_capped.
  7. The threads perf regression is recovered.

Second review:

  1. Empty hand-offs. discard_some is used at the call sites; entries drop in place; JobState routes what exit released through defer.
  2. The trace is tied to the pool. See Models.
  3. Docs. They list the remaining inline cases and narrow the claim to below 64 blocked callbacks.
  4. Settle versus Exit. The model has two steps and the invariant applies to the decision. Exit still never waits for pre-exit destructors, by design. A bounded wait at the death point would change the death point's semantics and the Lifecycle model, so it belongs in its own PR.
  5. Bursts. Documented.

Checks run

cargo fmt, clippy (default features, and with lifecycle-trace + failpoints), cargo test -p spawned-concurrency (595 passed), the trace and failpoint suites, the sim suites, Loom, the model-sync events/models/paths checks, and the planted patches still applying.

@unbalancedparentheses unbalancedparentheses added the no-model-change Modelled code changed without a model change; the PR body says why (Model: no change because ...) label Nov 17, 2026
@unbalancedparentheses unbalancedparentheses removed the no-model-change Modelled code changed without a model change; the PR body says why (Model: no change because ...) label Nov 17, 2026
@unbalancedparentheses
unbalancedparentheses force-pushed the fix/deadline-disposal branch 2 times, most recently from 42c2f3f to 6999e95 Compare November 17, 2026 23:54
@unbalancedparentheses
unbalancedparentheses marked this pull request as ready for review November 18, 2026 00:12
@unbalancedparentheses
unbalancedparentheses added this pull request to the merge queue Nov 18, 2026
@github-actions

Copy link
Copy Markdown

🤖 Codex Code Review

No actionable correctness or concurrency issues found. The disposal pool keeps deadline transitions and credit returns independent of user callbacks, and payload disposal rechecks the owner’s shutdown hold.

Validation was limited to code inspection: tests could not run because rustup attempted to write to a read-only directory.


Automated review by OpenAI Codex · gpt-6.1-sol · custom prompt · 325.4k in / 1.7k out · ~$0.17

@github-actions

Copy link
Copy Markdown

🤖 Claude Code Review

Review: PR #282 — deadline-service disposal pool

The design is sound. The service thread decides expiry and returns credits, and user code goes to an elastic pool. A payload handed off before the owner's exit is re-checked against the hold on the worker (settle). The worker loop re-checks the queue after a timeout and after a notify, so I couldn't construct a lost item from the idle accounting. That accounting counts notified workers that haven't re-locked yet; it is conservative, not wrong. Lock order (pool → trace section → held) is consistent everywhere I checked.

Issues

1. registry.rs Slot::dispose (~L57–67) hands off non-last references

super::disposal::defer_drop(self);

This defers the drop of the Arc whether or not it is the last reference. The common case looks like this:

  • A slot is REPLIED, or still OPEN because the entry was re-scheduled.
  • The caller still holds its receiver.

That case now costs:

  • a Box allocation,
  • a queue entry,
  • possibly a worker spawn,

all for an Arc decrement that runs no user code. This contradicts the module doc ("a reference that is not the last runs no user code, so it costs no hand-off") and the "empty payloads are no longer handed off" claim.

Suggested fix:

super::disposal::defer_drop_arc(self);

Arc::into_inner is race-free here: if the caller's drop wins, the caller's thread runs the destructor, as before.

2. Isolation granularity is coarser than the docs claim

  • slot.rs Wake::run: a slot's caller waker and all its token watchers run as one item. In expire, defer_as("wake", move || wake.run()) submits them together. So a blocking watcher delays the caller's waker of the same token.
  • jobs.rs wake_emitters: all emitter wakers of a job run in one item. One blocking waker delays the others.

Either:

  • split these into one item per waker/watcher (only when collecting(), so there is no inline cost), or
  • qualify "one item at a time … of the same one" in deferred-replies.md §2, the CHANGELOG and GUIDE.md.

3. disposal.rs collect (~L157–176): not re-entrancy safe, and can panic in Drop

  • BATCH.with(|b| *b.borrow_mut() = Some(Vec::new())) silently overwrites an existing batch. A nested collect would lose the outer items, which are wake-ups. Add debug_assert!(b.borrow().is_none()).
  • Scope::drop → Scope::take uses borrow_mut(). If the unwind originated while defer_as held the try_borrow_mut guard (e.g. a panic in the trace recorder), this panics during unwinding and aborts. Use try_borrow_mut there, as defer_as and collecting already do.

4. disposal.rs State::capped: reset only in Retire

The doc says the flag is "reset once below it again". In practice it is reset only when an idle worker times out. Under sustained load that never lets a worker retire, the pool can go below the cap and hit it again with no further warning.

  • Option A: reset capped when workers < MAX_WORKERS is observed in needs_worker.
  • Option B: fix the comment to match the current behaviour.

5. disposal.rs start_worker spawn-failure path

When workers > 0 but all workers are blocked, the queued items stay stranded until the next submit. This happens because starting is cleared and nothing retries.

  • It is acceptable as a degraded mode.
  • The "what still runs inline / limits" list in §2 should mention it alongside the workers == 0 inline fallback.

6. tests/disposal_trace.rs: quiescence relies on 100 ms sleeps

record() and write_to() sleep a fixed 100 ms. However, trace_check.py::generate_disposal hard-fails unless Pool has idle == workers && !starting. On a loaded CI or sanitizer runner, a worker still finishing a previous scenario's item makes the trace invalid rather than the test fail. This causes flaky verification CI.

Suggested fix: poll with_pool_state (expose a test helper) until the pool is quiescent, with a bound, before record_disposal() and before take_disposal().

Minor / nits

  • disposal.rs deferral_after_thread_local_teardown_runs_inline: the test passes regardless of TLS destructor order, which is unspecified across platforms. After collect returns, BATCH is None anyway, so the test doesn't exercise the "try_with fails" path it describes. Consider asserting via a flag that BATCH.try_with actually returned Err, or soften the comment.
  • failpoints.rs disposal.batch_serial description; Disposal.tla header: "the shared-batch bug fixed in PR fix: keep user code off the shared deadline-service thread #282 / PR fix: keep user code off the shared deadline-service thread #282's first rev." refers to an unreleased intermediate revision. Describe the fault itself instead; it will read oddly in the permanent tree.
  • Item::id / current(): the return …; #[cfg(not)] 0 pattern works but is awkward. Two #[cfg]'d function bodies, or cfg_if-style blocks, read better.
  • deadline.rs: if service_deadlines unwinds inside contain_entry, the upgraded registry drops inline on the service thread during unwinding. This is fine, but it is another inline case not listed in §2.
  • CHANGELOG.md: the new bullet is missing the blank line before "- Regenerate the 11 planted-bug patches…", unlike the neighbouring entries.

Looks good

  • expire_collect/terminate_collect keep transition and credit return atomic before the hand-off. The Loom case service_expiry_with_handed_off_wake_vs_reply covers the hand-off race well.
  • discard_some and the ScheduledEmit::settle guard avoid hand-offs for empty payloads.
  • defer_as only boxes when collecting, so there is no allocation on non-service threads.
  • The Expirable::dispose(self: Arc<Self>) default keeps the trait object-safe.
  • The subprocess isolation tests cover both backends, and the same-actor two-caller case is a valuable regression test.

Automated review by Claude · claude-opus-5-5 · custom prompt · 64.3k in / 10.7k out · ~$0.47

@github-actions

Copy link
Copy Markdown

🤖 DeepSeek Code Review

The PR is a substantial, well-documented change: dedicated disposal workers, TLA model, trace validation, and regression tests all look coherent. A few points worth checking before merge:

  1. Reentrancy of lifecycle_trace::atomic — possible deadlock/panic when lifecycle tracing is on
    disposal_section now wraps the entire section in atomic(f), and within that section lifecycle_trace::disposal(...) calls atomic(|| ...) again.

    • concurrency/src/lifecycle_trace.rs: disposal_section and disposal
    • This nesting happens on every recorded discard, settle, hold, and release.
      If atomic is a plain non-reentrant mutex/guard, this deadlocks immediately when recording. Please confirm atomic is reentrant (or make disposal not re-enter it inside a section), and add a test that exercises one of these paths with record_disposal() enabled.
  2. Slot::dispose hands off non-last references
    concurrency/src/reply/registry.rs, fn dispose(self: Arc<Self>):

    super::disposal::defer_drop(self);

    This always creates a disposal-work item for a Replied slot, even when another ReplyReceiver still owns an Arc<Slot>; dropping the service’s Arc then just decrements the strong count and runs no user code.
    Use defer_drop_arc(self) here, consistent with the comment and the other paths:

    super::disposal::defer_drop_arc(self);

    This avoids an unnecessary worker handoff on every replied deadline entry whose receiver is still alive.

  3. Empty payloads may still be handed off, despite the changelog/docs wording
    concurrency/src/mailbox.rs, discard<T> still defers any T, including () or an empty struct, when called on the service thread. The new discard_some only skips Option::None.
    If the design goal is “empty payloads are not handed off”, then either this needs a marker trait or the docs should say only discard_some(None) is optimized. As written, there is a small avoidable worker cost for empty-but-present payloads.

  4. collect overwrites an existing batch on reentrancy
    concurrency/src/reply/disposal.rs, collect:

    BATCH.with(|batch| *batch.borrow_mut() = Some(Vec::new()));

    If collect is ever re-entered on the same thread while a batch is already active, the outer batch is silently dropped. Current call paths do not appear to re-enter, but this is fragile. Consider a debug_assert! or an explicit guard so future changes don’t lose work.

  5. Fallback inline execution in start_worker weakens the isolation guarantee
    concurrency/src/reply/disposal.rs, start_worker, Start::Yes spawn failure:

    if state.workers == 0 {
        std::mem::take(&mut state.queue)
    } else {
        VecDeque::new()
    }
    orphaned.into_iter().for_each(run_item);

    This is documented and only happens when thread creation fails, but the orphaned items then run on the deadline-service thread. Worth confirming that this fallback is acceptable for the isolation contract and that the docs call it out explicitly (they do, with “only if no disposal thread exists and none can be spawned”). Not a correctness bug, just a known limitation.

  6. defer_as can silently run inline and return 0 while recording an Expire:wake
    concurrency/src/reply/registry.rs, Slot::expire, and reply/disposal.rs, defer_as.
    If BATCH.try_with or try_borrow_mut fails during a recorded visit, defer_as runs the waker inline and returns 0, but Slot::expire still records Expire with x: "wake" and id = 0.
    That would make a trace with an Expire:wake but no corresponding deferred item. This should not happen in normal use, but a debug assertion or fallback recording (x: "none"/inline) would make the tracing invariant more robust.

Overall, the architecture and tests are strong; the points above are primarily about tracing reentrancy, a couple of performance optimizations, and defensive robustness.


Automated review by DeepSeek · deepseek-v4-pro · custom prompt · 43.0k in / 39.3k out · ~$0.21

@github-actions

Copy link
Copy Markdown

🤖 Gemini Code Review

This PR looks great. The separation of expiry decisions and credit returns on the deadline-service thread from user-code execution (wakers and payload destructors) on the elastic disposal pool is clean, well-isolated, and thoroughly verified.

A few highlights from the review:

  • Pool state machine & worker lifecycle (concurrency/src/reply/disposal.rs): The idle / starting / workers bookkeeping in State::needs_worker, submit, and run properly handles concurrent submissions racing with wait_timeout expirations (re-checking state.queue.is_empty() before retiring, notifying remaining idle workers on Take when items remain queued, and falling back to inline execution if OS thread spawning fails when workers == 0).
  • Scope unwind safety & TLS teardown (concurrency/src/reply/disposal.rs:142-171, 571-598): collect's Scope guard ensures already-collected wake-ups/drops are still submitted if a visit unwinds, and defer_as falls back to inline execution if invoked during thread-local destruction after BATCH is torn down.
  • Death-point ordering (concurrency/src/mailbox.rs:58-114): Re-checking DropFailures::held in DropFailures::settle on the disposal worker preserves R6 (callers answered before payloads dropped) when an owner begins exiting after hand-off.
  • Zero-cost fast paths (concurrency/src/reply/registry.rs:57-68, concurrency/src/reply/jobs.rs:1113-1115, concurrency/src/mailbox.rs:90-94): Avoiding hand-offs for non-Replied terminal slots, non-last Arc drops, and empty optional payloads keeps the common path free of unnecessary allocations/queueing.
  • Verification & tests (verification/tla/Disposal.tla, concurrency/tests/disposal_trace.rs, concurrency/tests/deadline_service.rs, concurrency/tests/reply_slot_loom.rs): The TLA+ model, trace validation, negative controls (including disposal.batch_serial), Loom test for expire_collect hand-off, and tasks/threads subprocess isolation tests provide strong coverage.

No issues found — approved.


Automated review by Gemini · gemini-4-argon · custom prompt · 45.6k in / 29.5k out · ~$0.39

@github-actions

Copy link
Copy Markdown

🤖 Kimi Code Review

Findings

  • concurrency/src/reply/jobs.rs:431-443 — emitter wakers are still disposed as a shared batch.
    wake_emitters moves the entire wakers vector into one disposal item and wakes each waker serially. If the first waker blocks, every later emitter waker is stuck behind it; because those wakers were never queued individually, the pool cannot start another worker to help. This recreates the shared-batch problem at job scope and weakens the stated blocking-waker isolation guarantee. Defer each waker as its own item, and add a regression test with two emitter wakers where the first blocks. slot.rs’s Wake::run similarly runs the main waker before all watchers in one item, so watchers are also serialized behind a blocking waker.

  • concurrency/src/reply/disposal.rs:342-375 — worker-spawn failure can strand queued items indefinitely.
    In start_worker, when spawning fails and state.workers > 0, the code leaves the queue untouched, assuming an existing worker will take it. However, needs_worker can request this spawn precisely because all existing workers are busy; if they are permanently blocked, no worker will return, no further notification is issued, and the queued wake-ups/payload drops remain stranded until some unrelated future submission or worker completion. The no-worker case drains inline, but this case silently loses progress. Handle spawn failure with an explicit retry/degraded-progress strategy rather than assuming an existing worker is runnable.

The expiry/credit ordering and the two-phase payload settle hold re-check otherwise look careful, and the Loom, integration, and trace-validation coverage is substantial.


Automated review by Kimi (Moonshot AI) · kimi-k3.1-pro · custom prompt · 40.0k in / 13.6k out · ~$0.22

@github-actions

Copy link
Copy Markdown

🤖 Grok Code Review

The disposal pool’s condvar protocol, the R6 hold recheck in settle, and credit-before-wake are sound, and the tests/model cover the intended isolation. A few correctness holes remain.

Last drop can still run on the deadline thread

defer_drop_arc (concurrency/src/reply/disposal.rs) uses Arc::into_inner and, on None, drops that Arc in place. That is racy:

  1. Service CAS sees strong > 1 and falls into Arc’s normal Drop.
  2. The other holder drops between that failed CAS and this decrement.
  3. The service thread performs the last decrement and runs T’s destructor inline, inside the visit.

collecting() only helps if that Drop goes back through defer/discard. A registry/job/Run drop that directly drops slots, wakers, or other fields does not. Always queue the Arc itself while collecting (defer_drop(arc)); a non-last ref is only an atomic decrement on a worker, and it removes the race. The same pattern is used for the registry, jobs, and Run.

Emitter wakes are one queue item

JobState::wake_emitters (concurrency/src/reply/jobs.rs) defers the entire waker list as a single closure. One blocking emitter waker stalls every other emitter of that job, which cuts against the per-caller isolation this PR claims. Hand off one waker per item, as expire does for slots.

A panicking worker permanently shrinks the pool

In run (disposal.rs), workers is incremented in needs_worker and decremented only on the idle-timeout retire path. run_item catches panics in the callback, but anything that panics outside that (start_worker’s tracing subscriber, trace recording, a catch_unwind miss) kills the thread after the item was already pop_front’d. The slot is then leaked for the process lifetime, and that item never runs. Use a scope guard that decrements workers, clears starting, and either requeues the current item or asks needs_worker again.

Wake latency on the expiry path

Transition and credit return stay on the service thread, but the caller is not woken until a worker runs. After KEEP_ALIVE (10s) the pool is empty, so the next timeout pays thread spawn plus scheduling before wake. That is a real regression versus inline wake for the common single-expiry case, and it is invisible to TimelyWake (model clock, not wall time). Consider keeping one warm worker, or spawning the first worker off the critical path.

collect drops an existing batch

collect does *batch.borrow_mut() = Some(Vec::new()), which drops any previous Vec<Item> without submit. Those closures are not run, so nested or re-entered visits lose wake-ups. There is only one call site today; a drop guard that submits the previous batch would make that safe.

Smaller notes

  • notify_parked still calls waker.wake() on the service thread. That is safe only while parked is exclusively the blocking-recv unpark waker; a user waker there restores the old stall.
  • At MAX_WORKERS, a callback that waits for a later disposal item can deadlock the pool (those items cannot start). Below the cap, Take starting the next worker before run_item avoids this.
  • wake_emitters / Run last-ref handling is otherwise in good shape, and discard_some correctly skips empty payloads so the steady path does not enqueue.

Automated review by Grok (xAI) · grok-4.7 · custom prompt · 44.1k in / 36.6k out · ~$0.31

@github-merge-queue
github-merge-queue Bot removed this pull request from the merge queue due to a conflict with the base branch Nov 18, 2026
The process-wide deadline thread now only decides expiry (terminal CAS,
credit return, job notification enqueue). Wakers, payload destructors and
last references it releases go to an elastic disposal pool, so a blocking
user destructor or waker in one actor no longer delays other actors'
deadlines.
…st-reference-only hand-off

Review follow-ups for the disposal pool: one blocking waker or destructor no longer holds back other items of the same visit (two callers of one actor); deferral after thread-local teardown runs inline instead of aborting; an unwinding visit submits what it collected; registry, job and run references are handed off only when they are the last; the 64-worker cap is logged; docs state where emit credits return.
…ype code

Fold the decision into Expirable::expire (it returns whether the last drop could run user code) and read only the slot word in one non-generic function, so the generic Slot code instantiated in callers' crates is unchanged. An extra per-type method had shifted LLVM's inlining of the tasks receive loop (+5.5% on async_ct_send).
@unbalancedparentheses
unbalancedparentheses added this pull request to the merge queue Nov 18, 2026
Merged via the queue into main with commit 05551d1 Nov 18, 2026
33 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant