quinjet 0.0.74

A fast, live, keyboard-first Git source-control interface for the terminal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use std::io::Write;
use std::time::{Duration, Instant};

use ratatui::Terminal;
use ratatui::backend::TestBackend;

use super::*;
use crate::git::diff::{ImageCell, ImageSide};
use crate::theme::{Appearance, Theme, ThemeName};
use crate::ui::image_diff::tests::{image_line, preview};
use crate::ui::image_diff::{ImageDrawState, PreparationFrame, Rect, draw_image_line};

#[test]
#[ignore = "release-mode synthetic native image frame timings"]
fn native_image_frame_benchmark() {
    let theme = Theme::new(ThemeName::Quinjet, Appearance::Dark);
    for (width, height) in [(1920, 1080), (3840, 2160)] {
        for protocol in [
            ImageProtocol::Kitty,
            ImageProtocol::Iterm2,
            ImageProtocol::Sixel,
        ] {
            IMAGE_PREPARATION.with(|preparation| {
                *preparation.borrow_mut() = ImagePreparation::default();
            });
            let mut image = preview(ImageSide::New);
            image.width = Some(width);
            image.height = Some(height);
            image.rows = 40;
            image.cells = vec![
                ImageCell {
                    upper: [255, 0, 0],
                    lower: [0, 0, 255]
                };
                80
            ];
            image.raster = Some(Arc::new(ImageRaster {
                width,
                height,
                rgba: (0..width * height)
                    .flat_map(|pixel| {
                        let [red, green, blue, _] = pixel.to_le_bytes();
                        [red, green, blue, 255]
                    })
                    .collect(),
            }));
            let rows = (0..image.rows)
                .map(|row| {
                    let mut image = image.clone();
                    image.row = row;
                    image_line(image)
                })
                .collect::<Vec<_>>();
            let mut terminal =
                Terminal::new(TestBackend::new(100, 44)).expect("benchmark terminal");
            let render = |frame: &mut ratatui::Frame<'_>| {
                let _images = PreparationFrame::begin();
                let mut state = ImageDrawState::new(true);
                for (offset, line) in rows.iter().enumerate() {
                    let row = u16::try_from(offset).expect("benchmark row");
                    draw_image_line(
                        frame,
                        Rect::new(0, row, 100, 1),
                        line,
                        44 - row,
                        &theme,
                        protocol,
                        &mut state,
                    );
                }
            };
            let started = Instant::now();
            let _frame = terminal.draw(render).expect("cold image frame");
            let cold = started.elapsed();
            IMAGE_PREPARATION.with(|preparation| {
                let mut preparation = preparation.borrow_mut();
                let completed = preparation
                    .encoder
                    .as_ref()
                    .expect("benchmark encoder")
                    .completed
                    .recv_timeout(Duration::from_secs(60))
                    .expect("prepared benchmark image");
                assert!(
                    preparation.accept(completed),
                    "benchmark image becomes native"
                );
            });
            let ready = started.elapsed();
            let _frame = terminal.draw(render).expect("initial native frame");
            assert!(
                terminal
                    .backend()
                    .buffer()
                    .cell((0, 0))
                    .expect("native image")
                    .symbol()
                    .contains('\x1b'),
                "benchmark measures prepared native images"
            );
            let mut frames = Vec::new();
            for _ in 0..20 {
                let started = Instant::now();
                let _frame = terminal.draw(render).expect("warm image frame");
                frames.push(started.elapsed());
            }
            frames.sort_unstable();
            let warm = frames.get(10).expect("median warm frame");
            writeln!(
                std::io::stdout(),
                "{width}x{height} {protocol:?} pending_us={} native_ready_us={} warm_median_us={}",
                cold.as_micros(),
                ready.as_micros(),
                warm.as_micros()
            )
            .expect("benchmark output");
        }
    }
    IMAGE_PREPARATION.with(|preparation| {
        *preparation.borrow_mut() = ImagePreparation::default();
    });
}