iris-ai
ea1f836bf9
The eleventh sweep, over the built-in bounds work in2ac0843. `Painter::size_hint` refused to answer for a bounded widget by returning above the diagnostics, so that read was neither a hint hit nor a miss and `hint_read` recorded nothing. It is a miss now, with the reason on it. The two `for axis in Axis::BOTH` loops that `draw_widget` grew, both writing `own_holds`, are one loop, and the comment about combining the ask's holds no longer sits between a comment and the code it describes. `Declared::from_axes` lost its only caller with `Widgets::declared_lens`; `Bounds::from_axes` and `SizeRule::declared` never had one. The scenario shrinker printed a rule with derived `Debug`, which is 130 characters an axis in a line that carries every ancestor, in the one function whose job is output a tree can be rebuilt from. It prints its parts again. `bounds_cost` invented three environment-reading spellings where four copies of one `env` helper already existed; there is now one, in `tests/rig`, and the four copies are gone. It also verified 128 regions inside its measured loop, which the other rigs deliberately do before theirs; that measured 0.65% of the total, and none of it is layout. The 250-window row with a 300 cap was built by two tests, and the one that still explained itself tested less; they are one. The half of `a_cap_attribute_narrows_the_widgets_box` that the wrapper's removal left without its deciding assertion is the allocator's path instead, which nothing at the root covered. Format, workspace clippy under -D warnings with and without layout-diagnostics, 206 ordinary and 210 diagnostic tests, 400 depth-5 trees warm against cold in 64.19s, and the cold dump byte-identical to2ac0843across all 34,986 boxes.
89 lines
3.3 KiB
Rust
89 lines
3.3 KiB
Rust
//! CPU comparison of a bounds attribute against the `MaxSize` wrapper it
|
|
//! replaced, using the same builder calls and the same geometry. The wrapper
|
|
//! is gone from this tree, so its side of the comparison is run by checking
|
|
//! out a commit that still has it: the fixture is written to build the same
|
|
//! way at both.
|
|
//!
|
|
//! MODE=cap FRAMES=2000 cargo test --release --test bounds_cost \
|
|
//! -- --ignored --nocapture
|
|
//!
|
|
//! `MODE` is `plain`, `exact` or `cap`; `REDRAW=1` marks every widget for
|
|
//! redraw each frame; `FRAMES` is how many resize frames to measure. Use
|
|
//! repeated `perf stat -e instructions:u` runs on the executable directly.
|
|
//! Process totals include the cold frame, so compare identical modes and
|
|
//! frame counts. Wall time on this machine is not a stable comparison.
|
|
|
|
mod rig;
|
|
|
|
use iris::{harness::Harness, prelude::*};
|
|
use rig::env;
|
|
|
|
/// The two widths the loop alternates. The cap of 80 binds at 300 and does
|
|
/// not at 100, so the measured frames cross it in both directions.
|
|
const WIDTHS: [i32; 2] = [100, 300];
|
|
|
|
#[test]
|
|
#[ignore = "instruction-count measurement"]
|
|
fn bounds_cost() {
|
|
let mode = env("MODE", "cap".to_string());
|
|
let redraw = env("REDRAW", 0_u8) != 0;
|
|
let frames = env("FRAMES", 2000_usize);
|
|
let mut h = Harness::new((300, 512));
|
|
let mut column = Span::empty(Dir::DOWN);
|
|
let mut leaves = Vec::new();
|
|
for _ in 0..128 {
|
|
let first = match mode.as_str() {
|
|
"plain" => rect(Color::RED).add_strong(&mut h.rsc).any(),
|
|
"exact" => rect(Color::RED).width(40).add_strong(&mut h.rsc).any(),
|
|
"cap" => rect(Color::RED).max_width(80).add_strong(&mut h.rsc).any(),
|
|
_ => panic!("unknown MODE {mode}"),
|
|
};
|
|
leaves.push(first.id());
|
|
let second = rect(Color::BLUE).add_strong(&mut h.rsc);
|
|
let row = Span {
|
|
children: vec![first, second],
|
|
dir: Dir::RIGHT,
|
|
gap: Px::ZERO,
|
|
};
|
|
column.push(row.height(4).add_strong(&mut h.rsc));
|
|
}
|
|
h.set_root(column);
|
|
let ids: Vec<_> = h.render.active.keys().copied().collect();
|
|
println!(
|
|
"mode={mode}, widgets={}, rule_bytes={}",
|
|
ids.len(),
|
|
std::mem::size_of::<SizeRule>()
|
|
);
|
|
// That the fixture measures what it says is checked on both sides of the
|
|
// crossing here rather than inside the measured loop, which is what the
|
|
// other rigs do. Per frame it measured only 0.65% of the total (5.780B
|
|
// against 5.743B instructions at MODE=cap, FRAMES=2000), but none of it
|
|
// is the layout the number is about.
|
|
for width in WIDTHS {
|
|
h.resize((width, 512));
|
|
h.frame();
|
|
let expected = match mode.as_str() {
|
|
"plain" => width / 2,
|
|
"exact" => 40,
|
|
"cap" => (width / 2).min(80),
|
|
_ => unreachable!("the mode was checked while building"),
|
|
};
|
|
for id in &leaves {
|
|
assert_eq!(h.region(id).unwrap().size().x, Px::from_int(expected));
|
|
}
|
|
println!(
|
|
"width {width}: first leaf {}",
|
|
h.region(&leaves[0]).unwrap()
|
|
);
|
|
}
|
|
for frame in 0..frames {
|
|
if redraw {
|
|
for &id in &ids {
|
|
h.rsc.widgets_mut().mark_for_redraw(id);
|
|
}
|
|
}
|
|
h.resize((WIDTHS[frame % WIDTHS.len()], 512));
|
|
h.frame();
|
|
}
|
|
}
|