Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Reduce unified exec output buffer allocations (#39712)

Tamir Duberstein4a942885c8b4
diff --git a/codex-rs/core/src/unified_exec/async_watcher.rs b/codex-rs/core/src/unified_exec/async_watcher.rs
index f846d15737..230eba3241 100644
--- a/codex-rs/core/src/unified_exec/async_watcher.rs
+++ b/codex-rs/core/src/unified_exec/async_watcher.rs
@@ -249,7 +249,7 @@ async fn process_chunk(
while let Some(prefix) = split_valid_utf8_prefix(pending) {
{
let mut guard = transcript.lock().await;
- guard.push_chunk(prefix.to_vec());
+ guard.push_chunk(&prefix);
}
if *emitted_deltas >= MAX_EXEC_OUTPUT_DELTAS_PER_CALL {
diff --git a/codex-rs/core/src/unified_exec/head_tail_buffer.rs b/codex-rs/core/src/unified_exec/head_tail_buffer.rs
index 8515beef26..0c9df7c1be 100644
--- a/codex-rs/core/src/unified_exec/head_tail_buffer.rs
+++ b/codex-rs/core/src/unified_exec/head_tail_buffer.rs
@@ -42,22 +42,52 @@ impl<const MAX_BYTES: usize> HeadTailBuffer<MAX_BYTES> {
/// Bytes are first added to the head until the head budget is full; any
/// remaining bytes are added to the tail, with older tail bytes being
/// dropped to preserve the tail budget.
- pub(crate) fn push_chunk(&mut self, chunk: Vec<u8>) {
- if chunk.is_empty() {
- return;
- }
- if MAX_BYTES == 0 {
- self.omitted_bytes = self.omitted_bytes.saturating_add(chunk.len());
- return;
- }
+ pub(crate) fn push_chunk(&mut self, chunk: &[u8]) {
+ let chunk = self.fill_head(chunk);
+ self.push_tail(chunk);
+ }
- // Fill the head budget first, then keep a capped tail.
- let remaining_head = Self::HEAD_BUDGET.saturating_sub(self.head.len());
- let head_len = remaining_head.min(chunk.len());
- if head_len > 0 {
- self.head.extend_from_slice(&chunk[..head_len]);
- }
- self.push_to_tail(&chunk[head_len..]);
+ /// Fill the stable prefix and return the bytes that did not fit.
+ fn fill_head<'a>(&mut self, chunk: &'a [u8]) -> &'a [u8] {
+ let Self {
+ head,
+ tail: _,
+ omitted_bytes: _,
+ } = self;
+
+ let remaining_head = Self::HEAD_BUDGET.saturating_sub(head.len());
+ // A shorter chunk fits entirely in the head.
+ let (chunk_head, chunk_tail) = chunk
+ .split_at_checked(remaining_head)
+ .unwrap_or((chunk, &[]));
+ head.extend_from_slice(chunk_head);
+ chunk_tail
+ }
+
+ /// Append bytes known not to belong in the head, keeping the newest tail bytes.
+ fn push_tail(&mut self, chunk: &[u8]) {
+ let Self {
+ head: _,
+ tail,
+ omitted_bytes,
+ } = self;
+
+ let remaining_tail = Self::TAIL_BUDGET.saturating_sub(tail.len());
+ let excess_tail = chunk.len().saturating_sub(remaining_tail);
+ *omitted_bytes = omitted_bytes.saturating_add(excess_tail);
+
+ // Discard old tail bytes first, then skip any excess incoming bytes.
+ let chunk = match excess_tail.checked_sub(tail.len()) {
+ None => {
+ tail.drain(..excess_tail);
+ chunk
+ }
+ Some(skip) => {
+ tail.clear();
+ &chunk[skip..]
+ }
+ };
+ tail.extend(chunk);
}
/// Return the retained output as a single byte vector.
@@ -95,45 +125,41 @@ impl<const MAX_BYTES: usize> HeadTailBuffer<MAX_BYTES> {
/// Append a later buffer with the same budget. This preserves the summary
/// of the original concatenated output, including its omission count.
- pub(crate) fn push_buffer(&mut self, mut buffer: Self) {
- self.push_chunk(std::mem::take(&mut buffer.head));
- self.push_chunk(buffer.tail.drain(..).collect());
- self.omitted_bytes = self.omitted_bytes.saturating_add(buffer.omitted_bytes);
- }
-
- fn push_to_tail(&mut self, chunk: &[u8]) {
- if chunk.is_empty() {
- return;
- }
- if Self::TAIL_BUDGET == 0 {
- self.omitted_bytes = self.omitted_bytes.saturating_add(chunk.len());
- return;
- }
-
- if chunk.len() >= Self::TAIL_BUDGET {
- // This single chunk is larger than the whole tail budget. Keep only the last
- // tail_budget bytes and drop everything else.
- let start = chunk.len().saturating_sub(Self::TAIL_BUDGET);
- let kept = &chunk[start..];
- let dropped = chunk.len().saturating_sub(kept.len());
+ pub(crate) fn push_buffer(&mut self, buffer: Self) {
+ let Self {
+ head,
+ tail,
+ omitted_bytes,
+ } = buffer;
+
+ self.omitted_bytes = self.omitted_bytes.saturating_add(omitted_bytes);
+
+ // Preserve an existing prefix; otherwise reuse the source head.
+ let overflow = if self.head.is_empty() {
+ self.head = head;
+ &[]
+ } else {
+ self.fill_head(&head)
+ };
+
+ // A full source tail displaces both the old tail and the unused source head.
+ if tail.len() == Self::TAIL_BUDGET {
self.omitted_bytes = self
.omitted_bytes
.saturating_add(self.tail.len())
- .saturating_add(dropped);
- self.tail.clear();
- self.tail.extend(kept);
- return;
- }
-
- self.tail.extend(chunk);
- self.trim_tail_to_budget();
- }
-
- fn trim_tail_to_budget(&mut self) {
- let excess = self.tail.len().saturating_sub(Self::TAIL_BUDGET);
- if excess > 0 {
- drop(self.tail.drain(..excess));
- self.omitted_bytes = self.omitted_bytes.saturating_add(excess);
+ .saturating_add(overflow.len());
+ self.tail = tail;
+ } else {
+ self.push_tail(overflow);
+ // An empty destination can take a partial source tail without copying it.
+ if self.tail.is_empty() {
+ self.tail = tail;
+ } else {
+ // A nonempty source tail means its head, and now ours, is full.
+ let (first, second) = tail.as_slices();
+ self.push_tail(first);
+ self.push_tail(second);
+ }
}
}
}
diff --git a/codex-rs/core/src/unified_exec/head_tail_buffer_tests.rs b/codex-rs/core/src/unified_exec/head_tail_buffer_tests.rs
index b8e78dc812..db1defb3c4 100644
--- a/codex-rs/core/src/unified_exec/head_tail_buffer_tests.rs
+++ b/codex-rs/core/src/unified_exec/head_tail_buffer_tests.rs
@@ -6,11 +6,11 @@ use pretty_assertions::assert_eq;
fn keeps_prefix_and_suffix_when_over_budget() {
let mut buf = HeadTailBuffer::<10>::default();
- buf.push_chunk(b"0123456789".to_vec());
+ buf.push_chunk(b"0123456789");
assert_eq!(buf.omitted_bytes(), 0);
// Exceeds max by 2; we should keep head+tail and omit the middle.
- buf.push_chunk(b"ab".to_vec());
+ buf.push_chunk(b"ab");
assert!(buf.omitted_bytes() > 0);
let rendered = String::from_utf8_lossy(&buf.to_bytes()).to_string();
@@ -25,30 +25,30 @@ fn keeps_prefix_and_suffix_when_over_budget() {
#[test]
fn max_bytes_zero_drops_everything() {
let mut buf = HeadTailBuffer::<0>::default();
- buf.push_chunk(b"abc".to_vec());
+ buf.push_chunk(b"abc");
assert_eq!(buf.retained_bytes(), 0);
assert_eq!(buf.omitted_bytes(), 3);
- assert_eq!(buf.to_bytes(), b"".to_vec());
+ assert_eq!(buf.to_bytes(), b"");
}
#[test]
fn head_budget_zero_keeps_only_last_byte_in_tail() {
let mut buf = HeadTailBuffer::<1>::default();
- buf.push_chunk(b"abc".to_vec());
+ buf.push_chunk(b"abc");
assert_eq!(buf.retained_bytes(), 1);
assert_eq!(buf.omitted_bytes(), 2);
- assert_eq!(buf.to_bytes(), b"c".to_vec());
+ assert_eq!(buf.to_bytes(), b"c");
}
#[test]
fn chunk_larger_than_tail_budget_keeps_only_tail_end() {
let mut buf = HeadTailBuffer::<10>::default();
- buf.push_chunk(b"0123456789".to_vec());
+ buf.push_chunk(b"0123456789");
// Tail budget is 5 bytes. This chunk should replace the tail and keep only its last 5 bytes.
- buf.push_chunk(b"ABCDEFGHIJK".to_vec());
+ buf.push_chunk(b"ABCDEFGHIJK");
let out = String::from_utf8_lossy(&buf.to_bytes()).to_string();
assert!(out.starts_with("01234"));
@@ -61,19 +61,19 @@ fn fills_head_then_tail_across_multiple_chunks() {
let mut buf = HeadTailBuffer::<10>::default();
// Fill the 5-byte head budget across multiple chunks.
- buf.push_chunk(b"01".to_vec());
- buf.push_chunk(b"234".to_vec());
- assert_eq!(buf.to_bytes(), b"01234".to_vec());
+ buf.push_chunk(b"01");
+ buf.push_chunk(b"234");
+ assert_eq!(buf.to_bytes(), b"01234");
// Then fill the 5-byte tail budget.
- buf.push_chunk(b"567".to_vec());
- buf.push_chunk(b"89".to_vec());
- assert_eq!(buf.to_bytes(), b"0123456789".to_vec());
+ buf.push_chunk(b"567");
+ buf.push_chunk(b"89");
+ assert_eq!(buf.to_bytes(), b"0123456789");
assert_eq!(buf.omitted_bytes(), 0);
// One more byte causes the tail to drop its oldest byte.
- buf.push_chunk(b"a".to_vec());
- assert_eq!(buf.to_bytes(), b"012346789a".to_vec());
+ buf.push_chunk(b"a");
+ assert_eq!(buf.to_bytes(), b"012346789a");
assert_eq!(buf.omitted_bytes(), 1);
}
@@ -82,8 +82,8 @@ fn empty_and_tiny_chunks_have_bounded_metadata() {
let mut buf = HeadTailBuffer::<10>::default();
for byte in b"0123456789ab" {
- buf.push_chunk(Vec::new());
- buf.push_chunk(vec![*byte]);
+ buf.push_chunk(&[]);
+ buf.push_chunk(&[*byte]);
}
assert_eq!(buf.retained_bytes(), 10);
diff --git a/codex-rs/core/src/unified_exec/mod_tests.rs b/codex-rs/core/src/unified_exec/mod_tests.rs
index 682d789983..f0362ebd80 100644
--- a/codex-rs/core/src/unified_exec/mod_tests.rs
+++ b/codex-rs/core/src/unified_exec/mod_tests.rs
@@ -1,4 +1,3 @@
-use super::head_tail_buffer::HeadTailBuffer;
use super::*;
use crate::codex_thread::BackgroundTerminalInfo;
use crate::environment_selection::TurnEnvironmentState;
@@ -322,34 +321,6 @@ async fn write_stdin(
.await
}
-#[test]
-fn push_chunk_preserves_prefix_and_suffix() {
- let mut buffer: HeadTailBuffer = Default::default();
- buffer.push_chunk(vec![b'a'; UNIFIED_EXEC_OUTPUT_MAX_BYTES]);
- buffer.push_chunk(vec![b'b']);
- buffer.push_chunk(vec![b'c']);
-
- assert_eq!(buffer.retained_bytes(), UNIFIED_EXEC_OUTPUT_MAX_BYTES);
- let snapshot = buffer.to_bytes();
- let head_bytes = UNIFIED_EXEC_OUTPUT_MAX_BYTES / 2;
- let tail_bytes = UNIFIED_EXEC_OUTPUT_MAX_BYTES - head_bytes;
- let expected = std::iter::repeat_n(b'a', head_bytes + tail_bytes - 2)
- .chain(b"bc".iter().copied())
- .collect::<Vec<_>>();
- assert_eq!(snapshot, expected);
-}
-
-#[test]
-fn head_tail_buffer_default_preserves_prefix_and_suffix() {
- let mut buffer: HeadTailBuffer = Default::default();
- buffer.push_chunk(vec![b'a'; UNIFIED_EXEC_OUTPUT_MAX_BYTES]);
- buffer.push_chunk(b"bc".to_vec());
-
- let rendered = buffer.to_bytes();
- assert_eq!(rendered.first(), Some(&b'a'));
- assert!(rendered.ends_with(b"bc"));
-}
-
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn unified_exec_persists_across_requests() -> anyhow::Result<()> {
skip_if_sandbox!(Ok(()));
diff --git a/codex-rs/core/src/unified_exec/process.rs b/codex-rs/core/src/unified_exec/process.rs
index fc93935ada..3793927eb4 100644
--- a/codex-rs/core/src/unified_exec/process.rs
+++ b/codex-rs/core/src/unified_exec/process.rs
@@ -29,6 +29,7 @@ use codex_utils_pty::ExecCommandSession;
use codex_utils_pty::ProcessSignal as PtyProcessSignal;
use codex_utils_pty::SpawnedPty;
+use super::UNIFIED_EXEC_OUTPUT_MAX_BYTES;
use super::UNIFIED_EXEC_OUTPUT_MAX_TOKENS;
use super::UnifiedExecError;
use super::head_tail_buffer::HeadTailBuffer;
@@ -56,11 +57,10 @@ pub(crate) struct NoopSpawnLifecycle;
impl SpawnLifecycle for NoopSpawnLifecycle {}
-pub(crate) type OutputBuffer = Arc<Mutex<HeadTailBuffer>>;
/// Shared output state exposed to polling and streaming consumers.
#[derive(Clone)]
-pub(crate) struct OutputHandles {
- pub(crate) output_buffer: OutputBuffer,
+pub(crate) struct OutputHandles<const MAX_BYTES: usize = UNIFIED_EXEC_OUTPUT_MAX_BYTES> {
+ pub(crate) output_buffer: Arc<Mutex<HeadTailBuffer<MAX_BYTES>>>,
pub(crate) output_notify: Arc<Notify>,
pub(crate) output_closed: Arc<AtomicBool>,
pub(crate) output_closed_notify: Arc<Notify>,
@@ -501,7 +501,7 @@ impl UnifiedExecProcess {
for chunk in chunks.into_iter().filter(|chunk| chunk.seq > last_seq) {
let bytes = chunk.chunk.into_inner();
let mut guard = output_buffer.lock().await;
- guard.push_chunk(bytes.clone());
+ guard.push_chunk(&bytes);
drop(guard);
let _ = output_tx.send(bytes);
output_notify.notify_waiters();
@@ -544,7 +544,7 @@ impl UnifiedExecProcess {
last_seq = chunk.seq;
let bytes = chunk.chunk.into_inner();
let mut guard = output_buffer.lock().await;
- guard.push_chunk(bytes.clone());
+ guard.push_chunk(&bytes);
drop(guard);
let _ = output_tx.send(bytes);
output_notify.notify_waiters();
@@ -605,7 +605,7 @@ impl UnifiedExecProcess {
match receiver.recv().await {
Ok(chunk) => {
let mut guard = output_buffer.lock().await;
- guard.push_chunk(chunk.clone());
+ guard.push_chunk(&chunk);
drop(guard);
let _ = output_tx.send(chunk);
output_notify.notify_waiters();
diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rs
index 9fd8b08a74..8edc5a5675 100644
--- a/codex-rs/core/src/unified_exec/process_manager.rs
+++ b/codex-rs/core/src/unified_exec/process_manager.rs
@@ -1315,11 +1315,11 @@ impl UnifiedExecProcessManager {
})
}
- pub(super) async fn collect_output_until_deadline(
- output: &OutputHandles,
+ pub(super) async fn collect_output_until_deadline<const MAX_BYTES: usize>(
+ output: &OutputHandles<MAX_BYTES>,
mut pause_state: Option<watch::Receiver<bool>>,
mut deadline: Instant,
- ) -> HeadTailBuffer {
+ ) -> HeadTailBuffer<MAX_BYTES> {
const POST_EXIT_CLOSE_WAIT_CAP: Duration = Duration::from_millis(50);
let OutputHandles {
@@ -1339,7 +1339,7 @@ impl UnifiedExecProcessManager {
&mut post_exit_deadline,
)
.await;
- let drained_output: HeadTailBuffer;
+ let drained_output: HeadTailBuffer<MAX_BYTES>;
let has_drained_output: bool;
let mut wait_for_output = None;
{
diff --git a/codex-rs/core/src/unified_exec/process_manager_tests.rs b/codex-rs/core/src/unified_exec/process_manager_tests.rs
index 4d3429e038..5c096ce7e9 100644
--- a/codex-rs/core/src/unified_exec/process_manager_tests.rs
+++ b/codex-rs/core/src/unified_exec/process_manager_tests.rs
@@ -283,7 +283,8 @@ fn initial_exec_yield_time_has_no_platform_floor() {
#[tokio::test]
async fn output_collection_stays_bounded_across_repeated_drains() {
- let output_buffer = Arc::new(tokio::sync::Mutex::new(HeadTailBuffer::default()));
+ let chunks: [&[u8]; 4] = [b"01234567", b"89ABCDEF", b"ghijklmnopq", b"rs"];
+ let output_buffer = Arc::new(tokio::sync::Mutex::new(HeadTailBuffer::<10>::default()));
let output_notify = Arc::new(Notify::new());
let output_closed = Arc::new(AtomicBool::new(false));
let output_closed_notify = Arc::new(Notify::new());
@@ -302,10 +303,8 @@ async fn output_collection_stays_bounded_across_repeated_drains() {
Instant::now() + Duration::from_secs(5),
);
let produce = async {
- for byte in [b'a', b'b', b'c'] {
- output_buffer.lock().await.push_chunk(
- vec![byte; crate::unified_exec::UNIFIED_EXEC_OUTPUT_MAX_BYTES],
- );
+ for chunk in chunks {
+ output_buffer.lock().await.push_chunk(chunk);
output_notify.notify_one();
tokio::time::timeout(Duration::from_secs(1), async {
loop {
@@ -326,30 +325,21 @@ async fn output_collection_stays_bounded_across_repeated_drains() {
};
let (collected, ()) = tokio::join!(collect, produce);
- let mut expected = HeadTailBuffer::default();
- for byte in [b'a', b'b', b'c'] {
- expected.push_chunk(vec![
- byte;
- crate::unified_exec::UNIFIED_EXEC_OUTPUT_MAX_BYTES
- ]);
+ let mut expected = HeadTailBuffer::<10>::default();
+ for chunk in chunks {
+ expected.push_chunk(chunk);
}
assert_eq!(collected, expected);
}
#[tokio::test]
async fn output_collection_preserves_omissions_from_drained_buffer() {
- let mut buffered_output = HeadTailBuffer::default();
- buffered_output.push_chunk(vec![
- b'a';
- crate::unified_exec::UNIFIED_EXEC_OUTPUT_MAX_BYTES
- ]);
- buffered_output.push_chunk(b"overflow".to_vec());
- let mut expected = HeadTailBuffer::default();
- expected.push_chunk(vec![
- b'a';
- crate::unified_exec::UNIFIED_EXEC_OUTPUT_MAX_BYTES
- ]);
- expected.push_chunk(b"overflow".to_vec());
+ let mut buffered_output = HeadTailBuffer::<10>::default();
+ buffered_output.push_chunk(&[b'a'; 10]);
+ buffered_output.push_chunk(b"overflow");
+ let mut expected = HeadTailBuffer::<10>::default();
+ expected.push_chunk(&[b'a'; 10]);
+ expected.push_chunk(b"overflow");
let output_buffer = Arc::new(tokio::sync::Mutex::new(buffered_output));
let output_notify = Arc::new(Notify::new());
let output_closed = Arc::new(AtomicBool::new(true));
@@ -435,10 +425,7 @@ async fn failed_initial_end_for_unstored_process_uses_fallback_output() {
};
let transcript = Arc::new(tokio::sync::Mutex::new(HeadTailBuffer::default()));
- transcript
- .lock()
- .await
- .push_chunk(b"PARTIAL_TRANSCRIPT".to_vec());
+ transcript.lock().await.push_chunk(b"PARTIAL_TRANSCRIPT");
emit_failed_initial_exec_end_if_unstored(
/*process_started_alive*/ false,