Merge pull request #8355 from dotCooCoo/perf/ai-save-images-decode-once

.ai save: read each embedded image's pixels once a save
This commit is contained in:
BFlat
2026-11-18 12:56:04 +07:00
committed by GitHub
3 changed files with 267 additions and 13 deletions
+159
View File
@@ -4197,6 +4197,165 @@ fn images_that_cant_be_decoded_are_mid_gray_boxes() {
assert_eq!(paint(n.appearance.items[0].paint()), paint(&solid(Color::gray(0.5))));
}
/// A `w` × `h` RGB image whose pixels follow from `seed`, no two of its pixels gray.
fn seeded_png(seed: u32, (w, h): (u32, u32)) -> Vec<u8> {
let px = |x: u32, y: u32| {
let v = (x.wrapping_mul(73_856_093) ^ y.wrapping_mul(19_349_663) ^ seed.wrapping_mul(83_492_791)).to_le_bytes();
image::Rgb([v[0], v[1] | 1, v[2] & 0xfe])
};
png_of(image::DynamicImage::ImageRgb8(image::RgbImage::from_fn(w, h, px)))
}
/// A document placing `blobs` in turn on one layer, each `times` times: the first, the second and
/// so on, then the first again. Each blob is kept under `keys`' key at its index.
fn images_in_turn(blobs: &[ImageBlob], keys: &[&str], times: usize) -> Document {
let mut doc = Document::new(200.0, 100.0);
let layer = doc.layers[0].id;
for (blob, key) in blobs.iter().zip(keys) {
doc.images.insert((*key).to_string(), blob.clone());
}
for i in 0..times * blobs.len() {
let key = keys[i % blobs.len()].to_string();
let xf = Affine::translate((f64::from(u32::try_from(i).unwrap()), 10.0)) * Affine::scale(2.0);
let im = ImageObject { key, width: 4, height: 4, xf, link: None, placement: Default::default(), pixels: None };
let node = Node::new(doc.alloc_id(), NodeKind::Image(Box::new(im)));
doc.insert(Some(layer), usize::MAX, node).unwrap();
}
doc
}
/// `doc` written keeping the pixels of each image read (`last_only` false) or of the image read
/// last alone, and how many times an image's pixels were read.
fn export_reading(doc: &Document, last_only: bool) -> (AiEditingOutput, usize) {
writer::LAST_SAMPLES_ONLY.with(|l| l.set(last_only));
writer::SAMPLE_READS.with(|n| n.set(0));
let out = export_ai_editing(doc, &opts());
writer::LAST_SAMPLES_ONLY.with(|l| l.set(false));
(out.unwrap(), writer::SAMPLE_READS.with(std::cell::Cell::get))
}
/// `doc` written both ways ([`export_reading`]), the files and warnings compared whole, and the
/// reads of each way.
fn reads_for_the_same_file(doc: &Document) -> (usize, usize) {
let (kept, kept_reads) = export_reading(doc, false);
let (last, last_reads) = export_reading(doc, true);
assert!(kept.program == last.program, "the files differ");
assert_eq!(kept.header, last.header);
assert_eq!(kept.warnings, last.warnings);
(kept_reads, last_reads)
}
/// Two images placed one after the other 25 times each are each read once in a save, and the file
/// is the same as when only the image read last is kept.
#[test]
fn images_placed_in_turn_are_read_once_a_save() {
// GUARDS: each image was read again whenever the other was placed between its copies.
let blobs = [ImageBlob::png(seeded_png(1, (4, 4))), ImageBlob::png(seeded_png(2, (4, 4)))];
let doc = images_in_turn(&blobs, &["a", "b"], 25);
assert_eq!(reads_for_the_same_file(&doc), (2, 50));
let out = export_ai_editing(&doc, &opts()).unwrap();
assert_eq!(String::from_utf8_lossy(&out.program).matches("%AI5_BeginRaster").count(), 50);
}
/// A document of one image placed many times reads it once, and one without images reads none.
#[test]
fn one_image_is_read_once_and_no_image_never() {
let doc = images_in_turn(&[ImageBlob::png(seeded_png(3, (4, 4)))], &["a"], 10);
assert_eq!(reads_for_the_same_file(&doc), (1, 1));
assert_eq!(reads_for_the_same_file(&Document::new(200.0, 100.0)), (0, 0));
}
/// An image that can't be read, placed between copies of another, is read once too, and each copy
/// is still its gray outline with the same warning.
#[test]
fn an_image_that_cant_be_read_is_read_once_a_save() {
// GUARDS: an image that can't be read was read again whenever another image came between.
let blobs = [ImageBlob::png(b"not an image".to_vec()), ImageBlob::png(seeded_png(4, (4, 4)))];
let doc = images_in_turn(&blobs, &["bad", "good"], 3);
assert_eq!(reads_for_the_same_file(&doc), (2, 6));
let out = export_ai_editing(&doc, &opts()).unwrap();
assert_eq!(out.warnings, [writer::IMAGES]);
assert_eq!(String::from_utf8_lossy(&out.program).matches("%AI5_BeginRaster").count(), 3);
}
/// The same data under two MIME types is two images: each is read once, apart from the other.
#[test]
fn the_same_data_of_another_type_is_read_apart() {
let png = ImageBlob::png(seeded_png(5, (4, 4)));
let other = ImageBlob { mime: "image/x-other".into(), ..png.clone() };
assert!(Arc::ptr_eq(&png.bytes, &other.bytes));
let doc = images_in_turn(&[png, other], &["png", "other"], 3);
assert_eq!(reads_for_the_same_file(&doc), (2, 6));
}
/// Past the limits on the samples kept (bytes and images), an image is kept beside them in place
/// of the one before it, and the others are read again where they come: what is kept stays within
/// both limits, and the file is the same.
#[test]
fn images_past_the_limits_are_read_again_and_written_the_same() {
// Images of 48, 75 and 108 bytes of samples, then two of 48: 123 bytes and two images fit.
let sizes = [(4, 4), (5, 5), (6, 6), (4, 4), (4, 4)];
let blobs: Vec<_> = (0u32..).zip(sizes).map(|(i, s)| ImageBlob::png(seeded_png(10 + i, s))).collect();
let doc = images_in_turn(&blobs, &["a", "b", "c", "d", "e"], 3);
for (limits, kept_most, reads) in [((130, 8), (123, 2), 2 + 3 * 3), ((10_000, 3), (48 + 75 + 108, 3), 3 + 2 * 3)] {
writer::SAMPLE_LIMITS.with(|l| l.set(limits));
writer::SAMPLES_KEPT.with(|k| k.set((0, 0, false)));
let (kept_reads, last_reads) = reads_for_the_same_file(&doc);
let (bytes, images, beside) = writer::SAMPLES_KEPT.with(std::cell::Cell::get);
writer::SAMPLE_LIMITS.with(|l| l.set((256 << 20, 256)));
assert!(bytes <= limits.0 && images <= limits.1, "{limits:?}: kept {bytes} bytes of {images} images");
assert_eq!((bytes, images, beside), (kept_most.0, kept_most.1, true), "{limits:?}");
assert_eq!((kept_reads, last_reads), (reads, 15), "{limits:?}");
}
}
/// The time this thread has run, and how it was measured.
fn thread_time() -> (std::time::Duration, &'static str) {
if let Some(ns) = std::fs::read_to_string("/proc/thread-self/schedstat").ok().and_then(|s| s.split_whitespace().next()?.parse::<u64>().ok()) {
return (std::time::Duration::from_nanos(ns), "thread CPU time");
}
static START: std::sync::OnceLock<std::time::Instant> = std::sync::OnceLock::new();
(START.get_or_init(std::time::Instant::now).elapsed(), "wall-clock time")
}
/// The time to write two 2048 × 2048 images placed one after the other 25 times each, keeping the
/// pixels of each image read and of the image read last alone: the median of 7 runs of each,
/// alternating, with the files compared. Run with
/// `cargo test --release -p vectorcraft-eps --lib -- --ignored --nocapture images_placed_in_turn_are_written_quickly`.
#[test]
#[ignore = "timing"]
fn images_placed_in_turn_are_written_quickly() {
let blobs = [ImageBlob::png(seeded_png(1, (2048, 2048))), ImageBlob::png(seeded_png(2, (2048, 2048)))];
let doc = images_in_turn(&blobs, &["a", "b"], 25);
let mut times = [vec![], vec![]];
let mut files: [Option<Vec<u8>>; 2] = [None, None];
let mut reads = [0, 0];
let mut how = "";
for _ in 0..7 {
for (k, last_only) in [false, true].into_iter().enumerate() {
let (start, h) = thread_time();
let (out, n) = export_reading(&doc, last_only);
times[k].push(thread_time().0.saturating_sub(start));
how = h;
reads[k] = n;
files[k].get_or_insert(out.program);
}
}
assert!(files[0] == files[1], "the files differ");
assert_eq!(reads, [2, 50]);
for t in &mut times {
t.sort();
}
let ms = |d: std::time::Duration| d.as_secs_f64() * 1000.0;
println!("50 placements of two 2048 x 2048 images, median of 7 runs ({how}):");
println!("| pixels kept | images read | median (ms) | runs (ms) |");
println!("|---|---:|---:|---|");
for (k, label) in ["each image read", "the image read last"].into_iter().enumerate() {
let runs: Vec<String> = times[k].iter().map(|d| format!("{:.0}", ms(*d))).collect();
println!("| {label} | {} | {:.0} | {} |", reads[k], ms(times[k][3]), runs.join(", "));
}
}
#[test]
fn sixteen_bit_images_are_written_at_eight_bits() {
let mut doc = Document::new(200.0, 100.0);
+5 -5
View File
@@ -42,7 +42,7 @@ pub(super) use texts::wraps_held;
pub(super) use images::PAYLOAD;
#[cfg(test)]
pub(super) use images::{IMAGE_DEPTH, IMAGES, LINKS_EMBEDDED};
pub(super) use images::{IMAGE_DEPTH, IMAGES, LAST_SAMPLES_ONLY, LINKS_EMBEDDED, SAMPLE_LIMITS, SAMPLE_READS, SAMPLES_KEPT};
#[cfg(test)]
pub(super) use paints::{
GRADIENT_DITHER, GRADIENT_HUE, GRADIENT_PERCEPTUAL, GRADIENT_SHAPES, GRADIENTS, STOP_LINKS, SWATCH_PLACEMENT, free_gradient_name,
@@ -320,9 +320,9 @@ pub(super) struct Writer<'a> {
/// How many more envelopes and images with a Warp may be written live: as many as the reader
/// checks in one file ([`crate::import::ENVELOPE_CHECKS`]), which it spends on both.
checks_left: usize,
/// The image read last and its pixels ([`images::Samples::of`], `None` when they can't be
/// read): the pieces of a warped image, which follow one another, read them once.
last_samples: Option<(vectorcraft_doc::ImageBlob, Option<images::Read>)>,
/// The images read so far and their pixels: an image placed again, and each piece of a warped
/// image, is read once.
read_samples: images::SampleCache,
/// The images written whole so far, by the address of their data (which each entry keeps), each
/// with the index of its samples in [`Self::payloads`].
whole_images: HashMap<usize, (Arc<Vec<u8>>, usize)>,
@@ -422,7 +422,7 @@ impl<'a> Writer<'a> {
definition_links: 0,
definition_symbol_nodes: 0,
max_objects: crate::import::MAX_EDITING_OBJECTS,
last_samples: None,
read_samples: images::SampleCache::default(),
whole_images: HashMap::new(),
shown: vec![],
windowed: None,
+103 -8
View File
@@ -1,6 +1,9 @@
//! Images: embedded ones as a raster with its samples, linked ones as a placed file with a preview
//! (see [`crate::ai_editing`] for the form).
#[cfg(test)]
use std::cell::Cell;
use std::collections::HashMap;
use std::fmt::Write;
use std::sync::Arc;
@@ -30,6 +33,87 @@ pub(super) const SAMPLES_LINE: &str = "XI\u{1}";
/// An image's pixels as the data holds them, and whether it had 16 bits a channel ([`Samples::of`]).
pub(super) type Read = Arc<(Samples, bool)>;
/// The most bytes of samples a save keeps read ([`SampleCache`]): color and alpha together.
const KEPT_SAMPLE_BYTES: usize = 256 << 20;
/// The most images whose samples a save keeps read ([`SampleCache`]), those that can't be read
/// included.
const KEPT_IMAGES: usize = 256;
#[cfg(test)]
thread_local! {
/// How many times [`Samples::of`] has read an image on this thread.
pub(in crate::ai_editing) static SAMPLE_READS: Cell<usize> = const { Cell::new(0) };
/// Whether [`Writer::samples`] keeps only the image read last on this thread, to compare its
/// file with the one [`SampleCache`] gives.
pub(in crate::ai_editing) static LAST_SAMPLES_ONLY: Cell<bool> = const { Cell::new(false) };
/// The bytes of samples and the images [`SampleCache`] keeps at most on this thread.
pub(in crate::ai_editing) static SAMPLE_LIMITS: Cell<(usize, usize)> = const { Cell::new((KEPT_SAMPLE_BYTES, KEPT_IMAGES)) };
/// The most bytes of samples and images a [`SampleCache`] kept on this thread, and whether one
/// held an image beside them.
pub(in crate::ai_editing) static SAMPLES_KEPT: Cell<(usize, usize, bool)> = const { Cell::new((0, 0, false)) };
}
/// The bytes of samples and the images [`SampleCache`] keeps at most.
#[cfg(not(test))]
const fn sample_limits() -> (usize, usize) {
(KEPT_SAMPLE_BYTES, KEPT_IMAGES)
}
#[cfg(test)]
fn sample_limits() -> (usize, usize) {
SAMPLE_LIMITS.with(Cell::get)
}
/// The images read during a save and their pixels ([`Samples::of`], `None` when they can't be
/// read), so that an image placed again is read once: up to [`KEPT_IMAGES`] images and
/// [`KEPT_SAMPLE_BYTES`] of samples, and beside them the image read last that they have no room
/// for. An image is known by the address of its data and its MIME type; each entry keeps the
/// image, so no other data takes that address while the entry is kept.
#[derive(Default)]
pub(super) struct SampleCache {
/// By the address of the image's data, each image with that data and its pixels.
kept: HashMap<usize, Vec<(ImageBlob, Option<Read>)>>,
/// How many images `kept` holds.
images: usize,
/// The bytes of samples `kept` holds.
bytes: usize,
/// The image read last that `kept` had no room for, and its pixels.
last: Option<(ImageBlob, Option<Read>)>,
}
/// Whether `a` is the image `b`: the same data and MIME type.
fn same_image(a: &ImageBlob, b: &ImageBlob) -> bool {
Arc::ptr_eq(&a.bytes, &b.bytes) && a.mime == b.mime
}
impl SampleCache {
/// The pixels kept for `blob`, when it was read.
fn get(&self, blob: &ImageBlob) -> Option<Option<Read>> {
let kept = self.kept.get(&(Arc::as_ptr(&blob.bytes) as usize)).and_then(|v| v.iter().find(|(b, _)| same_image(b, blob)));
kept.or(self.last.as_ref().filter(|(b, _)| same_image(b, blob))).map(|(_, read)| read.clone())
}
/// Keep `read`, the pixels of `blob`: with the others while both limits allow, else beside them
/// in place of the image read last.
fn keep(&mut self, blob: &ImageBlob, read: Option<Read>) {
let size = read.as_deref().map_or(0, |(s, _)| s.color.len().saturating_add(s.alpha.as_ref().map_or(0, Vec::len)));
let (most_bytes, most_images) = sample_limits();
match self.bytes.checked_add(size).filter(|b| *b <= most_bytes) {
Some(bytes) if self.images < most_images => {
self.bytes = bytes;
self.images += 1;
self.kept.entry(Arc::as_ptr(&blob.bytes) as usize).or_default().push((blob.clone(), read));
}
_ => self.last = Some((blob.clone(), read)),
}
#[cfg(test)]
SAMPLES_KEPT.with(|k| {
let (b, n, last) = k.get();
k.set((b.max(self.bytes), n.max(self.images), last || self.last.is_some()));
});
}
}
/// A copy of an image written as the part of it that its regions show ([`Writer::image`]).
pub(super) struct Windowed {
/// Where its raster is in the body.
@@ -61,6 +145,8 @@ impl Samples {
/// or RGB samples, with an alpha channel when they need one. `None` when they can't be decoded or are more than
/// [`MAX_PIXELS`]; the flag is set when the image had 16 bits a channel.
fn of(blob: &ImageBlob) -> Option<(Samples, bool)> {
#[cfg(test)]
SAMPLE_READS.with(|n| n.set(n.get() + 1));
// The header's size is checked before the inks are decoded.
if blob.is_cmyk()
&& blob.header_size().is_some_and(|(w, h)| u64::from(w) * u64::from(h) <= MAX_PIXELS)
@@ -301,17 +387,26 @@ impl Writer<'_> {
);
}
/// The pixels of `blob` ([`Samples::of`]), read once for images that follow one another with
/// the same data.
/// The pixels of `blob` ([`Samples::of`]), read once in a save for each image the
/// [`SampleCache`] has room for.
fn samples(&mut self, blob: &ImageBlob) -> Option<Read> {
if let Some((last, read)) = &self.last_samples
&& Arc::ptr_eq(&last.bytes, &blob.bytes)
&& last.mime == blob.mime
{
return read.clone();
#[cfg(test)]
if LAST_SAMPLES_ONLY.with(Cell::get) {
if let Some((last, read)) = &self.read_samples.last
&& Arc::ptr_eq(&last.bytes, &blob.bytes)
&& last.mime == blob.mime
{
return read.clone();
}
let read = Samples::of(blob).map(Arc::new);
self.read_samples.last = Some((blob.clone(), read.clone()));
return read;
}
if let Some(read) = self.read_samples.get(blob) {
return read;
}
let read = Samples::of(blob).map(Arc::new);
self.last_samples = Some((blob.clone(), read.clone()));
self.read_samples.keep(blob, read.clone());
read
}