tenant.openagents/omega

1use benchmarks::bench_utils::random_rust_file;
2use gpui::{
3    AppContext as _, BenchAppContext, Context, Entity, IntoElement, Render, SharedString, Window,
4};
5use language::LanguageRegistry;
6use markdown::{
7    CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownFont,
8    MarkdownOptions, MarkdownStyle, WrapButtonVisibility,
9};
10use rand::{Rng as _, SeedableRng as _, rngs::StdRng};
11use settings::SettingsStore;
12use std::sync::Arc;
13use ui::prelude::*;
14
15const SEED: u64 = 1;
16
17#[gpui::bench(
18    inputs = markdown_sizes(),
19    group = "Markdown render",
20    input_name = "min_bytes",
21    sample_size = 10
22)]
23fn markdown_render(target_size: &usize, cx: &mut BenchAppContext) {
24    init_context(cx);
25
26    let source = SharedString::from(generate_markdown(SEED, *target_size));
27    let language_registry = markdown_language_registry(cx);
28
29    let mut window = cx.add_empty_window();
30    let view = window.update(|window, cx| {
31        let markdown = cx.new({
32            let source = source.clone();
33            let language_registry = language_registry.clone();
34            move |cx| build_markdown(source, language_registry, cx)
35        });
36        window.replace_root(cx, |_window, _cx| MarkdownBenchView { markdown })
37    });
38
39    cx.bench_renderer(view, |_, _, cx| cx.notify());
40}
41
42struct MarkdownBenchView {
43    markdown: Entity<Markdown>,
44}
45
46impl Render for MarkdownBenchView {
47    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
48        let style = MarkdownStyle::themed(MarkdownFont::Preview, window, cx);
49
50        div().w_full().h_full().child(
51            MarkdownElement::new(self.markdown.clone(), style).code_block_renderer(
52                CodeBlockRenderer::Default {
53                    copy_button_visibility: CopyButtonVisibility::VisibleOnHover,
54                    wrap_button_visibility: WrapButtonVisibility::VisibleOnHover,
55                    border: false,
56                },
57            ),
58        )
59    }
60}
61
62fn build_markdown(
63    source: SharedString,
64    language_registry: Arc<LanguageRegistry>,
65    cx: &mut Context<Markdown>,
66) -> Markdown {
67    Markdown::new_with_options(
68        source,
69        Some(language_registry),
70        None,
71        MarkdownOptions {
72            // Mermaid and embedded resources need their own focused benchmarks.
73            render_metadata_blocks: true,
74            ..Default::default()
75        },
76        cx,
77    )
78}
79
80fn generate_markdown(seed: u64, target_size: usize) -> String {
81    let mut rng = StdRng::seed_from_u64(seed);
82    let mut markdown = String::with_capacity(target_size);
83
84    markdown.push_str("---\n");
85    markdown.push_str("title: Markdown renderer benchmark\n");
86    markdown.push_str("author: Zed benchmark\n");
87    markdown.push_str("---\n\n");
88
89    while markdown.len() < target_size {
90        push_mixed_block(&mut markdown, &mut rng);
91    }
92
93    markdown
94}
95
96fn push_mixed_block(markdown: &mut String, rng: &mut StdRng) {
97    match rng.random_range(0..10) {
98        0 => push_heading(markdown, rng),
99        1 | 2 => push_paragraph(markdown, rng),
100        3 => push_list(markdown, rng),
101        4 => push_task_list(markdown, rng),
102        5 => push_table(markdown, rng),
103        6 | 7 => push_code_block(markdown, rng),
104        8 => push_block_quote(markdown, rng),
105        _ => push_rule(markdown),
106    }
107}
108
109fn push_heading(markdown: &mut String, rng: &mut StdRng) {
110    let level = rng.random_range(1..=4);
111    markdown.push_str(&"#".repeat(level));
112    markdown.push(' ');
113    let word_count = rng.random_range(3..8);
114    push_words(markdown, rng, word_count);
115    markdown.push_str("\n\n");
116}
117
118fn push_paragraph(markdown: &mut String, rng: &mut StdRng) {
119    let sentence_count = rng.random_range(2..7);
120    for sentence_index in 0..sentence_count {
121        if sentence_index > 0 {
122            markdown.push(' ');
123        }
124        push_sentence(markdown, rng);
125    }
126    markdown.push_str("\n\n");
127}
128
129fn push_sentence(markdown: &mut String, rng: &mut StdRng) {
130    let word_count = rng.random_range(8..24);
131    for word_index in 0..word_count {
132        if word_index > 0 {
133            markdown.push(' ');
134        }
135
136        match rng.random_range(0..18) {
137            0 => {
138                markdown.push_str("**");
139                markdown.push_str(random_word(rng));
140                markdown.push_str("**");
141            }
142            1 => {
143                markdown.push('*');
144                markdown.push_str(random_word(rng));
145                markdown.push('*');
146            }
147            2 => {
148                markdown.push('`');
149                markdown.push_str(random_identifier(rng));
150                markdown.push('`');
151            }
152            3 => {
153                markdown.push('[');
154                markdown.push_str(random_word(rng));
155                markdown.push_str("](https://example.com/");
156                markdown.push_str(random_identifier(rng));
157                markdown.push(')');
158            }
159            4 => {
160                markdown.push_str("https://zed.dev/");
161                markdown.push_str(random_identifier(rng));
162            }
163            _ => markdown.push_str(random_word(rng)),
164        }
165    }
166    markdown.push('.');
167}
168
169fn push_list(markdown: &mut String, rng: &mut StdRng) {
170    let item_count = rng.random_range(3..9);
171    let ordered = rng.random();
172    for item_index in 0..item_count {
173        if ordered {
174            markdown.push_str(&(item_index + 1).to_string());
175            markdown.push_str(". ");
176        } else {
177            markdown.push_str("- ");
178        }
179        let word_count = rng.random_range(5..14);
180        push_words(markdown, rng, word_count);
181        markdown.push('\n');
182    }
183    markdown.push('\n');
184}
185
186fn push_task_list(markdown: &mut String, rng: &mut StdRng) {
187    let item_count = rng.random_range(3..8);
188    for _ in 0..item_count {
189        if rng.random() {
190            markdown.push_str("- [x] ");
191        } else {
192            markdown.push_str("- [ ] ");
193        }
194        let word_count = rng.random_range(4..12);
195        push_words(markdown, rng, word_count);
196        markdown.push('\n');
197    }
198    markdown.push('\n');
199}
200
201fn push_table(markdown: &mut String, rng: &mut StdRng) {
202    let column_count = rng.random_range(3..7);
203    let row_count = rng.random_range(3..9);
204
205    for column_index in 0..column_count {
206        if column_index == 0 {
207            markdown.push('|');
208        }
209        markdown.push(' ');
210        markdown.push_str(random_word(rng));
211        markdown.push(' ');
212        markdown.push('|');
213    }
214    markdown.push('\n');
215
216    for column_index in 0..column_count {
217        if column_index == 0 {
218            markdown.push('|');
219        }
220        markdown.push_str(" --- |");
221    }
222    markdown.push('\n');
223
224    for _ in 0..row_count {
225        for column_index in 0..column_count {
226            if column_index == 0 {
227                markdown.push('|');
228            }
229            markdown.push(' ');
230            let word_count = rng.random_range(2..6);
231            push_words(markdown, rng, word_count);
232            markdown.push(' ');
233            markdown.push('|');
234        }
235        markdown.push('\n');
236    }
237    markdown.push('\n');
238}
239
240fn push_code_block(markdown: &mut String, rng: &mut StdRng) {
241    let line_count = rng.random_range(24..80);
242    let rust = random_rust_file(rng, line_count);
243    markdown.push_str("```rust\n");
244    markdown.push_str(&rust.join("\n"));
245    markdown.push_str("\n```\n\n");
246}
247
248fn push_block_quote(markdown: &mut String, rng: &mut StdRng) {
249    let line_count = rng.random_range(2..6);
250    for _ in 0..line_count {
251        markdown.push_str("> ");
252        push_sentence(markdown, rng);
253        markdown.push('\n');
254    }
255    markdown.push('\n');
256}
257
258fn push_rule(markdown: &mut String) {
259    markdown.push_str("---\n\n");
260}
261
262fn push_words(markdown: &mut String, rng: &mut StdRng, word_count: usize) {
263    for word_index in 0..word_count {
264        if word_index > 0 {
265            markdown.push(' ');
266        }
267        markdown.push_str(random_word(rng));
268    }
269}
270
271fn random_word(rng: &mut StdRng) -> &'static str {
272    const WORDS: &[&str] = &[
273        "renderer",
274        "layout",
275        "markdown",
276        "paragraph",
277        "heading",
278        "table",
279        "selection",
280        "syntax",
281        "highlight",
282        "window",
283        "element",
284        "callback",
285        "benchmark",
286        "profile",
287        "latency",
288        "throughput",
289        "scroll",
290        "wrapping",
291        "theme",
292        "language",
293        "fenced",
294        "blockquote",
295        "inline",
296        "content",
297    ];
298    choose(rng, WORDS)
299}
300
301fn random_identifier(rng: &mut StdRng) -> &'static str {
302    const IDENTIFIERS: &[&str] = &[
303        "markdown_renderer",
304        "layout_cache",
305        "rendered_text",
306        "source_range",
307        "bench_input",
308        "window_state",
309        "code_block",
310        "table_row",
311        "link_target",
312        "scroll_handle",
313        "text_style",
314        "root_block",
315    ];
316    choose(rng, IDENTIFIERS)
317}
318
319fn choose(rng: &mut StdRng, items: &'static [&'static str]) -> &'static str {
320    let index = rng.random_range(0..items.len());
321    items.get(index).copied().unwrap_or("markdown")
322}
323
324fn markdown_language_registry(cx: &BenchAppContext) -> Arc<LanguageRegistry> {
325    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
326    registry.add(language::rust_lang());
327    registry
328}
329
330fn init_context(cx: &mut BenchAppContext) {
331    cx.update(|cx| {
332        let store = SettingsStore::test(cx);
333        cx.set_global(store);
334        assets::Assets.load_test_fonts(cx);
335        theme_settings::init(theme::LoadThemes::JustBase, cx);
336    });
337}
338
339fn markdown_sizes() -> Vec<usize> {
340    let mut sizes = vec![5_000, 10_000, 50_000, 250_000];
341    if std::env::var("ZED_BENCH_HUGE").is_ok() {
342        sizes.push(1_000_000);
343    }
344    sizes
345}
346
347gpui::bench_group!(benches, markdown_render);
348gpui::bench_main!(benches);
349