Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Speed up StreamingDiff::push_new part two (#57849)
Anthony Eidcbaf8e4d9d14
diff --git a/Cargo.lock b/Cargo.lockindex 8398ff00bde..10ad05d6611 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -242,6 +242,7 @@ dependencies = ["cloud_llm_client","collections","context_server",+ "criterion","ctor","db","editor",diff --git a/crates/agent/Cargo.toml b/crates/agent/Cargo.tomlindex 77a9cd33f42..f88d8286535 100644--- a/crates/agent/Cargo.toml+++ b/crates/agent/Cargo.toml@@ -82,6 +82,7 @@ agent_servers = { workspace = true, "features" = ["test-support"] }client = { workspace = true, "features" = ["test-support"] }clock = { workspace = true, "features" = ["test-support"] }context_server = { workspace = true, "features" = ["test-support"] }+criterion.workspace = truector.workspace = truedb = { workspace = true, "features" = ["test-support"] }editor = { workspace = true, "features" = ["test-support"] }@@ -106,3 +107,8 @@ theme = { workspace = true, "features" = ["test-support"] }unindent = { workspace = true }zlog.workspace = true++[[bench]]+name = "edit_file_tool"+harness = false+required-features = ["test-support"]diff --git a/crates/agent/benches/edit_file_tool.rs b/crates/agent/benches/edit_file_tool.rsnew file mode 100644index 00000000000..5a26d0a3d4d--- /dev/null+++ b/crates/agent/benches/edit_file_tool.rs@@ -0,0 +1,519 @@+use std::{+ future::Future,+ path::Path,+ sync::Arc,+ task::{Context, Poll},+};++use action_log::ActionLog;+use agent::{+ AgentTool, ContextServerRegistry, EditFileTool, EditFileToolInput, EditFileToolOutput,+ Templates, Thread, ToolCallEventStream, ToolInput,+};+use agent_settings::{AgentSettings, ToolRules};+use criterion::{+ BatchSize, BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main,+};+use futures::{pin_mut, task::noop_waker};+use gpui::{AppContext as _, BackgroundExecutor, Entity, TestAppContext, UpdateGlobal as _};+use language_model::fake_provider::FakeLanguageModel;+use project::{FakeFs, Project};+use prompt_store::ProjectContext;+use rand::{Rng as _, SeedableRng as _, rngs::StdRng};+use serde_json::{Value, json};+use settings::{Settings as _, SettingsStore};++const SEED: u64 = 0x5EED_5EED;+const OLD_TEXT_CHUNK_SIZE: usize = 512;+const NEW_TEXT_CHUNK_SIZE: usize = 512;++#[derive(Clone)]+struct EditFixture {+ name: &'static str,+ old_file_text: String,+ expected_file_text: String,+ old_text: String,+ new_text: String,+}++struct BenchmarkHarness {+ cx: Option<TestAppContext>,+ edit_tool: Option<Arc<EditFileTool>>,+ thread: Option<Entity<Thread>>,+ partial_payloads: Vec<Value>,+ final_payload: Value,+ expected_file_text: String,+}++impl Drop for BenchmarkHarness {+ fn drop(&mut self) {+ // Release our handles to the entities first.+ self.edit_tool.take();+ self.thread.take();++ if let Some(cx) = self.cx.take() {+ // `ActionLog` holds buffers strongly via `tracked_buffers`, and spawns a background+ // diff-maintenance task that also captures a strong `Entity<Buffer>`. Releasing the+ // last handle to the action log only marks its entity for deferred release; the+ // entity's value (and the buffer handles inside) is not actually dropped until+ // `flush_effects` runs `release_dropped_entities`. Even then, the cancelled task's+ // captured handle does not drop until the executor pumps the cancellation through.+ //+ // Without this two-step teardown, GPUI's test leak detector panics on+ // `TestAppContext` drop because the buffer still appears alive. See+ // `ActionLog::track_buffer_internal` and `LeakDetector::drop` in+ // `crates/gpui/src/app/entity_map.rs`.+ cx.update(|_| {});+ cx.executor().run_until_parked();+ cx.quit();+ }+ }+}++fn edit_file_tool_streaming(c: &mut Criterion) {+ let fixtures = fixtures();+ let mut group = c.benchmark_group("edit_file_tool_streaming");+ group.sample_size(10);++ for fixture in fixtures {+ group.throughput(Throughput::Bytes(fixture.new_text.len() as u64));+ group.bench_with_input(+ BenchmarkId::new(fixture.name, fixture.old_text.len()),+ &fixture,+ |bench, fixture| {+ bench.iter_batched(+ || setup_harness(fixture.clone()),+ |mut harness| {+ let output = run_streamed_edit(&mut harness);+ let EditFileToolOutput::Success { new_text, .. } = &output else {+ panic!("expected edit_file tool to succeed");+ };+ assert_eq!(new_text, &harness.expected_file_text);+ // Return the harness as part of the output so its teardown (which has+ // to pump the executor to release `Entity<Buffer>` handles captured by+ // background tasks) runs in criterion's drop phase after the timer has+ // stopped, rather than inside the timed region.+ (black_box(output), harness)+ },+ BatchSize::SmallInput,+ );+ },+ );+ }++ group.finish();+}++fn setup_harness(fixture: EditFixture) -> BenchmarkHarness {+ let mut cx = init_context();+ let executor = cx.executor();+ let (edit_tool, thread) = block_on_executor(+ &executor,+ setup_edit_tool(&mut cx, fixture.old_file_text.clone()),+ );+ let partial_payloads = streamed_partial_payloads(&fixture.old_text, &fixture.new_text);+ let final_payload = json!({+ "path": "root/src/workspace_snapshot.rs",+ "edits": [{+ "old_text": fixture.old_text,+ "new_text": fixture.new_text,+ }],+ });++ BenchmarkHarness {+ cx: Some(cx),+ edit_tool: Some(edit_tool),+ thread: Some(thread),+ partial_payloads,+ final_payload,+ expected_file_text: fixture.expected_file_text,+ }+}++fn init_context() -> TestAppContext {+ let cx = TestAppContext::single();+ cx.update(|cx| {+ let settings_store = SettingsStore::test(cx);+ cx.set_global(settings_store);+ SettingsStore::update_global(cx, |store: &mut SettingsStore, cx| {+ store.update_user_settings(cx, |settings| {+ settings+ .project+ .all_languages+ .defaults+ .ensure_final_newline_on_save = Some(false);+ });+ });++ let mut agent_settings = AgentSettings::get_global(cx).clone();+ agent_settings.tool_permissions.tools.insert(+ EditFileTool::NAME.into(),+ ToolRules {+ default: Some(settings::ToolPermissionMode::Allow),+ always_allow: vec![],+ always_deny: vec![],+ always_confirm: vec![],+ invalid_patterns: vec![],+ },+ );+ AgentSettings::override_global(agent_settings, cx);+ });+ cx+}++async fn setup_edit_tool(+ cx: &mut TestAppContext,+ file_text: String,+) -> (Arc<EditFileTool>, Entity<Thread>) {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ "/root",+ json!({+ "src": {+ "workspace_snapshot.rs": file_text,+ },+ }),+ )+ .await;++ let project = Project::test(fs, [Path::new("/root")], cx).await;+ let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());+ let context_server_registry =+ cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));+ let model = Arc::new(FakeLanguageModel::default());+ let thread = cx.new(|cx| {+ Thread::new(+ project.clone(),+ cx.new(|_cx| ProjectContext::default()),+ context_server_registry,+ Templates::new(),+ Some(model),+ cx,+ )+ });+ let action_log: Entity<ActionLog> =+ thread.read_with(cx, |thread, _cx| thread.action_log().clone());++ let edit_tool = Arc::new(EditFileTool::new(+ project,+ thread.downgrade(),+ action_log,+ language_registry,+ ));+ (edit_tool, thread)+}++fn run_streamed_edit(harness: &mut BenchmarkHarness) -> EditFileToolOutput {+ let (mut sender, input): (_, ToolInput<EditFileToolInput>) = ToolInput::test();+ for payload in &harness.partial_payloads {+ sender.send_partial(payload.clone());+ }+ sender.send_full(harness.final_payload.clone());++ let (event_stream, _event_rx) = ToolCallEventStream::test();+ let cx = harness+ .cx+ .as_ref()+ .expect("benchmark harness should have a cx");+ let task = cx.update(|cx| {+ harness+ .edit_tool+ .as_ref()+ .expect("benchmark harness should have an edit tool")+ .clone()+ .run(input, event_stream, cx)+ });++ let executor = harness+ .cx+ .as_ref()+ .expect("benchmark harness should have a cx")+ .executor();+ block_on_executor(&executor, task).unwrap()+}++fn block_on_executor<R>(executor: &BackgroundExecutor, future: impl Future<Output = R>) -> R {+ pin_mut!(future);+ let waker = noop_waker();+ let mut task_context = Context::from_waker(&waker);++ for _ in 0..10_000 {+ if let Poll::Ready(output) = future.as_mut().poll(&mut task_context) {+ return output;+ }+ executor.run_until_parked();+ }++ panic!("future did not complete while running edit_file_tool benchmark");+}++fn streamed_partial_payloads(old_text: &str, new_text: &str) -> Vec<Value> {+ let path = "root/src/workspace_snapshot.rs";+ let mut payloads = Vec::new();++ payloads.push(json!({ "path": path }));+ payloads.push(json!({ "path": path }));++ for old_end in chunk_ends(old_text, OLD_TEXT_CHUNK_SIZE) {+ payloads.push(json!({+ "path": path,+ "edits": [{ "old_text": &old_text[..old_end] }],+ }));+ }++ payloads.push(json!({+ "path": path,+ "edits": [{ "old_text": old_text, "new_text": "" }],+ }));++ for new_end in chunk_ends(new_text, NEW_TEXT_CHUNK_SIZE) {+ payloads.push(json!({+ "path": path,+ "edits": [{+ "old_text": old_text,+ "new_text": &new_text[..new_end],+ }],+ }));+ }++ payloads+}++fn chunk_ends(text: &str, chunk_size: usize) -> impl Iterator<Item = usize> + '_ {+ let mut end = 0;+ std::iter::from_fn(move || {+ if end == text.len() {+ return None;+ }++ end = (end + chunk_size).min(text.len());+ while !text.is_char_boundary(end) {+ end -= 1;+ }+ Some(end)+ })+}++fn fixtures() -> Vec<EditFixture> {+ vec![+ make_fixture(+ "tiny_function_rewrite",+ 2,+ EditPattern::LocalizedRewrite {+ start_line: 12,+ line_count: 6,+ },+ SEED,+ ),+ make_fixture(+ "small_function_rewrite",+ 5,+ EditPattern::LocalizedRewrite {+ start_line: 22,+ line_count: 12,+ },+ SEED + 1,+ ),+ make_fixture(+ "medium_many_small_changes",+ 8,+ EditPattern::ManySmallChanges { every_nth_line: 7 },+ SEED + 2,+ ),+ make_fixture(+ "medium_insertions",+ 8,+ EditPattern::InsertHelperBlocks { every_nth_line: 9 },+ SEED + 3,+ ),+ ]+}++enum EditPattern {+ LocalizedRewrite {+ start_line: usize,+ line_count: usize,+ },+ ManySmallChanges {+ every_nth_line: usize,+ },+ InsertHelperBlocks {+ every_nth_line: usize,+ },+}++fn make_fixture(+ name: &'static str,+ function_count: usize,+ pattern: EditPattern,+ seed: u64,+) -> EditFixture {+ let mut rng = StdRng::seed_from_u64(seed);+ let old_lines = random_rust_module(&mut rng, function_count);+ let edit_range = edit_range(&old_lines, &pattern);+ let old_text = old_lines[edit_range.clone()].join("\n");+ let mut new_lines = old_lines.clone();++ match pattern {+ EditPattern::LocalizedRewrite { .. } => {+ rewrite_local_block(&mut new_lines[edit_range.clone()], &mut rng)+ }+ EditPattern::ManySmallChanges { every_nth_line } => {+ rewrite_many_small_lines(&mut new_lines[edit_range.clone()], every_nth_line, &mut rng)+ }+ EditPattern::InsertHelperBlocks { every_nth_line } => {+ insert_helper_blocks(&mut new_lines, edit_range.clone(), every_nth_line, &mut rng)+ }+ }++ let new_text_end = edit_range.end + new_lines.len().saturating_sub(old_lines.len());+ let old_file_text = old_lines.join("\n");+ let expected_file_text = new_lines.join("\n");+ let new_text = new_lines[edit_range.start..new_text_end].join("\n");++ EditFixture {+ name,+ old_file_text,+ expected_file_text,+ old_text,+ new_text,+ }+}++fn edit_range(lines: &[String], pattern: &EditPattern) -> std::ops::Range<usize> {+ let mut range = match pattern {+ EditPattern::LocalizedRewrite {+ start_line,+ line_count,+ } => *start_line..(*start_line + *line_count).min(lines.len()),+ EditPattern::ManySmallChanges { .. } | EditPattern::InsertHelperBlocks { .. } => {+ 10..lines.len().saturating_sub(5)+ }+ };++ while range.end > range.start && lines[range.end - 1].is_empty() {+ range.end -= 1;+ }++ range+}++fn random_rust_module(rng: &mut StdRng, function_count: usize) -> Vec<String> {+ let mut lines = vec![+ "use anyhow::{Context as _, Result};".to_string(),+ "use collections::HashMap;".to_string(),+ "".to_string(),+ "#[derive(Clone, Debug)]".to_string(),+ "pub struct WorkspaceSnapshot {".to_string(),+ " buffers: HashMap<String, usize>,".to_string(),+ " version: usize,".to_string(),+ "}".to_string(),+ "".to_string(),+ "impl WorkspaceSnapshot {".to_string(),+ ];++ for function_index in 0..function_count {+ let function_name = identifier(rng, function_index);+ let argument_name = identifier(rng, function_index + 1_000);+ let local_name = identifier(rng, function_index + 2_000);+ let branch_name = identifier(rng, function_index + 3_000);+ let multiplier = rng.random_range(2..17);+ let offset = rng.random_range(1..128);++ lines.extend([+ format!(+ " pub fn {function_name}(&mut self, {argument_name}: usize) -> Result<usize> {{"+ ),+ format!(" let mut {local_name} = {argument_name}.saturating_mul({multiplier});"),+ format!(" if {local_name} % 2 == 0 {{"),+ format!(+ " {local_name} = {local_name}.saturating_add(self.version + {offset});"+ ),+ " } else {".to_string(),+ format!(" {local_name} = {local_name}.saturating_sub({offset});"),+ " }".to_string(),+ format!(" let {branch_name} = self.buffers.len().saturating_add({local_name});"),+ format!(" self.version = self.version.saturating_add({branch_name});"),+ format!(" Ok({branch_name})"),+ " }".to_string(),+ "".to_string(),+ ]);+ }++ lines.push("}".to_string());+ lines.push("".to_string());+ lines.push("pub fn normalize_path(path: &str) -> String {".to_string());+ lines.push(" path.replace('\\\\', \"/\")".to_string());+ lines.push("}".to_string());+ lines+}++fn rewrite_local_block(lines: &mut [String], rng: &mut StdRng) {+ for (line_index, line) in lines.iter_mut().enumerate() {+ let suffix = identifier(rng, line_index + 10_000);+ if line.contains("saturating_add") {+ *line = format!(+ " let {suffix} = self.version.checked_add({line_index}).context(\"version overflow\")?;"+ );+ } else if line.contains("saturating_sub") {+ *line = format!(+ " {suffix}.saturating_sub({});",+ rng.random_range(8..256)+ );+ } else if line.trim().is_empty() {+ *line =+ format!(" tracing::trace!(target: \"agent_bench\", value = {line_index});");+ } else {+ *line = format!("{line} // updated {suffix}");+ }+ }+}++fn rewrite_many_small_lines(lines: &mut [String], every_nth_line: usize, rng: &mut StdRng) {+ for (line_index, line) in lines.iter_mut().enumerate() {+ if line_index.is_multiple_of(every_nth_line) || line.trim().is_empty() {+ continue;+ }++ let suffix = identifier(rng, line_index + 20_000);+ *line = format!("{line} // audited {suffix}");+ }+}++fn insert_helper_blocks(+ lines: &mut Vec<String>,+ range: std::ops::Range<usize>,+ every_nth_line: usize,+ rng: &mut StdRng,+) {+ let mut line_index = range.start;+ while line_index < range.end.min(lines.len()) {+ if line_index.is_multiple_of(every_nth_line) && !lines[line_index].trim().is_empty() {+ let suffix = identifier(rng, line_index + 30_000);+ lines.splice(+ line_index..line_index,+ [+ format!(" let {suffix}_before = self.version;"),+ format!(" tracing::debug!(version = {suffix}_before);"),+ ],+ );+ line_index += 2;+ }+ line_index += 1;+ }+}++fn identifier(rng: &mut StdRng, salt: usize) -> String {+ const PARTS: &[&str] = &[+ "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "theta", "lambda", "sigma", "omega",+ ];+ format!(+ "{}_{}_{}",+ PARTS[rng.random_range(0..PARTS.len())],+ salt,+ rng.random_range(0..10_000)+ )+}++criterion_group!(benches, edit_file_tool_streaming);+criterion_main!(benches);diff --git a/crates/streaming_diff/src/streaming_diff.rs b/crates/streaming_diff/src/streaming_diff.rsindex 2205a1dec5e..6d455a236bd 100644--- a/crates/streaming_diff/src/streaming_diff.rs+++ b/crates/streaming_diff/src/streaming_diff.rs@@ -74,6 +74,20 @@ impl Matrix {self.cells[col * self.rows + row] = value;}++ fn adjacent_columns_mut(&mut self, current_col: usize) -> (&[f64], &mut [f64]) {+ if current_col == 0 || current_col >= self.cols {+ panic!("column out of bounds");+ }++ let current_col_start = current_col * self.rows;+ let previous_col_start = current_col_start - self.rows;+ let (before_current, current_and_after) = self.cells.split_at_mut(current_col_start);+ (+ &before_current[previous_col_start..current_col_start],+ &mut current_and_after[..self.rows],+ )+ }}impl Debug for Matrix {@@ -141,24 +155,27 @@ impl StreamingDiff {for j in self.new_text_ix + 1..=self.new.len() {self.current_equal_runs.fill(0);let relative_j = j - self.new_text_ix;-- self.scores- .set(0, relative_j, j as f64 * Self::INSERTION_SCORE);- for i in 1..=self.old.len() {- let insertion_score = self.scores.get(i, relative_j - 1) + Self::INSERTION_SCORE;- let deletion_score = self.scores.get(i - 1, relative_j) + Self::DELETION_SCORE;- let equality_score = if self.old[i - 1] == self.new[j - 1] {- let equal_run = self.previous_equal_runs[i - 1] + 1;- self.current_equal_runs[i] = equal_run;+ let new_char = self.new[j - 1];+ let old = &self.old;+ let previous_equal_runs = &self.previous_equal_runs;+ let current_equal_runs = &mut self.current_equal_runs;+ let (previous_scores, current_scores) = self.scores.adjacent_columns_mut(relative_j);++ current_scores[0] = j as f64 * Self::INSERTION_SCORE;+ for i in 1..=old.len() {+ let insertion_score = previous_scores[i] + Self::INSERTION_SCORE;+ let deletion_score = current_scores[i - 1] + Self::DELETION_SCORE;+ let equality_score = if old[i - 1] == new_char {+ let equal_run = previous_equal_runs[i - 1] + 1;+ current_equal_runs[i] = equal_run;let exponent = cmp::min(equal_run as i32 / 4, Self::MAX_EQUALITY_EXPONENT);- self.scores.get(i - 1, relative_j - 1) + Self::EQUALITY_BASE.powi(exponent)+ previous_scores[i - 1] + Self::EQUALITY_BASE.powi(exponent)} else {f64::NEG_INFINITY};- let score = insertion_score.max(deletion_score).max(equality_score);- self.scores.set(i, relative_j, score);+ current_scores[i] = insertion_score.max(deletion_score).max(equality_score);}std::mem::swap(&mut self.previous_equal_runs, &mut self.current_equal_runs);