`73c634b`

perf: write-combine pty stdout chunks before ipc emit

Authored by

espadonne 1 month ago

SHA: 73c634b03a87a8ad18651af953b901cf63719ae7
Parents: 8378ba8
Tree: 06fd225

1 changed file

Status	File	+	-
M	`src-tauri/src/commands.rs`	53	15

src-tauri/src/commands.rsmodified

          },
      );
 -    // Forwarder task: base64-encode each chunk off `data_rx` and emit
 -    // a per-PTY event named `pty:data:<pty_id>`. Per-PTY events
 -    // avoid the O(N) fan-out that the previous single `pty:data`
 -    // channel had — every TerminalPane subscribes only to events
 -    // for its own ptyId, so one PTY's stdout chunk doesn't wake up
 -    // every listener in the webview.
 +    // Forwarder task: write-combines stdout chunks off `data_rx`
 +    // into ~frame-sized batches and emits them on a per-PTY event
 +    // `pty:data:<pty_id>`. Write combining matters because:
      //
 -    // When `data_rx` closes (reader task hit EOF), wait on
 -    // `exit_rx` for the final exit code and emit `pty:exit`
 -    // (globally, since the store subscribes to it to clean up
 -    // `ptyIds` and doesn't want to listen per-pty). Then remove
 -    // our entry from active_ptys — if close_pty already removed
 -    // it, the remove here is a harmless no-op.
 +    //   * Each emit is a Tauri IPC call that dispatches a DOM
 +    //     event on the webview's main thread.
 +    //   * Each frontend callback does base64 decode + `term.write`
 +    //     which is non-trivial main-thread work.
 +    //
 +    // Without coalescing, a claude TUI spinner + token stream
 +    // easily pushed 30-60 discrete chunks per second through the
 +    // bridge, stalling the main thread enough to beachball mouse
 +    // input. We now buffer up to `MAX_COALESCE_BYTES` or until
 +    // `MAX_COALESCE_MS` elapses since the first queued chunk,
 +    // whichever comes first.
 +    const MAX_COALESCE_BYTES: usize = 16 * 1024;
 +    const MAX_COALESCE_MS: u64 = 16;
++
      let app_clone = app.clone();
      let active_ptys = state.active_ptys.clone();
      let pid = pty_id.clone();
      let data_event = format!("pty:data:{pid}");
      tauri::async_runtime::spawn(async move {
 -        while let Some(chunk) = data_rx.recv().await {
 -            let b64 = BASE64_STANDARD.encode(&chunk);
 +        use std::time::Duration;
++
 +        let mut buffer: Vec<u8> = Vec::with_capacity(MAX_COALESCE_BYTES);
 +        loop {
 +            // Block for the first chunk of a batch. If the channel
 +            // has closed AND the buffer is empty, we're done.
 +            let first = match data_rx.recv().await {
 +                Some(chunk) => chunk,
 +                None => break,
 +            };
 +            buffer.extend_from_slice(&first);
++
 +            // Pull additional chunks until we hit the byte or time
 +            // budget. `try_recv` is non-blocking; `time::timeout`
 +            // on `recv` bounds the wait.
 +            let deadline = tokio::time::Instant::now()
 +                + Duration::from_millis(MAX_COALESCE_MS);
 +            while buffer.len() < MAX_COALESCE_BYTES {
 +                let now = tokio::time::Instant::now();
 +                if now >= deadline {
 +                    break;
 +                }
 +                let remaining = deadline - now;
 +                match tokio::time::timeout(remaining, data_rx.recv()).await {
 +                    Ok(Some(chunk)) => buffer.extend_from_slice(&chunk),
 +                    Ok(None) => {
 +                        // Sender closed — flush and exit after emit.
 +                        break;
 +                    }
 +                    Err(_) => break, // timeout elapsed
 +                }
 +            }
++
 +            let b64 = BASE64_STANDARD.encode(&buffer);
              let payload = PtyDataPayload {
                  pty_id: pid.clone(),
                  base64: b64,
              if let Err(err) = app_clone.emit(&data_event, &payload) {
                  tracing::warn!(error = %err, "failed to emit pty:data");
+             }
 +            buffer.clear();
+         }
 -        // data_rx closed — now block on the wait task's exit code.
 +        // data_rx closed — wait on the exit code and emit pty:exit.
          let exit_code = exit_rx.await.ok().flatten();
          let payload = PtyExitPayload {
              pty_id: pid.clone(),