perf(cmux-tui): the inline key write checks room with one kernel queue per connection and sends without a copy (#35413 s17ga) by lawrencecchen · Pull Request #35988 · manaflow-ai/cmux

lawrencecchen · 2026-11-05T01:24:51Z

Summary

The s17ga typing A/B for #35413 kept the S1 input lane off (STATUS 13245, 13254, 13302). The daemon part was worse with the lane on at p50: +0.016 ms against an OFF round-to-round spread of 0.009 ms, with both ON rounds above both OFF rounds. On one boundary for both arms (from the key's arrival at the daemon to its bytes on the host socket), the difference stays: +0.018 ms at p50. It is all in the key's write call on its own request thread: 0.019-0.020 ms at p50 with the inline write (#35872), against 0.005 ms for the old path's direct write. Both arms write the host socket on the request thread, so this is the inline write's own cost.

The inline write did three things the old direct write did not:

poll(POLLOUT, 0) before the send. On macOS it is needed: there a send with MSG_DONTWAIT on a blocking stream socket still waits for room (perf(cmux-tui): a key to an idle input port is written on its own turn, with no thread hand-off (#35413 A/B) #35872). But XNU's poll() opens a kernel event queue, registers a knote on the socket under the socket's lock, and frees both again on every call. Freeing the queue walks every knote of the process: the fd knote lists under the process's fd lock, then every hashed knote under the hash lock. The daemon holds one hashed EVFILT_PROC knote per host child, so this cost grows with the session's terminals.
Two heap copies of the key (Frame::new(payload.to_vec()), then encode_frame).
One send of the frame it had just built.

Now (terminal_host_runtime/shared/attachment/room_check.rs):

macOS: each host connection keeps one kernel event queue, with the socket's EVFILT_WRITE registered once, at its first key. A key reads it with kevent64(KEVENT_FLAG_IMMEDIATE): one call, no allocation, no sleep (a zero-timeout poll() also slept about 10 us when there was no room). The filter's data is the socket's free room; the key goes inline only when that holds the whole frame. EV_EOF or EV_ERROR is no room, so the key goes to the port and its reconnect path. A failed kqueue() falls back to poll(). The connection's attachment owns the queue and shares it with every route clone; it closes with the attachment (a reconnect makes a new attachment and a new queue). Closing the socket removes the registration, so a stale queue never reports room.
Linux: no check. MSG_DONTWAIT is honoured there, and a Unix stream socket takes a frame this small whole or not at all.
Every Unix target: the frame header is built on the stack (terminal_host_protocol::input_frame_header, pinned byte for byte to encode_frame's output by a test). The header and the key go out in one sendmsg of two iovecs, with no heap copy of the key.

The order rules, the 1 KB size limit and every fallback to the port are unchanged. The room check still runs under the connection's writer guard, so no other daemon writer can take the room before the send.

Testing

Focused command: cmux-ci run --class isolated --script scripts/ci/cmux-tui-rust-check.sh --os macos|linux --arg test --arg input_port_inline --ref SHA.

Review of 0fffc79 (SHIP, should-fix 1): the stalled-host test now ends with one more key after the host read everything: it must go inline (on macOS, the connection's queue reports room again after the socket was full). The header test covers Paste as well as Input. Head 058c3a2: macOS input_port_inline 6 of 6 (step f25adbd3739062d9b540f9e6), Linux 5 of 5 (step e1c696e6dc6436d3597240cb; the first Linux run died on a zig TLS fetch while building ghostty-vt-sys, so the same SHA ran again), Linux clippy -D warnings (step 076708c6cfd10fc2eca60557). Review of the delta: SHIP at 058c3a2 (receipt in the PR comments).
Red first: a_connections_keys_share_one_kernel_queue_for_their_room_check at 737b57c (the test only, on feat 539facd), macOS step a56f9142fa5dac3cc0a4e0a6: "100 keys to one connection opened 100 kernel event queues for their room checks: one per key".
Green at the head 0fffc79:
- input_port_inline 6 of 6 on macOS (step 4abaf6fbccc02d57fa8c01bd). These are the new queue test, the new header test (the_inline_frame_header_is_the_encoders_header) and perf(cmux-tui): a key to an idle input port is written on its own turn, with no thread hand-off (#35413 A/B) #35872's four tests, which include the stalled-host test (1000 keys into a host that reads nothing). Linux: 5 of 5 (step 2a4b1da9b1a6502c24ab1d5b; the queue test is macOS only).
- surface::tests::hosted 40 of 40 on macOS (step a08306a8069afa5a572d8403). Linux: 39 of 39 (step d9a428e849b4ddc077dd6a9c; the writer QoS test is macOS only).
- Clippy -D warnings: Linux (step 6f131964990a2bcfb4824ad7) and macOS (step 06cde7700e3fc85d59bf620f).
- Rust panic ratchet: passed (step 6b5038f18d6444bd0b167df5). The crash ratchet against feat is ok.
- Compile-check: CmuxNext, app and cmux-tui passed (job aeb287ae47362e0b23b82761).
- Compile-check at the review head 058c3a2: CmuxNext, app and cmux-tui passed (job 1d0c2ec5b2f168cf62352fb4).

Observed / Not run

Observed: the runs above, and a never-merge micro-benchmark on an idle fleet Mac (step 8ee692ca8659f49c9c816176; ns per call, p50). poll(POLLOUT, 0) 375, kevent64(IMMEDIATE) on a registered queue 167, Frame::new + encode_frame 42, a 33-byte send 1625. On an idle Mac this saves about 0.25 us per key. The same benchmark with 14 spinning threads and the measuring thread at user-interactive QoS (before the fix: step b9f9e486b09b70b51035d3b2; after: step fde1d207ce50ee8d1d22a4fc; different minis, so compare within a run): poll 416 ns, kevent64 208 ns at p50 in both runs. These benchmarks did not reproduce the A/B's 0.014 ms write-call difference: in the test process the lane-on write_bytes_replying is not slower than the lane-off one at p50 in either run. A cost that the test process does not have (never-merge macOS bench, step 9e2ae6e0d493356babb1a379): a zero-timeout poll() costs more the more kernel event registrations the process holds, because XNU's poll builds and tears down a kernel queue against the process's file table on every call. p50 375 ns with no other registrations, 1083 ns with 1024, 3584 ns with 4096. kevent64(IMMEDIATE) on a queue registered once stays at 208 ns at every count. The daemon's own count, read from the live app daemon under the L6 load (see below), is 264-266, not thousands; the benches below are at that count. In the after run, the tight 20,000-key loop sent most keys through the port (lane-on p50 83 ns: a queue push, no syscall), because the writer outran the reader and the port then stays busy; the paced test above shows that keys with room go inline.
Observed: the typing A/B s17ha on HEAD build e8291edc70fd5a9064248bd8 (this PR plus perf(cmux-tui-core): the input lane is the daemon's default; CMUX_TUI_RDS_INPUT=0 keeps the old path for one nightly (R-DAEMON-STATE S1.7) #35413), cmux21, OFF/ON/OFF/ON (STATUS 13405): the ON write call fell to 0.007 ms at p50 (OFF 0.005 ms; 0.019-0.020 ms before this PR), and stayed there in the 4 rounds of s17hb (STATUS 13496); daemon part and key-to-commit not worse by either rule. One flag from s17ha: echo gap max (one key per round) was higher in both ON rounds, 3.98 and 3.37 ms against 2.22 and 1.94 ms. The replication set s17hb (4 more rounds) settled it (STATUS 13496, 8 rounds): the OFF rounds reached 3.87 and 3.88 ms, pooled ON - OFF at max is +1.61 ms inside an OFF spread of 1.94 ms, and no layer is worse by the rule with the floor or the rule with no floor.
Observed: the daemon's real kernel event count, read without changes from the live app daemon under the L6 load (cmux21, build e8291edc, lskq and proc_pidinfo; rounds s17hb-1-off at 02:44Z and s17hp-head-1 at 03:20Z, the same in both): 264-266 knotes. 13-14 are on fds (highest fd 67-79). 250-253 are hashed, and 234-237 of them are EVFILT_PROC, one per host child, so the count grows with the session's terminals. 1052 open fds (768 sockets), highest fd 1095. The chief daemon holds 29. The daemon under that load runs 390-560 threads, 365k-388k Unix calls and 142k-149k context switches a second, at about 180% CPU (s17hp-head-2 at 03:41Z).
Observed: the knote bench rebuilt at that count in the test process (never-merge, step 4a530efa4a2276db2caa564e, p50 ns). poll(POLLOUT, 0): 791 warm, 6500 cold (the caches swept before each call). kevent64(IMMEDIATE): 208 warm, 1750 cold. So at the daemon's count the old check cost +0.58 us warm and +4.75 us cold per key. A knote list grown to the highest fd changes nothing (792 ns): the hashed knotes set the cost. With 1000 hashed knotes: +1.96 us warm, +23.9 us cold, so the old cost grows with the session size. The same shape with paced socket and EVFILT_USER threads at about the daemon's rates (398k Unix calls and 262k switches a second; step e7934de9e7d37a98dcf3461b): +1.58 us warm, +5.38 us cold; poll's p95 rose to 11.2 us against 1.5 us for kevent64.
Observed: the whole inline write before and after this PR, end to end, at that knote shape and under that paced load, with a host thread that reads the socket (never-merge, step 582752f33f1c775cf20b9cc3, 1000 keys per case, p50 / p95 ns). With the caches swept before each call (between two of the typist's keys the daemon makes about 50k calls): before 12583 / 24083, after 4584 / 9667, so +8.0 / +14.4 us per key. The room check is +5.3 / +12.5 us of that, the build and send (two copies and send against a stack header and sendmsg) +2.75 / +2.6 us. Warm (200 us apart): +2.0 / +8.2 us. Idle and cold: +5.9 / +6.3 us.
So, at the daemon's real knote count and at about its call rates, the bench explains about two thirds of what the A/B removed from the write call (12-13 us at p50, 20-22 us at p95), and the room check is most of it. The rest, about 4-5 us at p50, has no measured cause. The A/B's write call also holds work the bench does not have (the port lock, the route load, the flow records), and the real daemon runs 390-560 threads against the bench's 50.
Not run: the full cmux-tui suite at the head, and Windows (the inline write is Unix only; Windows does not change).

Performance

metric (s17 A/B, L6 load, cmux21)	before (s17ga, build 2ed758c7)	after (s17h, build e8291edc)	harness
write call p50/p95/p99 ms, ON	0.019-0.020 / 0.030-0.032 / 0.042-0.045 (OFF 0.005 / 0.008 / 0.019-0.020)	0.007 / 0.009-0.011 / 0.017-0.020 (OFF 0.005 / 0.007-0.009 / 0.015-0.017), s17ha + s17hb, 4 rounds each (STATUS 13496)	segments.py on the flow files
daemon part p50 ms, ON - OFF	+0.016 (OFF spread 0.009)	+0.006 (OFF spread 0.017), s17ha + s17hb (8 rounds)	ab_summary.py, STATUS 13245, 13496
poll(POLLOUT, 0) vs kevent64(IMMEDIATE) per key, p50 ns, against the process's kernel event registrations (0 / 1024 / 4096)	poll 375 / 1083 / 3584	kevent64 208 / 208 / 208	never-merge macOS bench, step 9e2ae6e0d493356babb1a379
the same at the live daemon's count (264 knotes, 250 hashed, 1041 fds), p50 ns, warm / cold	poll 791 / 6500	kevent64 208 / 1750	never-merge macOS bench, step 4a530efa4a2276db2caa564e
the same under paced load at about the daemon's call rates (398k calls/s, 262k switches/s), p50 / p95 ns, warm	poll 2000 / 11208	kevent64 417 / 1458	never-merge macOS bench, step e7934de9e7d37a98dcf3461b
whole inline write (room check, build, send), at the daemon's count and paced load, caches cold, p50 / p95 ns	12583 / 24083	4584 / 9667	never-merge macOS bench, step 582752f33f1c775cf20b9cc3

Counted on the live daemon: 264-266 knotes (250-253 hashed). At that count the bench gives +0.58 us warm and +4.75 us cold per key for the old check (step 4a530efa4a2276db2caa564e), about a third of the 12-13 us the write call lost. The whole old write against the new one, at that count and at about the daemon's call rates, with the caches cold: +8.0 us at p50 and +14.4 us at p95 (step 582752f33f1c775cf20b9cc3), about two thirds of what the A/B removed (12-13 / 20-22 us). The old room check alone is +5.3 / +12.5 us of that, and it grows with the hashed knotes (one per host child): +23.9 us cold at 1000. The rest has no measured cause.

Changelog

none (the input lane is on by default since #35413, which has the What's New highlight; this removes about 8-13 us per key on macOS, which no one can see)

Proof

No capture: daemon-only change with no UI. The typing A/B is reported on #35413.

…room check (#35413 s17ga; red on macOS) The s17ga typing A/B for #35413 (STATUS 13245, 13254) kept the S1 input lane off: daemon part p50 was +0.016 ms with ON, against an OFF round-to-round spread of 0.009 ms, with both ON rounds above both OFF rounds. The whole difference was the key's write call (daemon.send.write -> written): 0.019 and 0.020 ms at p50 with ON, 0.005 ms with OFF. The inline key write (#35872) checks for room with poll(POLLOUT, 0) before its send. On XNU each poll() opens a kernel event queue, registers a knote on the socket under the socket's lock, and frees both again (sys_generic.c poll_nocancel; the #35872 reviewer's note 3). The test sends 100 keys to one idle connection and counts the kernel event queues that their room checks opened, with a test-only per-thread counter at the room check. It fails on this code: 100 keys open 100 queues, one per key. macOS only (Linux's poll opens no queue).

… per connection and sends without a copy (#35413 s17ga) The test is the commit before this one (red on macOS: 100 keys to one connection opened 100 kernel event queues, one per key's room check). s17ga (STATUS 13245, 13254, 13302) kept the S1 input lane off. On one boundary for both arms, ON was worse at p50 beyond the OFF spread. The whole difference was the write call on the key's own request thread: 0.019-0.020 ms with the inline write, against 0.005 ms for the old path's direct write. The inline write did three things the old path did not: 1. poll(POLLOUT, 0) before the send. On XNU each poll() opens a kernel event queue, registers a knote under the socket lock and frees both. 2. Two heap copies of the key (Frame::new(payload.to_vec()), encode_frame). 3. One send of a frame it had just built. Now (terminal_host_runtime/shared/attachment/room_check.rs): - macOS: each host connection keeps one kernel event queue, with the socket's EVFILT_WRITE registered once at its first key. Each key reads it with kevent64(KEVENT_FLAG_IMMEDIATE): one call, no allocation, no sleep. The filter's data is the socket's free room; the key goes inline only when it holds the whole frame. EV_EOF or EV_ERROR is no room, so the key goes to the port and its reconnect path. A failed kqueue() falls back to poll(). The connection's attachment owns the queue and shares it with every route clone; it closes with the attachment, and a reconnect makes a new one. - Linux: no check. MSG_DONTWAIT is honoured, and a Unix stream socket takes a frame this small whole or not at all. - Every Unix target: the frame header is built on the stack (terminal_host_protocol::input_frame_header, pinned to encode_frame's output by the_inline_frame_header_is_the_encoders_header). The header and the key go out in one sendmsg of two iovecs, with no heap copy of the key. The order rules, the size limit and the fallbacks to the port are the same. The room check still runs under the connection's writer guard, so nothing takes the room before the send.

github-actions · 2026-11-05T01:25:05Z

cmux status _{(one comment, edited in place; each line is updated by the job that owns it)}

Review 058c3a2: HQ feed card · gallery before/after runs · checks

App of this head (app.zip, kept 1 day)

gh workflow run reload-build.yml -R manaflow-ai/cmux --ref feat-cmux-next -f tag=pr35988 -f ref=fix/p0-typing-s1-inline-write-cost -f platform=macos -f backend_mode=local

web and size checks: green

Shipped in:

cmux NEXT nightly 1.0.0-nightly.4198271655001 (2a1e13d383)

blacksmith-sh · 2026-11-05T01:33:39Z

Found 298 test failures on Blacksmith runners:

Failures

Test	View Logs
`main.DeveloperIdAppTests.test_download_prints_the_active_profile_only/` `test_download_prints_the_active_profile_only`	View Logs
`stubs: /System/Library/Frameworks/Security.framework/Versions/A/Security has no stub/` `Security has no stub`	View Logs
`stubs: CoreFoundation.tbd: install-name /System/Library/Frameworks/` `CoreFoundation.framework/Versions/A/CoreFoundation, missing 1: ['_CFRetain']/` `CoreFoundation, missing 1: ['_CFRetain']`	View Logs
`stubs: CoreFoundation.tbd: install-name /System/Library/Frameworks/` `CoreFoundation.framework/Versions/A/CoreFoundation, missing 1: ['_log2']/` `CoreFoundation, missing 1: ['_log2']`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='find-nightly-next-recovery')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='find-nightly-next-recovery')`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='pick-nightly-build-runner')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='pick-nightly-build-runner')`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='prepare-nightly-variant')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='prepare-nightly-variant')`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='prepare-nightly-variant-primary')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='prepare-nightly-variant-primary')`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='resolve-nightly-cmux-tui-client')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='resolve-nightly-cmux-tui-client')`	View Logs
`test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='resolve-nightly-ghostty-cli-helper')/` `test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet_pick (main.Night` `lyPooledRoutingTests.test_light_nightly_overflow_never_takes_blacksmith_without_a_fleet` `_pick) (job='resolve-nightly-ghostty-cli-helper')`	View Logs

...and 288 more test failures. View all on Blacksmith

^{Need help on this PR? Tag @codesmith-bot with what you need.}

…line again; the header test covers Paste (#35988 review) Review of #35988 (SHIP at 0fffc79), should-fix 1: no test sent a key after the socket was full and the host then read everything. On macOS that is the one state the per-connection room-check queue keeps between keys: if its write filter did not report room again, every later key on the connection would go to the port and nothing would say so. keys_to_a_host_that_stopped_reading_never_block_their_requests now ends by waiting for an idle port, holding the port's writer and sending one more key: it must reach the host inline. The order test uses the same pattern. Note 3: the_inline_frame_header_is_the_encoders_header also covers MessageKind::Paste, which reaches the inline write too.

…ote shape, warm and cold (#35988) The live app daemon under the L6 typing load (cmux21, build e8291edc, lskq and proc_pidinfo) holds 264-266 knotes: 13-14 on fds, 250-253 hashed (234-237 EVFILT_PROC, one per host child), and 1052 open fds. This bench builds that shape in the test process and times poll(POLLOUT, 0) against kevent64 (IMMEDIATE) on a queue registered once, warm and with the caches swept before each call. Fails on purpose so the step log shows the report.

…aemon's own call and switch rates (#35988) The live app daemon under the L6 load ran 390-560 threads, about 375k Unix calls and 145k context switches a second (proc_pidinfo, cmux21, build e8291edc). At its knote count alone, cold, poll() cost 4.75 us more than kevent64 (step 4a530efa4a2276db2caa564e), a third of the A/B difference. This bench adds socket ping-pong and EVFILT_USER wake threads paced to about those rates and times both calls warm and cold, idle and under that load.

…ter #35988 at the daemon's shape and load Times the old write (poll room check, two copies, send) against the new one (kevent64 on the connection's queue, stack header, one sendmsg) end to end, and each half alone, interleaved, warm and cold, idle and under paced socket and EVFILT_USER load, at the live daemon's knote shape, with a host thread that reads the socket. The knote-only benches explain about a third of the 12-13 us the A/B removed; this measures the rest of the path the same way. Fails on purpose so the step log shows the report.

lawrencecchen · 2026-11-05T04:11:17Z

Review (claude-reviewer-rds-cost): SHIP at 058c3a2

Independent review subagent of the delta 0fffc79..058c3a2 (test only: cmux-tui/crates/cmux-tui-core/src/surface/tests/input_port_inline.rs, +30 -16; no production code changed after the earlier SHIP at 0fffc79). No must-fix, no should-fix.

The new end of keys_to_a_host_that_stopped_reading_never_block_their_requests closes the earlier should-fix: on macOS it fails if the connection's room-check queue does not report room again after the socket was full (a key that went to the paused port would miss the 300 ms read). The pause cannot hang the test.
The header test covers MessageKind::Paste as well as Input.
Evidence at the head: macOS input_port_inline 6 of 6 (cmux-ci step f25adbd3739062d9b540f9e6), Linux 5 of 5 (step e1c696e6dc6436d3597240cb), Linux clippy -D warnings (step 076708c6cfd10fc2eca60557). No macOS clippy ran at this head; the macOS-only test did not change.
The 3 red checks (tooling-tests, nightly-guards / workflow-guard-tests / release-notary, nightly-guards / Guard status) are base reds: every feat-cmux-next push run of "cmux-next guards" from 02:05 to 02:42Z failed the same 3 jobs with the same text (example run 41955572079 at cebb5ac).

…inline-write cost) into fix/p0-typing-s1-8-delete-old-path

…ted_typing_surface without the lane argument S1.8 removed #35988 (179bb0f) added a_connections_keys_share_one_kernel_queue_for_their_room_check with hosted_typing_surface(name, true). S1.8 removed the lane argument, so the merged tree does not compile on Apple targets (the test is cfg(target_vendor = "apple"), so the Linux steps cannot see it). The call drops the argument; the test is unchanged otherwise.

lawrencecchen added 2 commits November 5, 2026 01:00

lawrencecchen added the risk:normal Risk tier (docs/ci/risk-tiers.md) label Nov 5, 2026

lawrencecchen mentioned this pull request Nov 5, 2026

perf(cmux-tui-core): the input lane is the daemon's default; CMUX_TUI_RDS_INPUT=0 keeps the old path for one nightly (R-DAEMON-STATE S1.7) #35413

Merged

lawrencecchen temporarily deployed to ci-routing-agent November 5, 2026 02:30 — with GitHub Actions Inactive

lawrencecchen temporarily deployed to sentry-dsyms November 5, 2026 02:42 — with GitHub Actions Inactive

lawrencecchen temporarily deployed to artifacts November 5, 2026 02:42 — with GitHub Actions Inactive

lawrencecchen temporarily deployed to artifacts November 5, 2026 02:44 — with GitHub Actions Inactive

lawrencecchen added the ready-to-land Reviewed at this head; next-autoland merges it into feat-cmux-next when its only reds are base reds label Nov 5, 2026

lawrencecchen merged commit 179bb0f into feat-cmux-next Nov 5, 2026
235 of 243 checks passed

lawrencecchen deleted the fix/p0-typing-s1-inline-write-cost branch November 5, 2026 04:39

lawrencecchen mentioned this pull request Nov 5, 2026

cmux-tui-core: delete the S1 input lane switch, the old locked key path, the kept terminal and the route generations (R-DAEMON-STATE S1.8) #36197

Open

lawrencecchen added a commit that referenced this pull request Nov 5, 2026

Merge feat-cmux-next (186c74f: the nightly with S1.7 shipped, #35988 …

dcdd016

…inline-write cost) into fix/p0-typing-s1-8-delete-old-path

Navigation Menu

Repository navigation

perf(cmux-tui): the inline key write checks room with one kernel queue per connection and sends without a copy (#35413 s17ga) - #35988

perf(cmux-tui): the inline key write checks room with one kernel queue per connection and sends without a copy (#35413 s17ga)#35988
lawrencecchen merged 3 commits into
feat-cmux-nextfrom
fix/p0-typing-s1-inline-write-cost

lawrencecchen commented Nov 5, 2026 •

edited

Loading

Uh oh!

github-actions Bot commented Nov 5, 2026 •

edited

Loading

Uh oh!

blacksmith-sh Bot commented Nov 5, 2026 •

edited

Loading

Uh oh!

lawrencecchen commented Nov 5, 2026

Uh oh!

Uh oh!

This branch was previously deployed

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

lawrencecchen commented Nov 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Testing

Observed / Not run

Performance

Changelog

Proof

Uh oh!

github-actions Bot commented Nov 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

blacksmith-sh Bot commented Nov 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Failures

Uh oh!

lawrencecchen commented Nov 5, 2026

Uh oh!

Uh oh!

This branch was previously deployed

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

lawrencecchen commented Nov 5, 2026 •

edited

Loading

github-actions Bot commented Nov 5, 2026 •

edited

Loading

blacksmith-sh Bot commented Nov 5, 2026 •

edited

Loading