Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
perf: Add initial benchmark for markdown element (#59524)
Anthony Eid6076ce27384c
diff --git a/Cargo.lock b/Cargo.lockindex 127c329710d..5dc2fed54f1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2151,6 +2151,7 @@ dependencies = ["language","language_model","lsp",+ "markdown","multi_buffer","project","prompt_store",diff --git a/crates/benchmarks/Cargo.toml b/crates/benchmarks/Cargo.tomlindex 5a62d0273d9..1db9acf391b 100644--- a/crates/benchmarks/Cargo.toml+++ b/crates/benchmarks/Cargo.toml@@ -12,6 +12,9 @@ doctest = false[lints]workspace = true+[dependencies]+rand.workspace = true+[dev-dependencies]action_log.workspace = trueagent = { workspace = true, features = ["test-support"] }@@ -26,10 +29,10 @@ itertools.workspace = truelanguage = { workspace = true, features = ["test-support"] }language_model = { workspace = true, features = ["test-support"] }lsp = { workspace = true, features = ["test-support"] }+markdown.workspace = truemulti_buffer.workspace = trueproject = { workspace = true, features = ["test-support"] }prompt_store.workspace = true-rand.workspace = trueserde_json.workspace = truesettings = { workspace = true, features = ["test-support"] }text.workspace = true@@ -50,3 +53,7 @@ harness = false[[bench]]name = "edit_file_tool"harness = false++[[bench]]+name = "markdown_renderer"+harness = falsediff --git a/crates/benchmarks/benches/edit_file_tool.rs b/crates/benchmarks/benches/edit_file_tool.rsindex 7080b01200e..a00add54ee3 100644--- a/crates/benchmarks/benches/edit_file_tool.rs+++ b/crates/benchmarks/benches/edit_file_tool.rs@@ -12,6 +12,10 @@ use agent::{Templates, Thread, ToolCallEventStream, ToolInput,};use agent_settings::{AgentSettings, ToolRules};+use benchmarks::bench_utils::{+ RUST_FUNCTION_BODY_LINES, RUST_FUNCTION_LINES, RUST_MODULE_HEADER_LINES, random_rust_file,+ rust_file_line_count, rust_identifier as identifier,+};use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main,};@@ -478,7 +482,7 @@ fn make_fixture(seed: u64,) -> EditFixture {let mut rng = StdRng::seed_from_u64(seed);- let old_lines = random_rust_module(&mut rng, function_count);+ let old_lines = random_rust_file(&mut rng, rust_file_line_count(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();@@ -514,12 +518,8 @@ fn make_large_multi_edit_fixture(edit_count: usize,seed: u64,) -> EditFixture {- const HEADER_LINES: usize = 10;- const FUNCTION_LINES: usize = 12;- const FUNCTION_BODY_LINES: usize = 11;-let mut rng = StdRng::seed_from_u64(seed);- let old_lines = random_rust_module(&mut rng, function_count);+ let old_lines = random_rust_file(&mut rng, rust_file_line_count(function_count));let old_file_text = old_lines.join("\n");let step = (function_count / edit_count).max(1);@@ -541,8 +541,8 @@ fn make_large_multi_edit_fixture(let edits = replacements.iter().map(|(function_index, new_function)| {- let start = HEADER_LINES + function_index * FUNCTION_LINES;- let end = start + FUNCTION_BODY_LINES;+ let start = RUST_MODULE_HEADER_LINES + function_index * RUST_FUNCTION_LINES;+ let end = start + RUST_FUNCTION_BODY_LINES;EditOp {old_text: old_lines[start..end].join("\n"),new_text: new_function.join("\n"),@@ -552,8 +552,8 @@ fn make_large_multi_edit_fixture(let mut new_lines = old_lines;for (function_index, new_function) in replacements.iter().rev() {- let start = HEADER_LINES + function_index * FUNCTION_LINES;- let end = start + FUNCTION_BODY_LINES;+ let start = RUST_MODULE_HEADER_LINES + function_index * RUST_FUNCTION_LINES;+ let end = start + RUST_FUNCTION_BODY_LINES;new_lines.splice(start..end, new_function.iter().cloned());}let expected_file_text = new_lines.join("\n");@@ -622,56 +622,6 @@ fn edit_range(lines: &[String], pattern: &EditPattern) -> std::ops::Range<usize>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);@@ -727,17 +677,5 @@ fn insert_helper_blocks(}}-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/benchmarks/benches/markdown_renderer.rs b/crates/benchmarks/benches/markdown_renderer.rsnew file mode 100644index 00000000000..7320bbd8099--- /dev/null+++ b/crates/benchmarks/benches/markdown_renderer.rs@@ -0,0 +1,348 @@+use benchmarks::bench_utils::random_rust_file;+use gpui::{+ AppContext as _, BenchAppContext, Context, Entity, IntoElement, Render, SharedString, Window,+};+use language::LanguageRegistry;+use markdown::{+ CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownFont,+ MarkdownOptions, MarkdownStyle, WrapButtonVisibility,+};+use rand::{Rng as _, SeedableRng as _, rngs::StdRng};+use settings::SettingsStore;+use std::sync::Arc;+use ui::prelude::*;++const SEED: u64 = 1;++#[gpui::bench(+ inputs = markdown_sizes(),+ group = "Markdown render",+ input_name = "min_bytes",+ sample_size = 10+)]+fn markdown_render(target_size: &usize, cx: &mut BenchAppContext) {+ init_context(cx);++ let source = SharedString::from(generate_markdown(SEED, *target_size));+ let language_registry = markdown_language_registry(cx);++ let mut window = cx.add_empty_window();+ let view = window.update(|window, cx| {+ let markdown = cx.new({+ let source = source.clone();+ let language_registry = language_registry.clone();+ move |cx| build_markdown(source, language_registry, cx)+ });+ window.replace_root(cx, |_window, _cx| MarkdownBenchView { markdown })+ });++ cx.bench_renderer(view, |_, _, cx| cx.notify());+}++struct MarkdownBenchView {+ markdown: Entity<Markdown>,+}++impl Render for MarkdownBenchView {+ fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ let style = MarkdownStyle::themed(MarkdownFont::Preview, window, cx);++ div().w_full().h_full().child(+ MarkdownElement::new(self.markdown.clone(), style).code_block_renderer(+ CodeBlockRenderer::Default {+ copy_button_visibility: CopyButtonVisibility::VisibleOnHover,+ wrap_button_visibility: WrapButtonVisibility::VisibleOnHover,+ border: false,+ },+ ),+ )+ }+}++fn build_markdown(+ source: SharedString,+ language_registry: Arc<LanguageRegistry>,+ cx: &mut Context<Markdown>,+) -> Markdown {+ Markdown::new_with_options(+ source,+ Some(language_registry),+ None,+ MarkdownOptions {+ // Mermaid and embedded resources need their own focused benchmarks.+ render_metadata_blocks: true,+ ..Default::default()+ },+ cx,+ )+}++fn generate_markdown(seed: u64, target_size: usize) -> String {+ let mut rng = StdRng::seed_from_u64(seed);+ let mut markdown = String::with_capacity(target_size);++ markdown.push_str("---\n");+ markdown.push_str("title: Markdown renderer benchmark\n");+ markdown.push_str("author: Zed benchmark\n");+ markdown.push_str("---\n\n");++ while markdown.len() < target_size {+ push_mixed_block(&mut markdown, &mut rng);+ }++ markdown+}++fn push_mixed_block(markdown: &mut String, rng: &mut StdRng) {+ match rng.random_range(0..10) {+ 0 => push_heading(markdown, rng),+ 1 | 2 => push_paragraph(markdown, rng),+ 3 => push_list(markdown, rng),+ 4 => push_task_list(markdown, rng),+ 5 => push_table(markdown, rng),+ 6 | 7 => push_code_block(markdown, rng),+ 8 => push_block_quote(markdown, rng),+ _ => push_rule(markdown),+ }+}++fn push_heading(markdown: &mut String, rng: &mut StdRng) {+ let level = rng.random_range(1..=4);+ markdown.push_str(&"#".repeat(level));+ markdown.push(' ');+ let word_count = rng.random_range(3..8);+ push_words(markdown, rng, word_count);+ markdown.push_str("\n\n");+}++fn push_paragraph(markdown: &mut String, rng: &mut StdRng) {+ let sentence_count = rng.random_range(2..7);+ for sentence_index in 0..sentence_count {+ if sentence_index > 0 {+ markdown.push(' ');+ }+ push_sentence(markdown, rng);+ }+ markdown.push_str("\n\n");+}++fn push_sentence(markdown: &mut String, rng: &mut StdRng) {+ let word_count = rng.random_range(8..24);+ for word_index in 0..word_count {+ if word_index > 0 {+ markdown.push(' ');+ }++ match rng.random_range(0..18) {+ 0 => {+ markdown.push_str("**");+ markdown.push_str(random_word(rng));+ markdown.push_str("**");+ }+ 1 => {+ markdown.push('*');+ markdown.push_str(random_word(rng));+ markdown.push('*');+ }+ 2 => {+ markdown.push('`');+ markdown.push_str(random_identifier(rng));+ markdown.push('`');+ }+ 3 => {+ markdown.push('[');+ markdown.push_str(random_word(rng));+ markdown.push_str("](https://example.com/");+ markdown.push_str(random_identifier(rng));+ markdown.push(')');+ }+ 4 => {+ markdown.push_str("https://zed.dev/");+ markdown.push_str(random_identifier(rng));+ }+ _ => markdown.push_str(random_word(rng)),+ }+ }+ markdown.push('.');+}++fn push_list(markdown: &mut String, rng: &mut StdRng) {+ let item_count = rng.random_range(3..9);+ let ordered = rng.random();+ for item_index in 0..item_count {+ if ordered {+ markdown.push_str(&(item_index + 1).to_string());+ markdown.push_str(". ");+ } else {+ markdown.push_str("- ");+ }+ let word_count = rng.random_range(5..14);+ push_words(markdown, rng, word_count);+ markdown.push('\n');+ }+ markdown.push('\n');+}++fn push_task_list(markdown: &mut String, rng: &mut StdRng) {+ let item_count = rng.random_range(3..8);+ for _ in 0..item_count {+ if rng.random() {+ markdown.push_str("- [x] ");+ } else {+ markdown.push_str("- [ ] ");+ }+ let word_count = rng.random_range(4..12);+ push_words(markdown, rng, word_count);+ markdown.push('\n');+ }+ markdown.push('\n');+}++fn push_table(markdown: &mut String, rng: &mut StdRng) {+ let column_count = rng.random_range(3..7);+ let row_count = rng.random_range(3..9);++ for column_index in 0..column_count {+ if column_index == 0 {+ markdown.push('|');+ }+ markdown.push(' ');+ markdown.push_str(random_word(rng));+ markdown.push(' ');+ markdown.push('|');+ }+ markdown.push('\n');++ for column_index in 0..column_count {+ if column_index == 0 {+ markdown.push('|');+ }+ markdown.push_str(" --- |");+ }+ markdown.push('\n');++ for _ in 0..row_count {+ for column_index in 0..column_count {+ if column_index == 0 {+ markdown.push('|');+ }+ markdown.push(' ');+ let word_count = rng.random_range(2..6);+ push_words(markdown, rng, word_count);+ markdown.push(' ');+ markdown.push('|');+ }+ markdown.push('\n');+ }+ markdown.push('\n');+}++fn push_code_block(markdown: &mut String, rng: &mut StdRng) {+ let line_count = rng.random_range(24..80);+ let rust = random_rust_file(rng, line_count);+ markdown.push_str("```rust\n");+ markdown.push_str(&rust.join("\n"));+ markdown.push_str("\n```\n\n");+}++fn push_block_quote(markdown: &mut String, rng: &mut StdRng) {+ let line_count = rng.random_range(2..6);+ for _ in 0..line_count {+ markdown.push_str("> ");+ push_sentence(markdown, rng);+ markdown.push('\n');+ }+ markdown.push('\n');+}++fn push_rule(markdown: &mut String) {+ markdown.push_str("---\n\n");+}++fn push_words(markdown: &mut String, rng: &mut StdRng, word_count: usize) {+ for word_index in 0..word_count {+ if word_index > 0 {+ markdown.push(' ');+ }+ markdown.push_str(random_word(rng));+ }+}++fn random_word(rng: &mut StdRng) -> &'static str {+ const WORDS: &[&str] = &[+ "renderer",+ "layout",+ "markdown",+ "paragraph",+ "heading",+ "table",+ "selection",+ "syntax",+ "highlight",+ "window",+ "element",+ "callback",+ "benchmark",+ "profile",+ "latency",+ "throughput",+ "scroll",+ "wrapping",+ "theme",+ "language",+ "fenced",+ "blockquote",+ "inline",+ "content",+ ];+ choose(rng, WORDS)+}++fn random_identifier(rng: &mut StdRng) -> &'static str {+ const IDENTIFIERS: &[&str] = &[+ "markdown_renderer",+ "layout_cache",+ "rendered_text",+ "source_range",+ "bench_input",+ "window_state",+ "code_block",+ "table_row",+ "link_target",+ "scroll_handle",+ "text_style",+ "root_block",+ ];+ choose(rng, IDENTIFIERS)+}++fn choose(rng: &mut StdRng, items: &'static [&'static str]) -> &'static str {+ let index = rng.random_range(0..items.len());+ items.get(index).copied().unwrap_or("markdown")+}++fn markdown_language_registry(cx: &BenchAppContext) -> Arc<LanguageRegistry> {+ let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));+ registry.add(language::rust_lang());+ registry+}++fn init_context(cx: &mut BenchAppContext) {+ cx.update(|cx| {+ let store = SettingsStore::test(cx);+ cx.set_global(store);+ assets::Assets.load_test_fonts(cx);+ theme_settings::init(theme::LoadThemes::JustBase, cx);+ });+}++fn markdown_sizes() -> Vec<usize> {+ let mut sizes = vec![5_000, 10_000, 50_000, 250_000];+ if std::env::var("ZED_BENCH_HUGE").is_ok() {+ sizes.push(1_000_000);+ }+ sizes+}++gpui::bench_group!(benches, markdown_render);+gpui::bench_main!(benches);diff --git a/crates/benchmarks/src/bench_utils.rs b/crates/benchmarks/src/bench_utils.rsnew file mode 100644index 00000000000..d35d76d708c--- /dev/null+++ b/crates/benchmarks/src/bench_utils.rs@@ -0,0 +1,89 @@+use rand::Rng;++pub const RUST_MODULE_HEADER_LINES: usize = 10;+pub const RUST_FUNCTION_LINES: usize = 12;+pub const RUST_FUNCTION_BODY_LINES: usize = 11;+pub const RUST_MODULE_FOOTER_LINES: usize = 5;++pub fn rust_file_line_count(function_count: usize) -> usize {+ RUST_MODULE_HEADER_LINES + function_count * RUST_FUNCTION_LINES + RUST_MODULE_FOOTER_LINES+}++pub fn random_rust_file(rng: &mut impl Rng, line_count: usize) -> Vec<String> {+ if line_count < RUST_MODULE_HEADER_LINES + RUST_MODULE_FOOTER_LINES {+ return (0..line_count)+ .map(|line_index| format!("// generated benchmark line {line_index}"))+ .collect();+ }++ 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(),+ ];++ let body_line_count = line_count - RUST_MODULE_HEADER_LINES - RUST_MODULE_FOOTER_LINES;+ let function_count = body_line_count / RUST_FUNCTION_LINES;+ let filler_line_count = body_line_count % RUST_FUNCTION_LINES;++ for function_index in 0..function_count {+ let function_name = rust_identifier(rng, function_index);+ let argument_name = rust_identifier(rng, function_index + 1_000);+ let local_name = rust_identifier(rng, function_index + 2_000);+ let branch_name = rust_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(),+ ]);+ }++ for filler_index in 0..filler_line_count {+ let filler_name = rust_identifier(rng, function_count + 4_000 + filler_index);+ lines.push(format!(" // benchmark filler {filler_name}"));+ }++ 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());++ debug_assert_eq!(lines.len(), line_count);+ lines+}++pub fn rust_identifier(rng: &mut impl Rng, 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)+ )+}diff --git a/crates/benchmarks/src/benchmarks.rs b/crates/benchmarks/src/benchmarks.rsindex 1b606305052..4c4134b5b94 100644--- a/crates/benchmarks/src/benchmarks.rs+++ b/crates/benchmarks/src/benchmarks.rs@@ -4,3 +4,5 @@//! (Criterion, `gpui_platform`, gpui's `bench` feature, ...) don't weigh down//! the test builds of the crates being benchmarked. Each file in `benches/`//! targets one area of the codebase.++pub mod bench_utils;diff --git a/crates/gpui/src/app/bench_context.rs b/crates/gpui/src/app/bench_context.rsindex 35d4144566f..3085776d702 100644--- a/crates/gpui/src/app/bench_context.rs+++ b/crates/gpui/src/app/bench_context.rs@@ -409,9 +409,14 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {}).expect("cannot benchmark renderer for entity without a current window");+ let dispatcher = self.background_executor.dispatcher().clone();let collector = FrameTraceScope::start();let mut benchmark = || {+ dispatcher+ .as_bench()+ .expect("validated in BenchAppContext::build")+ .run_ready_main_tasks();self.with_window(view.entity_id(), |window, cx| {view.update(cx, |view, cx| update(view, window, cx));})diff --git a/crates/gpui/src/platform/bench_dispatcher.rs b/crates/gpui/src/platform/bench_dispatcher.rsindex 91e4a27c82f..139434bd187 100644--- a/crates/gpui/src/platform/bench_dispatcher.rs+++ b/crates/gpui/src/platform/bench_dispatcher.rs@@ -258,6 +258,16 @@ impl BenchDispatcher {}}+ /// Runs all main-thread tasks that are queued right now, without waiting for+ /// background work or timers to finish.+ pub fn run_ready_main_tasks(&self) -> bool {+ assert!(+ self.is_main_thread(),+ "run_ready_main_tasks must be called on the benchmark main thread"+ );+ self.drain_main_queue()+ }+/// Cancels all pending timers so timers armed by one benchmark can't fire/// during a later benchmark sharing this process-lifetime dispatcher.///@@ -379,6 +389,38 @@ mod tests {use super::*;use crate::{BackgroundExecutor, ForegroundExecutor};+ #[test]+ fn run_ready_main_tasks_does_not_wait_for_background_handoffs() {+ let dispatcher = Arc::new(BenchDispatcher::new());+ let background = BackgroundExecutor::new(dispatcher.clone());+ let foreground = ForegroundExecutor::new(dispatcher.clone());++ let (sender, receiver) = futures::channel::oneshot::channel();+ background+ .spawn(async move {+ thread::sleep(Duration::from_millis(10));+ sender.send(()).ok();+ })+ .detach();++ let completed = Arc::new(AtomicBool::new(false));+ foreground+ .spawn({+ let completed = completed.clone();+ async move {+ receiver.await.ok();+ completed.store(true, Ordering::SeqCst);+ }+ })+ .detach();++ assert!(dispatcher.run_ready_main_tasks());+ assert!(!completed.load(Ordering::SeqCst));++ dispatcher.run_until_idle();+ assert!(completed.load(Ordering::SeqCst));+ }+#[test]fn run_until_idle_completes_background_to_main_handoffs() {let dispatcher = Arc::new(BenchDispatcher::new());