konevsa/typst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove layout cache

Browse Source
This commit is contained in:
Laurenz 2022-02-22 12:42:02 +01:00
parent c7e52f2048
commit 2bf32c51bc
26 changed files with 241 additions and 1096 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Cargo.lock generated
View File

@ -190,17 +190,6 @@ dependencies = [
"regex",
]
[[package]]
name = "filedescriptor"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7199d965852c3bac31f779ef99cbb4537f80e952e2d6aa0ffeb30cce00f4f46e"
dependencies = [
"libc",
"thiserror",
"winapi",
]
[[package]]
name = "flate2"
version = "1.0.22"
@ -779,26 +768,6 @@ dependencies = [
"winapi-util",
]
[[package]]
name = "thiserror"
version = "1.0.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "time"
version = "0.3.7"
@ -843,7 +812,6 @@ dependencies = [
"bytemuck",
"codespan-reporting",
"dirs",
"filedescriptor",
"flate2",
"fxhash",
"iai",

1
Cargo.toml
View File

@ -64,7 +64,6 @@ memmap2 = { version = "0.5", optional = true }
walkdir = { version = "2", optional = true }
[dev-dependencies]
filedescriptor = "0.8"
iai = { git = "https://github.com/reknih/iai" }
walkdir = "2"

185
src/layout/mod.rs → src/eval/layout.rs
View File

@ -1,22 +1,14 @@
//! Layouting infrastructure.
mod constraints;
mod incremental;
mod regions;
pub use constraints::*;
pub use incremental::*;
pub use regions::*;
use std::any::{Any, TypeId};
use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher};
use std::hash::Hash;
use std::sync::Arc;
use crate::diag::TypResult;
use crate::eval::StyleChain;
use crate::frame::{Element, Frame, Geometry, Shape, Stroke};
use crate::geom::{Align, Linear, Paint, Point, Sides, Size, Spec, Transform};
use crate::geom::{Align, Length, Linear, Paint, Point, Sides, Size, Spec, Transform};
use crate::library::{AlignNode, PadNode, TransformNode, MOVE};
use crate::util::Prehashed;
use crate::Vm;
@ -32,7 +24,7 @@ pub trait Layout {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>>;
) -> TypResult<Vec<Arc<Frame>>>;
/// Convert to a packed node.
fn pack(self) -> LayoutNode
@ -43,6 +35,102 @@ pub trait Layout {
}
}
/// A sequence of regions to layout into.
#[derive(Debug, Clone)]
pub struct Regions {
/// The (remaining) size of the first region.
pub first: Size,
/// The base size for relative sizing.
pub base: Size,
/// The height of followup regions. The width is the same for all regions.
pub backlog: std::vec::IntoIter<Length>,
/// The height of the final region that is repeated once the backlog is
/// drained. The width is the same for all regions.
pub last: Option<Length>,
/// Whether nodes should expand to fill the regions instead of shrinking to
/// fit the content.
pub expand: Spec<bool>,
}
impl Regions {
/// Create a new region sequence with exactly one region.
pub fn one(size: Size, base: Size, expand: Spec<bool>) -> Self {
Self {
first: size,
base,
backlog: vec![].into_iter(),
last: None,
expand,
}
}
/// Create a new sequence of same-size regions that repeats indefinitely.
pub fn repeat(size: Size, base: Size, expand: Spec<bool>) -> Self {
Self {
first: size,
base,
backlog: vec![].into_iter(),
last: Some(size.y),
expand,
}
}
/// Create new regions where all sizes are mapped with `f`.
///
/// Note that since all regions must have the same width, the width returned
/// by `f` is ignored for the backlog and the final region.
pub fn map<F>(&self, mut f: F) -> Self
where
F: FnMut(Size) -> Size,
{
let x = self.first.x;
Self {
first: f(self.first),
base: f(self.base),
backlog: self
.backlog
.as_slice()
.iter()
.map(|&y| f(Size::new(x, y)).y)
.collect::<Vec<_>>()
.into_iter(),
last: self.last.map(|y| f(Size::new(x, y)).y),
expand: self.expand,
}
}
/// Whether the first region is full and a region break is called for.
pub fn is_full(&self) -> bool {
Length::zero().fits(self.first.y) && !self.in_last()
}
/// Whether the first region is the last usable region.
///
/// If this is true, calling `next()` will have no effect.
pub fn in_last(&self) -> bool {
self.backlog.len() == 0 && self.last.map_or(true, |height| self.first.y == height)
}
/// Advance to the next region if there is any.
pub fn next(&mut self) {
if let Some(height) = self.backlog.next().or(self.last) {
self.first.y = height;
self.base.y = height;
}
}
/// An iterator that returns the sizes of the first and all following
/// regions, equivalently to what would be produced by calling
/// [`next()`](Self::next) repeatedly until all regions are exhausted.
/// This iterater may be infinite.
pub fn iter(&self) -> impl Iterator<Item = Size> + '_ {
let first = std::iter::once(self.first);
let backlog = self.backlog.as_slice().iter();
let last = self.last.iter().cycle();
first.chain(backlog.chain(last).map(|&h| Size::new(self.first.x, h)))
}
}
/// A type-erased layouting node with a precomputed hash.
#[derive(Clone, Hash)]
pub struct LayoutNode(Arc<Prehashed<dyn Bounds>>);
@ -136,41 +224,9 @@ impl Layout for LayoutNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
let styles = styles.barred(self.id());
let hash = {
let mut state = fxhash::FxHasher64::default();
self.hash(&mut state);
styles.hash(&mut state);
state.finish()
};
// This is not written with `unwrap_or_else`, because then the
// #[track_caller] annotation doesn't work.
if let Some(frames) = vm.layout_cache.get(hash, regions) {
Ok(frames)
} else {
vm.level += 1;
let frames = self.0.layout(vm, regions, styles)?;
vm.level -= 1;
let entry = FramesEntry::new(frames.clone(), vm.level);
#[cfg(debug_assertions)]
if !entry.check(regions) {
eprintln!("node: {:#?}", self.0);
eprintln!("regions: {regions:#?}");
eprintln!(
"constraints: {:#?}",
frames.iter().map(|c| c.cts).collect::<Vec<_>>(),
);
panic!("constraints did not match regions they were created for");
}
vm.layout_cache.insert(hash, entry);
Ok(frames)
}
) -> TypResult<Vec<Arc<Frame>>> {
// TODO(query)
self.0.layout(vm, regions, styles.barred(self.id()))
}
fn pack(self) -> LayoutNode {
@ -221,11 +277,10 @@ impl Layout for EmptyNode {
_: &mut Vm,
regions: &Regions,
_: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
let size = regions.expand.select(regions.current, Size::zero());
let mut cts = Constraints::new(regions.expand);
cts.exact = regions.current.filter(regions.expand);
Ok(vec![Frame::new(size).constrain(cts)])
) -> TypResult<Vec<Arc<Frame>>> {
Ok(vec![Arc::new(Frame::new(
regions.expand.select(regions.first, Size::zero()),
))])
}
}
@ -244,10 +299,7 @@ impl Layout for SizedNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
let is_auto = self.sizing.map_is_none();
let is_rel = self.sizing.map(|s| s.map_or(false, Linear::is_relative));
) -> TypResult<Vec<Arc<Frame>>> {
// The "pod" is the region into which the child will be layouted.
let pod = {
// Resolve the sizing to a concrete size.
@ -255,30 +307,25 @@ impl Layout for SizedNode {
.sizing
.zip(regions.base)
.map(|(s, b)| s.map(|v| v.resolve(b)))
.unwrap_or(regions.current);
.unwrap_or(regions.first);
// Select the appropriate base and expansion for the child depending
// on whether it is automatically or linearly sized.
let is_auto = self.sizing.map_is_none();
let base = is_auto.select(regions.base, size);
let expand = regions.expand | !is_auto;
Regions::one(size, base, expand)
};
// Layout the child.
let mut frames = self.child.layout(vm, &pod, styles)?;
let Constrained { item: frame, cts } = &mut frames[0];
// Ensure frame size matches regions size if expansion is on.
let target = regions.expand.select(regions.current, frame.size);
let frame = &mut frames[0];
let target = regions.expand.select(regions.first, frame.size);
Arc::make_mut(frame).resize(target, Align::LEFT_TOP);
// Set base & exact constraints if the child is automatically sized
// since we don't know what the child might have done. Also set base if
// our sizing is relative.
*cts = Constraints::new(regions.expand);
cts.exact = regions.current.filter(regions.expand | is_auto);
cts.base = regions.base.filter(is_rel | is_auto);
Ok(frames)
}
}
@ -298,9 +345,9 @@ impl Layout for FillNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut frames = self.child.layout(vm, regions, styles)?;
for Constrained { item: frame, .. } in &mut frames {
for frame in &mut frames {
let shape = Shape::filled(Geometry::Rect(frame.size), self.fill);
Arc::make_mut(frame).prepend(Point::zero(), Element::Shape(shape));
}
@ -323,9 +370,9 @@ impl Layout for StrokeNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut frames = self.child.layout(vm, regions, styles)?;
for Constrained { item: frame, .. } in &mut frames {
for frame in &mut frames {
let shape = Shape::stroked(Geometry::Rect(frame.size), self.stroke);
Arc::make_mut(frame).prepend(Point::zero(), Element::Shape(shape));
}

2
src/eval/mod.rs
View File

@ -12,6 +12,7 @@ mod capture;
mod class;
mod collapse;
mod func;
mod layout;
mod ops;
mod scope;
mod show;
@ -23,6 +24,7 @@ pub use class::*;
pub use collapse::*;
pub use dict::*;
pub use func::*;
pub use layout::*;
pub use scope::*;
pub use show::*;
pub use styles::*;

6
src/eval/template.rs
View File

@ -7,10 +7,10 @@ use std::ops::{Add, AddAssign};
use typed_arena::Arena;
use super::{
CollapsingBuilder, Interruption, Property, Show, ShowNode, StyleMap, StyleVecBuilder,
CollapsingBuilder, Interruption, Layout, LayoutNode, Property, Show, ShowNode,
StyleMap, StyleVecBuilder,
};
use crate::diag::StrResult;
use crate::layout::{Layout, LayoutNode};
use crate::library::prelude::*;
use crate::library::{
DecoNode, FlowChild, FlowNode, ListItem, ListKind, ListNode, PageNode, ParChild,
@ -240,7 +240,7 @@ impl Layout for Template {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let sya = Arena::new();
let tpa = Arena::new();

3
src/eval/value.rs
View File

@ -4,10 +4,9 @@ use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher};
use std::sync::Arc;
use super::{ops, Args, Array, Class, Dict, Func, Template};
use super::{ops, Args, Array, Class, Dict, Func, Layout, Template};
use crate::diag::StrResult;
use crate::geom::{Angle, Color, Fractional, Length, Linear, Relative, RgbaColor};
use crate::layout::Layout;
use crate::syntax::Spanned;
use crate::util::EcoString;

30
src/export/render.rs
View File

@ -1,6 +1,5 @@
//! Rendering into raster images.
use std::collections::{hash_map::Entry, HashMap};
use std::io::Read;
use image::{GenericImageView, Rgba};
@ -8,26 +7,12 @@ use tiny_skia as sk;
use ttf_parser::{GlyphId, OutlineBuilder};
use usvg::FitTo;
use crate::font::{Face, FaceId};
use crate::font::Face;
use crate::frame::{Element, Frame, Geometry, Group, Shape, Stroke, Text};
use crate::geom::{self, Length, Paint, PathElement, Size, Transform};
use crate::image::{Image, RasterImage, Svg};
use crate::Context;
/// Caches rendering artifacts.
#[derive(Default, Clone)]
pub struct RenderCache {
/// Glyphs prepared for rendering.
glyphs: HashMap<(FaceId, GlyphId), pixglyph::Glyph>,
}
impl RenderCache {
/// Create a new, empty rendering cache.
pub fn new() -> Self {
Self::default()
}
}
/// Export a frame into a rendered image.
///
/// This renders the frame at the given number of pixels per printer's point and
@ -131,7 +116,6 @@ fn render_text(
text: &Text,
) {
let face = ctx.fonts.get(text.face_id);
let cache = &mut ctx.render_cache;
let mut x = 0.0;
for glyph in &text.glyphs {
@ -141,7 +125,7 @@ fn render_text(
render_svg_glyph(canvas, ts, mask, text, face, id)
.or_else(|| render_bitmap_glyph(canvas, ts, mask, text, face, id))
.or_else(|| render_outline_glyph(canvas, ts, mask, cache, text, face, id));
.or_else(|| render_outline_glyph(canvas, ts, mask, text, face, id));
x += glyph.x_advance.resolve(text.size).to_f32();
}
@ -227,7 +211,6 @@ fn render_outline_glyph(
canvas: &mut sk::Pixmap,
ts: sk::Transform,
mask: Option<&sk::ClipMask>,
cache: &mut RenderCache,
text: &Text,
face: &Face,
id: GlyphId,
@ -255,15 +238,10 @@ fn render_outline_glyph(
return Some(());
}
// TODO(query)
// Try to retrieve a prepared glyph or prepare it from scratch if it
// doesn't exist, yet.
let glyph = match cache.glyphs.entry((text.face_id, id)) {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => {
let glyph = pixglyph::Glyph::load(face.ttf(), id)?;
entry.insert(glyph)
}
};
let glyph = pixglyph::Glyph::load(face.ttf(), id)?;
// Rasterize the glyph with `pixglyph`.
let bitmap = glyph.rasterize(ts.tx, ts.ty, ppem);

88
src/layout/constraints.rs
View File

@ -1,88 +0,0 @@
use std::sync::Arc;
use super::Regions;
use crate::frame::Frame;
use crate::geom::{Length, Size, Spec};
/// Constrain a frame with constraints.
pub trait Constrain {
/// Reference-count the frame and wrap it with constraints.
fn constrain(self, cts: Constraints) -> Constrained<Arc<Frame>>;
}
impl Constrain for Frame {
fn constrain(self, cts: Constraints) -> Constrained<Arc<Frame>> {
Constrained::new(Arc::new(self), cts)
}
}
/// Carries an item that is only valid in certain regions and the constraints
/// that describe these regions.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Constrained<T> {
/// The item that is only valid if the constraints are fullfilled.
pub item: T,
/// Constraints on regions in which the item is valid.
pub cts: Constraints,
}
impl<T> Constrained<T> {
/// Constrain an item with constraints.
pub fn new(item: T, cts: Constraints) -> Self {
Self { item, cts }
}
}
/// Describe regions that match them.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Constraints {
/// The minimum available length in the region.
pub min: Spec<Option<Length>>,
/// The maximum available length in the region.
pub max: Spec<Option<Length>>,
/// The available length in the region.
pub exact: Spec<Option<Length>>,
/// The base length of the region used for relative length resolution.
pub base: Spec<Option<Length>>,
/// The expand settings of the region.
pub expand: Spec<bool>,
}
impl Constraints {
/// Create a new region constraint.
pub fn new(expand: Spec<bool>) -> Self {
Self {
min: Spec::default(),
max: Spec::default(),
exact: Spec::default(),
base: Spec::default(),
expand,
}
}
/// Create tight constraints for a region.
pub fn tight(regions: &Regions) -> Self {
Self {
min: Spec::default(),
max: Spec::default(),
exact: regions.current.map(Some),
base: regions.base.map(Some),
expand: regions.expand,
}
}
/// Check whether the constraints are fullfilled in a region with the given
/// properties.
pub fn check(&self, current: Size, base: Size, expand: Spec<bool>) -> bool {
self.expand == expand
&& verify(self.min, current, |m, c| c.fits(m))
&& verify(self.max, current, |m, c| m.fits(c))
&& verify(self.exact, current, Length::approx_eq)
&& verify(self.base, base, Length::approx_eq)
}
}
/// Verify a single constraint.
fn verify(spec: Spec<Option<Length>>, size: Size, f: fn(Length, Length) -> bool) -> bool {
spec.zip(size).all(|&(opt, s)| opt.map_or(true, |m| f(m, s)))
}

451
src/layout/incremental.rs
View File

@ -1,451 +0,0 @@
use std::cmp::Reverse;
use std::collections::HashMap;
use std::sync::Arc;
use itertools::Itertools;
use super::{Constrained, Regions};
use crate::frame::Frame;
use crate::geom::Scalar;
const TEMP_LEN: usize = 4;
/// Caches layouting artifacts.
#[derive(Default, Clone)]
pub struct LayoutCache {
/// Maps from node hashes to the resulting frames and regions in which the
/// frames are valid. The right hand side of the hash map is a vector of
/// results because across one or more compilations, multiple different
/// layouts of the same node may have been requested.
frames: HashMap<u64, Vec<FramesEntry>>,
/// In how many compilations this cache has been used.
age: usize,
/// What cache eviction policy should be used.
policy: EvictionPolicy,
/// The maximum number of entries this cache should have. Can be exceeded if
/// there are more must-keep entries.
max_size: usize,
}
impl LayoutCache {
/// Create a new, empty layout cache.
pub fn new(policy: EvictionPolicy, max_size: usize) -> Self {
Self {
frames: HashMap::default(),
age: 0,
policy,
max_size,
}
}
/// Whether the cache is empty.
pub fn is_empty(&self) -> bool {
self.frames.values().all(|entry| entry.is_empty())
}
/// Amount of items in the cache.
pub fn len(&self) -> usize {
self.frames.values().map(Vec::len).sum()
}
/// The number of levels stored in the cache.
pub fn levels(&self) -> usize {
self.entries().map(|entry| entry.level + 1).max().unwrap_or(0)
}
/// An iterator over all entries in the cache.
pub fn entries(&self) -> impl Iterator<Item = &FramesEntry> + '_ {
self.frames.values().flatten()
}
/// Fetch matching cached frames if there are any.
pub fn get(
&mut self,
hash: u64,
regions: &Regions,
) -> Option<Vec<Constrained<Arc<Frame>>>> {
self.frames
.get_mut(&hash)?
.iter_mut()
.find_map(|entry| entry.lookup(regions))
}
/// Insert a new frame entry into the cache.
pub fn insert(&mut self, hash: u64, entry: FramesEntry) {
self.frames.entry(hash).or_default().push(entry);
}
/// Clear the cache.
pub fn clear(&mut self) {
self.frames.clear();
}
/// Retains all elements for which the closure on the level returns `true`.
pub fn retain<F>(&mut self, mut f: F)
where
F: FnMut(usize) -> bool,
{
for entries in self.frames.values_mut() {
entries.retain(|entry| f(entry.level));
}
}
/// Prepare the cache for the next round of compilation.
pub fn turnaround(&mut self) {
self.age += 1;
for entry in self.frames.values_mut().flatten() {
if entry.temperature[0] > 0 {
entry.used_cycles += 1;
}
let last = *entry.temperature.last().unwrap();
for i in (1 .. TEMP_LEN).rev() {
entry.temperature[i] = entry.temperature[i - 1];
}
entry.temperature[0] = 0;
entry.ancient_hits += last as usize;
entry.age += 1;
}
self.evict();
self.frames.retain(|_, v| !v.is_empty());
}
/// Evict the cache according to the policy.
fn evict(&mut self) {
let len = self.len();
if len <= self.max_size {
return;
}
match self.policy {
EvictionPolicy::LeastRecentlyUsed => {
// We find the element with the largest cooldown that cannot fit
// anymore.
let threshold = self
.entries()
.map(|f| Reverse(f.cooldown()))
.k_smallest(len - self.max_size)
.last()
.unwrap()
.0;
for entries in self.frames.values_mut() {
entries.retain(|f| f.cooldown() < threshold);
}
}
EvictionPolicy::LeastFrequentlyUsed => {
let threshold = self
.entries()
.map(|f| Scalar(f.hits() as f64 / f.age() as f64))
.k_smallest(len - self.max_size)
.last()
.unwrap()
.0;
for entries in self.frames.values_mut() {
entries.retain(|f| f.hits() as f64 / f.age() as f64 > threshold);
}
}
EvictionPolicy::Patterns => {
let kept = self.entries().filter(|f| f.properties().must_keep()).count();
let remaining_capacity = self.max_size - kept.min(self.max_size);
if len - kept <= remaining_capacity {
return;
}
let threshold = self
.entries()
.filter(|f| !f.properties().must_keep())
.map(|f| Scalar(f.hits() as f64 / f.age() as f64))
.k_smallest((len - kept) - remaining_capacity)
.last()
.unwrap()
.0;
for entries in self.frames.values_mut() {
entries.retain(|f| {
f.properties().must_keep()
|| f.hits() as f64 / f.age() as f64 > threshold
});
}
}
EvictionPolicy::None => {}
}
}
}
/// Cached frames from past layouting.
#[derive(Debug, Clone)]
pub struct FramesEntry {
/// The cached frames for a node.
frames: Vec<Constrained<Arc<Frame>>>,
/// How nested the frame was in the context is was originally appearing in.
level: usize,
/// For how long the element already exists.
age: usize,
/// How much the element was accessed during the last five compilations, the
/// most recent one being the first element.
temperature: [u8; TEMP_LEN],
/// All past usages that do not fit in the temperature array.
ancient_hits: usize,
/// Amount of cycles in which the element has been used at all.
used_cycles: usize,
}
impl FramesEntry {
/// Construct a new instance.
pub fn new(frames: Vec<Constrained<Arc<Frame>>>, level: usize) -> Self {
Self {
frames,
level,
age: 1,
temperature: [0; TEMP_LEN],
ancient_hits: 0,
used_cycles: 0,
}
}
/// Checks if the cached frames are valid in the given regions and returns
/// them if so.
pub fn lookup(&mut self, regions: &Regions) -> Option<Vec<Constrained<Arc<Frame>>>> {
self.check(regions).then(|| {
self.temperature[0] = self.temperature[0].saturating_add(1);
self.frames.clone()
})
}
/// Checks if the cached frames are valid in the given regions.
pub fn check(&self, regions: &Regions) -> bool {
let mut iter = regions.iter();
self.frames.iter().all(|frame| {
iter.next().map_or(false, |(current, base)| {
frame.cts.check(current, base, regions.expand)
})
})
}
/// How nested the frame was in the context is was originally appearing in.
pub fn level(&self) -> usize {
self.level
}
/// The number of compilation cycles this item has remained in the cache.
pub fn age(&self) -> usize {
self.age
}
/// Whether this element was used in the last compilation cycle.
pub fn hit(&self) -> bool {
self.temperature[0] != 0
}
/// Get the total amount of hits over the lifetime of this item.
pub fn hits(&self) -> usize {
self.temperature.into_iter().map(usize::from).sum::<usize>() + self.ancient_hits
}
/// The amount of consecutive cycles in which this item has not been used.
pub fn cooldown(&self) -> usize {
let mut cycle = 0;
for &temp in &self.temperature[.. self.age.min(TEMP_LEN)] {
if temp > 0 {
return cycle;
}
cycle += 1;
}
cycle
}
/// Properties that describe how this entry's temperature evolved.
pub fn properties(&self) -> PatternProperties {
let mut all_zeros = true;
let mut multi_use = false;
let mut decreasing = true;
let mut sparse = false;
let mut abandoned = false;
let mut last = None;
let mut all_same = true;
for (i, &temp) in self.temperature.iter().enumerate() {
if temp == 0 && !all_zeros {
sparse = true;
}
if temp != 0 {
all_zeros = false;
}
if all_zeros && i == 1 {
abandoned = true;
}
if temp > 1 {
multi_use = true;
}
if let Some(prev) = last {
if prev > temp {
decreasing = false;
}
if temp != prev {
all_same = false;
}
}
last = Some(temp);
}
if self.age > TEMP_LEN && self.age - TEMP_LEN <= self.ancient_hits {
multi_use = true;
}
if self.ancient_hits > 0 {
all_zeros = false;
}
PatternProperties {
mature: self.age > TEMP_LEN,
hit: self.temperature[0] >= 1,
top_level: self.level == 0,
all_zeros,
multi_use,
decreasing: decreasing && !all_same,
sparse,
abandoned,
}
}
}
/// Cache eviction strategies.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum EvictionPolicy {
/// Evict the least recently used item.
LeastRecentlyUsed,
/// Evict the least frequently used item.
LeastFrequentlyUsed,
/// Use the pattern verdicts.
Patterns,
/// Do not evict.
None,
}
impl Default for EvictionPolicy {
fn default() -> Self {
Self::Patterns
}
}
/// Describes the properties that this entry's temperature array has.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct PatternProperties {
/// There only are zero values.
pub all_zeros: bool,
/// The entry exists for more or equal time as the temperature array is long.
pub mature: bool,
/// The entry was used more than one time in at least one compilation.
pub multi_use: bool,
/// The entry was used in the last compilation.
pub hit: bool,
/// The temperature is monotonously decreasing in non-terminal temperature fields.
pub decreasing: bool,
/// There are zero temperatures after non-zero temperatures.
pub sparse: bool,
/// There are multiple zero temperatures at the front of the temperature array.
pub abandoned: bool,
/// If the item is on the top level.
pub top_level: bool,
}
impl PatternProperties {
/// Check if it is vital to keep an entry based on its properties.
pub fn must_keep(&self) -> bool {
// Keep an undo stack.
(self.top_level && !self.mature)
// Keep the most recently created items, even if they have not yet
// been used.
|| (self.all_zeros && !self.mature)
|| (self.multi_use && !self.abandoned)
|| self.hit
|| self.sparse
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geom::{Size, Spec};
use crate::layout::Constraints;
fn empty_frames() -> Vec<Constrained<Arc<Frame>>> {
vec![Constrained {
item: Arc::new(Frame::default()),
cts: Constraints::new(Spec::splat(false)),
}]
}
fn zero_regions() -> Regions {
Regions::one(Size::zero(), Size::zero(), Spec::splat(false))
}
#[test]
fn test_layout_incremental_temperature() {
let mut cache = LayoutCache::new(EvictionPolicy::None, 20);
let regions = zero_regions();
cache.policy = EvictionPolicy::None;
cache.insert(0, FramesEntry::new(empty_frames(), 0));
let entry = cache.frames.get(&0).unwrap().first().unwrap();
assert_eq!(entry.age(), 1);
assert_eq!(entry.temperature, [0, 0, 0, 0]);
assert_eq!(entry.ancient_hits, 0);
assert_eq!(entry.used_cycles, 0);
assert_eq!(entry.level, 0);
cache.get(0, &regions).unwrap();
let entry = cache.frames.get(&0).unwrap().first().unwrap();
assert_eq!(entry.age(), 1);
assert_eq!(entry.temperature, [1, 0, 0, 0]);
assert_eq!(entry.ancient_hits, 0);
cache.turnaround();
let entry = cache.frames.get(&0).unwrap().first().unwrap();
assert_eq!(entry.age(), 2);
assert_eq!(entry.temperature, [0, 1, 0, 0]);
assert_eq!(entry.ancient_hits, 0);
assert_eq!(entry.used_cycles, 1);
cache.get(0, &regions).unwrap();
for _ in 0 .. 4 {
cache.turnaround();
}
let entry = cache.frames.get(&0).unwrap().first().unwrap();
assert_eq!(entry.age(), 6);
assert_eq!(entry.temperature, [0, 0, 0, 0]);
assert_eq!(entry.ancient_hits, 2);
assert_eq!(entry.used_cycles, 2);
}
#[test]
fn test_layout_incremental_properties() {
let mut cache = LayoutCache::new(EvictionPolicy::None, 20);
cache.policy = EvictionPolicy::None;
cache.insert(0, FramesEntry::new(empty_frames(), 1));
let props = cache.frames.get(&0).unwrap().first().unwrap().properties();
assert_eq!(props.top_level, false);
assert_eq!(props.mature, false);
assert_eq!(props.multi_use, false);
assert_eq!(props.hit, false);
assert_eq!(props.decreasing, false);
assert_eq!(props.sparse, false);
assert_eq!(props.abandoned, true);
assert_eq!(props.all_zeros, true);
assert_eq!(props.must_keep(), true);
}
}

102
src/layout/regions.rs
View File

@ -1,102 +0,0 @@
use crate::geom::{Length, Size, Spec};
/// A sequence of regions to layout into.
#[derive(Debug, Clone)]
pub struct Regions {
/// The remaining size of the current region.
pub current: Size,
/// The base size for relative sizing.
pub base: Size,
/// The height of followup regions. The width is the same for all regions.
pub backlog: std::vec::IntoIter<Length>,
/// The height of the final region that is repeated once the backlog is
/// drained. The width is the same for all regions.
pub last: Option<Length>,
/// Whether nodes should expand to fill the regions instead of shrinking to
/// fit the content.
pub expand: Spec<bool>,
}
impl Regions {
/// Create a new region sequence with exactly one region.
pub fn one(size: Size, base: Size, expand: Spec<bool>) -> Self {
Self {
current: size,
base,
backlog: vec![].into_iter(),
last: None,
expand,
}
}
/// Create a new sequence of same-size regions that repeats indefinitely.
pub fn repeat(size: Size, base: Size, expand: Spec<bool>) -> Self {
Self {
current: size,
base,
backlog: vec![].into_iter(),
last: Some(size.y),
expand,
}
}
/// Create new regions where all sizes are mapped with `f`.
///
/// Note that since all regions must have the same width, the width returned
/// by `f` is ignored for the backlog and the final region.
pub fn map<F>(&self, mut f: F) -> Self
where
F: FnMut(Size) -> Size,
{
let x = self.current.x;
Self {
current: f(self.current),
base: f(self.base),
backlog: self
.backlog
.as_slice()
.iter()
.map(|&y| f(Size::new(x, y)).y)
.collect::<Vec<_>>()
.into_iter(),
last: self.last.map(|y| f(Size::new(x, y)).y),
expand: self.expand,
}
}
/// Whether the current region is full and a region break is called for.
pub fn is_full(&self) -> bool {
Length::zero().fits(self.current.y) && !self.in_last()
}
/// Whether `current` is the last usable region.
///
/// If this is true, calling `next()` will have no effect.
pub fn in_last(&self) -> bool {
self.backlog.len() == 0
&& self.last.map_or(true, |height| self.current.y == height)
}
/// Advance to the next region if there is any.
pub fn next(&mut self) {
if let Some(height) = self.backlog.next().or(self.last) {
self.current.y = height;
self.base.y = height;
}
}
/// An iterator that returns pairs of `(current, base)` that are equivalent
/// to what would be produced by calling [`next()`](Self::next) repeatedly
/// until all regions are exhausted.
pub fn iter(&self) -> impl Iterator<Item = (Size, Size)> + '_ {
let first = std::iter::once((self.current, self.base));
let backlog = self.backlog.as_slice().iter();
let last = self.last.iter().cycle();
first.chain(backlog.chain(last).map(|&height| {
(
Size::new(self.current.x, height),
Size::new(self.base.x, height),
)
}))
}
}

41
src/lib.rs
View File

@ -44,7 +44,6 @@ pub mod font;
pub mod frame;
pub mod geom;
pub mod image;
pub mod layout;
pub mod library;
pub mod loading;
pub mod parse;
@ -58,11 +57,9 @@ use std::sync::Arc;
use crate::diag::TypResult;
use crate::eval::{Eval, Module, Scope, Scopes, StyleMap};
use crate::export::RenderCache;
use crate::font::FontStore;
use crate::frame::Frame;
use crate::image::ImageStore;
use crate::layout::{EvictionPolicy, LayoutCache};
use crate::loading::Loader;
use crate::source::{SourceId, SourceStore};
@ -76,10 +73,6 @@ pub struct Context {
pub fonts: FontStore,
/// Stores decoded images.
pub images: ImageStore,
/// Caches layouting artifacts.
pub layout_cache: LayoutCache,
/// Caches rendering artifacts.
pub render_cache: RenderCache,
/// The standard library scope.
std: Scope,
/// The default styles.
@ -115,11 +108,6 @@ impl Context {
pub fn typeset(&mut self, id: SourceId) -> TypResult<Vec<Arc<Frame>>> {
Vm::new(self).typeset(id)
}
/// Garbage-collect caches.
pub fn turnaround(&mut self) {
self.layout_cache.turnaround();
}
}
/// A builder for a [`Context`].
@ -128,8 +116,6 @@ impl Context {
pub struct ContextBuilder {
std: Option<Scope>,
styles: Option<StyleMap>,
policy: EvictionPolicy,
max_size: usize,
}
impl ContextBuilder {
@ -146,21 +132,6 @@ impl ContextBuilder {
self
}
/// The policy for eviction of the layout cache.
pub fn cache_policy(mut self, policy: EvictionPolicy) -> Self {
self.policy = policy;
self
}
/// The maximum number of entries the layout cache should have.
///
/// Note that this can be exceeded if more entries are categorized as [must
/// keep][crate::layout::PatternProperties::must_keep].
pub fn cache_max_size(mut self, max_size: usize) -> Self {
self.max_size = max_size;
self
}
/// Finish building the context by providing the `loader` used to load
/// fonts, images, source files and other resources.
pub fn build(self, loader: Arc<dyn Loader>) -> Context {
@ -169,8 +140,6 @@ impl ContextBuilder {
fonts: FontStore::new(Arc::clone(&loader)),
images: ImageStore::new(Arc::clone(&loader)),
loader,
layout_cache: LayoutCache::new(self.policy, self.max_size),
render_cache: RenderCache::new(),
std: self.std.unwrap_or_else(library::new),
styles: self.styles.unwrap_or_default(),
}
@ -179,12 +148,7 @@ impl ContextBuilder {
impl Default for ContextBuilder {
fn default() -> Self {
Self {
std: None,
styles: None,
policy: EvictionPolicy::default(),
max_size: 2000,
}
Self { std: None, styles: None }
}
}
@ -198,8 +162,6 @@ pub struct Vm<'a> {
pub fonts: &'a mut FontStore,
/// Stores decoded images.
pub images: &'a mut ImageStore,
/// Caches layouting artifacts.
pub layout_cache: &'a mut LayoutCache,
/// The default styles.
pub styles: &'a StyleMap,
/// The stack of imported files that led to evaluation of the current file.
@ -223,7 +185,6 @@ impl<'a> Vm<'a> {
sources: &mut ctx.sources,
fonts: &mut ctx.fonts,
images: &mut ctx.images,
layout_cache: &mut ctx.layout_cache,
styles: &ctx.styles,
route: vec![],
modules: HashMap::new(),

13
src/library/align.rs
View File

@ -27,7 +27,7 @@ impl Layout for AlignNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
// The child only needs to expand along an axis if there's no alignment.
let mut pod = regions.clone();
pod.expand &= self.aligns.map_is_none();
@ -40,20 +40,13 @@ impl Layout for AlignNode {
// Layout the child.
let mut frames = self.child.layout(vm, &pod, passed.chain(&styles))?;
for ((current, base), Constrained { item: frame, cts }) in
regions.iter().zip(&mut frames)
{
for (region, frame) in regions.iter().zip(&mut frames) {
// Align in the target size. The target size depends on whether we
// should expand.
let target = regions.expand.select(current, frame.size);
let target = regions.expand.select(region, frame.size);
let default = Spec::new(Align::Left, Align::Top);
let aligns = self.aligns.unwrap_or(default);
Arc::make_mut(frame).resize(target, aligns);
// Set constraints.
cts.expand = regions.expand;
cts.base = base.filter(cts.base.map_is_some());
cts.exact = current.filter(regions.expand | cts.exact.map_is_some());
}
Ok(frames)

25
src/library/columns.rs
View File

@ -32,23 +32,23 @@ impl Layout for ColumnsNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
// Separating the infinite space into infinite columns does not make
// much sense.
if regions.current.x.is_infinite() {
if regions.first.x.is_infinite() {
return self.child.layout(vm, regions, styles);
}
// Determine the width of the gutter and each column.
let columns = self.columns.get();
let gutter = styles.get(Self::GUTTER).resolve(regions.base.x);
let width = (regions.current.x - gutter * (columns - 1) as f64) / columns as f64;
let width = (regions.first.x - gutter * (columns - 1) as f64) / columns as f64;
// Create the pod regions.
let pod = Regions {
current: Size::new(width, regions.current.y),
first: Size::new(width, regions.first.y),
base: Size::new(width, regions.base.y),
backlog: std::iter::once(&regions.current.y)
backlog: std::iter::once(&regions.first.y)
.chain(regions.backlog.as_slice())
.flat_map(|&height| std::iter::repeat(height).take(columns))
.skip(1)
@ -66,18 +66,18 @@ impl Layout for ColumnsNode {
let mut finished = vec![];
// Stitch together the columns for each region.
for (current, base) in regions.iter().take(total_regions) {
for region in regions.iter().take(total_regions) {
// The height should be the parent height if the node shall expand.
// Otherwise its the maximum column height for the frame. In that
// case, the frame is first created with zero height and then
// resized.
let height = if regions.expand.y { current.y } else { Length::zero() };
let mut output = Frame::new(Size::new(regions.current.x, height));
let height = if regions.expand.y { region.y } else { Length::zero() };
let mut output = Frame::new(Size::new(regions.first.x, height));
let mut cursor = Length::zero();
for _ in 0 .. columns {
let frame = match frames.next() {
Some(frame) => frame.item,
Some(frame) => frame,
None => break,
};
@ -89,17 +89,14 @@ impl Layout for ColumnsNode {
let x = if dir.is_positive() {
cursor
} else {
regions.current.x - cursor - width
regions.first.x - cursor - width
};
output.push_frame(Point::with_x(x), frame);
cursor += width + gutter;
}
let mut cts = Constraints::new(regions.expand);
cts.base = base.map(Some);
cts.exact = current.map(Some);
finished.push(output.constrain(cts));
finished.push(Arc::new(output));
}
Ok(finished)

31
src/library/flow.rs
View File

@ -31,7 +31,7 @@ impl Layout for FlowNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut layouter = FlowLayouter::new(regions);
for (child, map) in self.0.iter() {
@ -96,7 +96,7 @@ pub struct FlowLayouter {
regions: Regions,
/// Whether the flow should expand to fill the region.
expand: Spec<bool>,
/// The full size of `regions.current` that was available before we started
/// The full size of `regions.size` that was available before we started
/// subtracting.
full: Size,
/// The size used by the frames for the current region.
@ -106,7 +106,7 @@ pub struct FlowLayouter {
/// Spacing and layouted nodes.
items: Vec<FlowItem>,
/// Finished frames for previous regions.
finished: Vec<Constrained<Arc<Frame>>>,
finished: Vec<Arc<Frame>>,
}
/// A prepared item in a flow layout.
@ -125,7 +125,7 @@ impl FlowLayouter {
/// Create a new flow layouter.
pub fn new(regions: &Regions) -> Self {
let expand = regions.expand;
let full = regions.current;
let full = regions.first;
// Disable vertical expansion for children.
let mut regions = regions.clone();
@ -148,8 +148,8 @@ impl FlowLayouter {
SpacingKind::Linear(v) => {
// Resolve the linear and limit it to the remaining space.
let resolved = v.resolve(self.full.y);
let limited = resolved.min(self.regions.current.y);
self.regions.current.y -= limited;
let limited = resolved.min(self.regions.first.y);
self.regions.first.y -= limited;
self.used.y += limited;
self.items.push(FlowItem::Absolute(resolved));
}
@ -177,7 +177,7 @@ impl FlowLayouter {
if let Some(placed) = node.downcast::<PlaceNode>() {
if placed.out_of_flow() {
let frame = node.layout(vm, &self.regions, styles)?.remove(0);
self.items.push(FlowItem::Placed(frame.item));
self.items.push(FlowItem::Placed(frame));
return Ok(());
}
}
@ -197,11 +197,11 @@ impl FlowLayouter {
let len = frames.len();
for (i, frame) in frames.into_iter().enumerate() {
// Grow our size, shrink the region and save the frame for later.
let size = frame.item.size;
let size = frame.size;
self.used.y += size.y;
self.used.x.set_max(size.x);
self.regions.current.y -= size.y;
self.items.push(FlowItem::Frame(frame.item, aligns));
self.regions.first.y -= size.y;
self.items.push(FlowItem::Frame(frame, aligns));
if i + 1 < len {
self.finish_region();
@ -251,21 +251,16 @@ impl FlowLayouter {
}
}
// Generate tight constraints for now.
let mut cts = Constraints::new(self.expand);
cts.exact = self.full.map(Some);
cts.base = self.regions.base.map(Some);
// Advance to the next region.
self.regions.next();
self.full = self.regions.current;
self.full = self.regions.first;
self.used = Size::zero();
self.fr = Fractional::zero();
self.finished.push(output.constrain(cts));
self.finished.push(Arc::new(output));
}
/// Finish layouting and return the resulting frames.
pub fn finish(mut self) -> Vec<Constrained<Arc<Frame>>> {
pub fn finish(mut self) -> Vec<Arc<Frame>> {
if self.expand.y {
while self.regions.backlog.len() > 0 {
self.finish_region();

91
src/library/grid.rs
View File

@ -38,7 +38,7 @@ impl Layout for GridNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
// Prepare grid layout by unifying content and gutter tracks.
let layouter = GridLayouter::new(
self.tracks.as_deref(),
@ -105,8 +105,6 @@ pub struct GridLayouter<'a> {
rcols: Vec<Length>,
/// Rows in the current region.
lrows: Vec<Row>,
/// Whether the grid itself should expand to fill the region.
expand: Spec<bool>,
/// The full height of the current region.
full: Length,
/// The used-up size of the current region. The horizontal size is
@ -114,10 +112,8 @@ pub struct GridLayouter<'a> {
used: Size,
/// The sum of fractional ratios in the current region.
fr: Fractional,
/// Constraints for the active region.
cts: Constraints,
/// Frames for finished regions.
finished: Vec<Constrained<Arc<Frame>>>,
finished: Vec<Arc<Frame>>,
}
/// Produced by initial row layout, auto and linear rows are already finished,
@ -177,8 +173,7 @@ impl<'a> GridLayouter<'a> {
cols.pop();
rows.pop();
let expand = regions.expand;
let full = regions.current.y;
let full = regions.first.y;
let rcols = vec![Length::zero(); cols.len()];
let lrows = vec![];
@ -195,17 +190,15 @@ impl<'a> GridLayouter<'a> {
styles,
rcols,
lrows,
expand,
full,
used: Size::zero(),
fr: Fractional::zero(),
cts: Constraints::new(expand),
finished: vec![],
}
}
/// Determines the columns sizes and then layouts the grid row-by-row.
pub fn layout(mut self, vm: &mut Vm) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
pub fn layout(mut self, vm: &mut Vm) -> TypResult<Vec<Arc<Frame>>> {
self.measure_columns(vm)?;
for y in 0 .. self.rows.len() {
@ -219,7 +212,6 @@ impl<'a> GridLayouter<'a> {
TrackSizing::Auto => self.layout_auto_row(vm, y)?,
TrackSizing::Linear(v) => self.layout_linear_row(vm, v, y)?,
TrackSizing::Fractional(v) => {
self.cts.exact.y = Some(self.full);
self.lrows.push(Row::Fr(v, y));
self.fr += v;
}
@ -232,22 +224,6 @@ impl<'a> GridLayouter<'a> {
/// Determine all column sizes.
fn measure_columns(&mut self, vm: &mut Vm) -> TypResult<()> {
enum Case {
/// The column sizing is only determined by specified linear sizes.
PurelyLinear,
/// The column sizing would be affected by the region size if it was
/// smaller.
Fitting,
/// The column sizing is affected by the region size.
Exact,
/// The column sizing would be affected by the region size if it was
/// larger.
Overflowing,
}
// The different cases affecting constraints.
let mut case = Case::PurelyLinear;
// Sum of sizes of resolved linear tracks.
let mut linear = Length::zero();
@ -258,23 +234,18 @@ impl<'a> GridLayouter<'a> {
// fractional tracks.
for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
match col {
TrackSizing::Auto => {
case = Case::Fitting;
}
TrackSizing::Auto => {}
TrackSizing::Linear(v) => {
let resolved = v.resolve(self.regions.base.x);
*rcol = resolved;
linear += resolved;
}
TrackSizing::Fractional(v) => {
case = Case::Fitting;
fr += v;
}
TrackSizing::Fractional(v) => fr += v,
}
}
// Size that is not used by fixed-size columns.
let available = self.regions.current.x - linear;
let available = self.regions.first.x - linear;
if available >= Length::zero() {
// Determine size of auto columns.
let (auto, count) = self.measure_auto_columns(vm, available)?;
@ -285,25 +256,10 @@ impl<'a> GridLayouter<'a> {
if remaining >= Length::zero() {
if !fr.is_zero() {
self.grow_fractional_columns(remaining, fr);
case = Case::Exact;
}
} else {
self.shrink_auto_columns(available, count);
case = Case::Exact;
}
} else if matches!(case, Case::Fitting) {
case = Case::Overflowing;
}
// Children could depend on base.
self.cts.base = self.regions.base.map(Some);
// Set constraints depending on the case we hit.
match case {
Case::PurelyLinear => {}
Case::Fitting => self.cts.min.x = Some(self.used.x),
Case::Exact => self.cts.exact.x = Some(self.regions.current.x),
Case::Overflowing => self.cts.max.x = Some(linear),
}
// Sum up the resolved column sizes once here.
@ -342,7 +298,7 @@ impl<'a> GridLayouter<'a> {
pod.base.y = v.resolve(self.regions.base.y);
}
let frame = node.layout(vm, &pod, self.styles)?.remove(0).item;
let frame = node.layout(vm, &pod, self.styles)?.remove(0);
resolved.set_max(frame.size.x);
}
}
@ -403,7 +359,7 @@ impl<'a> GridLayouter<'a> {
for (x, &rcol) in self.rcols.iter().enumerate() {
if let Some(node) = self.cell(x, y) {
let mut pod = self.regions.clone();
pod.current.x = rcol;
pod.first.x = rcol;
// All widths should be `rcol` except the base for auto columns.
if self.cols[x] == TrackSizing::Auto {
@ -413,7 +369,7 @@ impl<'a> GridLayouter<'a> {
let mut sizes = node
.layout(vm, &pod, self.styles)?
.into_iter()
.map(|frame| frame.item.size.y);
.map(|frame| frame.size.y);
// For each region, we want to know the maximum height any
// column requires.
@ -443,10 +399,8 @@ impl<'a> GridLayouter<'a> {
// eaten up by any fr rows.
if self.fr.is_zero() {
let len = resolved.len();
for (target, (current, _)) in
resolved[.. len - 1].iter_mut().zip(self.regions.iter())
{
target.set_max(current.y);
for (region, target) in self.regions.iter().zip(&mut resolved[.. len - 1]) {
target.set_max(region.y);
}
}
@ -456,7 +410,6 @@ impl<'a> GridLayouter<'a> {
for (i, frame) in frames.into_iter().enumerate() {
self.push_row(frame);
if i + 1 < len {
self.cts.exact.y = Some(self.full);
self.finish_region(vm)?;
}
}
@ -472,8 +425,7 @@ impl<'a> GridLayouter<'a> {
// Skip to fitting region.
let height = frame.size.y;
while !self.regions.current.y.fits(height) && !self.regions.in_last() {
self.cts.max.y = Some(self.used.y + height);
while !self.regions.first.y.fits(height) && !self.regions.in_last() {
self.finish_region(vm)?;
// Don't skip multiple regions for gutter and don't push a row.
@ -509,7 +461,7 @@ impl<'a> GridLayouter<'a> {
let pod = Regions::one(size, base, Spec::splat(true));
let frame = node.layout(vm, &pod, self.styles)?.remove(0);
output.push_frame(pos, frame.item);
output.push_frame(pos, frame);
}
pos.x += rcol;
@ -540,7 +492,7 @@ impl<'a> GridLayouter<'a> {
let mut pos = Point::zero();
for (x, &rcol) in self.rcols.iter().enumerate() {
if let Some(node) = self.cell(x, y) {
pod.current.x = rcol;
pod.first.x = rcol;
// All widths should be `rcol` except the base for auto columns.
if self.cols[x] == TrackSizing::Auto {
@ -550,7 +502,7 @@ impl<'a> GridLayouter<'a> {
// Push the layouted frames into the individual output frames.
let frames = node.layout(vm, &pod, self.styles)?;
for (output, frame) in outputs.iter_mut().zip(frames) {
output.push_frame(pos, frame.item);
output.push_frame(pos, frame);
}
}
@ -562,7 +514,7 @@ impl<'a> GridLayouter<'a> {
/// Push a row frame into the current region.
fn push_row(&mut self, frame: Frame) {
self.regions.current.y -= frame.size.y;
self.regions.first.y -= frame.size.y;
self.used.y += frame.size.y;
self.lrows.push(Row::Frame(frame));
}
@ -574,9 +526,6 @@ impl<'a> GridLayouter<'a> {
let mut size = self.used;
if self.fr.get() > 0.0 && self.full.is_finite() {
size.y = self.full;
self.cts.exact.y = Some(self.full);
} else {
self.cts.min.y = Some(size.y.min(self.full));
}
// The frame for the region.
@ -599,13 +548,11 @@ impl<'a> GridLayouter<'a> {
pos.y += height;
}
self.cts.base = self.regions.base.map(Some);
self.finished.push(output.constrain(self.cts));
self.finished.push(Arc::new(output));
self.regions.next();
self.full = self.regions.current.y;
self.full = self.regions.first.y;
self.used.y = Length::zero();
self.fr = Fractional::zero();
self.cts = Constraints::new(self.expand);
Ok(())
}

4
src/library/hide.rs
View File

@ -19,11 +19,11 @@ impl Layout for HideNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut frames = self.0.layout(vm, regions, styles)?;
// Clear the frames.
for Constrained { item: frame, .. } in &mut frames {
for frame in &mut frames {
*frame = Arc::new(Frame { elements: vec![], ..**frame });
}

20
src/library/image.rs
View File

@ -39,24 +39,24 @@ impl Layout for ImageNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let img = vm.images.get(self.0);
let pxw = img.width() as f64;
let pxh = img.height() as f64;
let px_ratio = pxw / pxh;
// Find out whether the image is wider or taller than the target size.
let &Regions { current, expand, .. } = regions;
let current_ratio = current.x / current.y;
let wide = px_ratio > current_ratio;
let &Regions { first, expand, .. } = regions;
let region_ratio = first.x / first.y;
let wide = px_ratio > region_ratio;
// The space into which the image will be placed according to its fit.
let target = if expand.x && expand.y {
current
} else if expand.x || (!expand.y && wide && current.x.is_finite()) {
Size::new(current.x, current.y.min(current.x.safe_div(px_ratio)))
} else if current.y.is_finite() {
Size::new(current.x.min(current.y * px_ratio), current.y)
first
} else if expand.x || (!expand.y && wide && first.x.is_finite()) {
Size::new(first.x, first.y.min(first.x.safe_div(px_ratio)))
} else if first.y.is_finite() {
Size::new(first.x.min(first.y * px_ratio), first.y)
} else {
Size::new(Length::pt(pxw), Length::pt(pxh))
};
@ -91,7 +91,7 @@ impl Layout for ImageNode {
frame.link(url);
}
Ok(vec![frame.constrain(Constraints::tight(regions))])
Ok(vec![Arc::new(frame)])
}
}

8
src/library/mod.rs
View File

@ -66,14 +66,12 @@ pub mod prelude {
pub use crate::diag::{with_alternative, At, StrResult, TypResult};
pub use crate::eval::{
Arg, Args, Cast, Construct, Func, Merge, Property, Scope, Set, Show, ShowNode,
Smart, StyleChain, StyleMap, StyleVec, Template, Value,
Arg, Args, Cast, Construct, Func, Layout, LayoutNode, Merge, Property, Regions,
Scope, Set, Show, ShowNode, Smart, StyleChain, StyleMap, StyleVec, Template,
Value,
};
pub use crate::frame::*;
pub use crate::geom::*;
pub use crate::layout::{
Constrain, Constrained, Constraints, Layout, LayoutNode, Regions,
};
pub use crate::syntax::{Span, Spanned};
pub use crate::util::{EcoString, OptionExt};
pub use crate::Vm;

19
src/library/pad.rs
View File

@ -33,14 +33,12 @@ impl Layout for PadNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
// Layout child into padded regions.
let pod = regions.map(|size| shrink(size, self.padding));
let mut frames = self.child.layout(vm, &pod, styles)?;
for ((current, base), Constrained { item: frame, cts }) in
regions.iter().zip(&mut frames)
{
for frame in &mut frames {
// Apply the padding inversely such that the grown size padded
// yields the frame's size.
let padded = grow(frame.size, self.padding);
@ -51,19 +49,6 @@ impl Layout for PadNode {
let frame = Arc::make_mut(frame);
frame.size = padded;
frame.translate(offset);
// Set exact and base constraints if the child had them. Also set
// base if our padding is relative.
let is_rel = self.padding.sum_by_axis().map(Linear::is_relative);
cts.exact = current.filter(cts.exact.map_is_some());
cts.base = base.filter(is_rel | cts.base.map_is_some());
// Inflate min and max contraints by the padding.
for spec in [&mut cts.min, &mut cts.max] {
spec.as_mut()
.zip(padding.sum_by_axis())
.map(|(s, p)| s.as_mut().map(|v| *v += p));
}
}
Ok(frames)

9
src/library/page.rs
View File

@ -115,15 +115,12 @@ impl PageNode {
// Layout the child.
let regions = Regions::repeat(size, size, size.map(Length::is_finite));
let mut frames: Vec<_> = child
.layout(vm, &regions, styles)?
.into_iter()
.map(|c| c.item)
.collect();
let mut frames = child.layout(vm, &regions, styles)?;
let header = styles.get_ref(Self::HEADER);
let footer = styles.get_ref(Self::FOOTER);
// Realize header and footer.
for frame in &mut frames {
let size = frame.size;
let padding = padding.resolve(size);
@ -136,7 +133,7 @@ impl PageNode {
let w = size.x - padding.left - padding.right;
let area = Size::new(w, h);
let pod = Regions::one(area, area, area.map(Length::is_finite));
let sub = template.layout(vm, &pod, styles)?.remove(0).item;
let sub = template.layout(vm, &pod, styles)?.remove(0);
Arc::make_mut(frame).push_frame(pos, sub);
}
}

24
src/library/par.rs
View File

@ -86,7 +86,7 @@ impl Layout for ParNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
// Collect all text into one string used for BiDi analysis.
let text = self.collect_text();
let level = Level::from_dir(styles.get(Self::DIR));
@ -113,7 +113,7 @@ impl Layout for ParNode {
// If the line doesn't fit anymore, we push the last fitting attempt
// into the stack and rebuild the line from its end. The resulting
// line cannot be broken up further.
if !regions.current.x.fits(line.size.x) {
if !regions.first.x.fits(line.size.x) {
if let Some((last_line, last_end)) = last.take() {
lines.push(last_line);
start = last_end;
@ -124,7 +124,7 @@ impl Layout for ParNode {
// Finish the current line if there is a mandatory line break (i.e.
// due to "\n") or if the line doesn't fit horizontally already
// since no shorter line will be possible.
if mandatory || !regions.current.x.fits(line.size.x) {
if mandatory || !regions.first.x.fits(line.size.x) {
lines.push(line);
start = end;
last = None;
@ -139,7 +139,7 @@ impl Layout for ParNode {
// Determine the paragraph's width: Fit to width if we shoudn't expand
// and there's no fractional spacing.
let mut width = regions.current.x;
let mut width = regions.first.x;
if !regions.expand.x && lines.iter().all(|line| line.fr.is_zero()) {
width = lines.iter().map(|line| line.size.x).max().unwrap_or_default();
}
@ -149,15 +149,13 @@ impl Layout for ParNode {
let mut finished = vec![];
let mut first = true;
let mut output = Frame::new(Size::with_x(width));
let mut cts = Constraints::tight(&regions);
// Stack the lines into one frame per region.
for line in lines {
while !regions.current.y.fits(line.size.y) && !regions.in_last() {
finished.push(output.constrain(cts));
while !regions.first.y.fits(line.size.y) && !regions.in_last() {
finished.push(Arc::new(output));
output = Frame::new(Size::with_x(width));
regions.next();
cts = Constraints::tight(&regions);
first = true;
}
@ -170,11 +168,11 @@ impl Layout for ParNode {
output.size.y += frame.size.y;
output.merge_frame(pos, frame);
regions.current.y -= line.size.y + leading;
regions.first.y -= line.size.y + leading;
first = false;
}
finished.push(output.constrain(cts));
finished.push(Arc::new(output));
Ok(finished)
}
}
@ -316,7 +314,7 @@ impl<'a> ParLayout<'a> {
}
ParChild::Spacing(kind) => match *kind {
SpacingKind::Linear(v) => {
let resolved = v.resolve(regions.current.x);
let resolved = v.resolve(regions.first.x);
items.push(ParItem::Absolute(resolved));
ranges.push(range);
}
@ -326,10 +324,10 @@ impl<'a> ParLayout<'a> {
}
},
ParChild::Node(node) => {
let size = Size::new(regions.current.x, regions.base.y);
let size = Size::new(regions.first.x, regions.base.y);
let pod = Regions::one(size, regions.base, Spec::splat(false));
let frame = node.layout(vm, &pod, styles)?.remove(0);
items.push(ParItem::Frame(Arc::take(frame.item)));
items.push(ParItem::Frame(Arc::take(frame)));
ranges.push(range);
}
}

16
src/library/place.rs
View File

@ -26,11 +26,11 @@ impl Layout for PlaceNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let out_of_flow = self.out_of_flow();
// The pod is the base area of the region because for absolute
// placement we don't really care about the already used area (current).
// placement we don't really care about the already used area.
let pod = {
let finite = regions.base.map(Length::is_finite);
let expand = finite & (regions.expand | out_of_flow);
@ -38,26 +38,20 @@ impl Layout for PlaceNode {
};
let mut frames = self.0.layout(vm, &pod, styles)?;
let Constrained { item: frame, cts } = &mut frames[0];
// If expansion is off, zero all sizes so that we don't take up any
// space in our parent. Otherwise, respect the expand settings.
let target = regions.expand.select(regions.current, Size::zero());
let frame = &mut frames[0];
let target = regions.expand.select(regions.first, Size::zero());
Arc::make_mut(frame).resize(target, Align::LEFT_TOP);
// Set base constraint because our pod size is base and exact
// constraints if we needed to expand or offset.
*cts = Constraints::new(regions.expand);
cts.base = regions.base.map(Some);
cts.exact = regions.current.filter(regions.expand | out_of_flow);
Ok(frames)
}
}
impl PlaceNode {
/// Whether this node wants to be placed relative to its its parent's base
/// origin. instead of relative to the parent's current flow/cursor
/// origin. Instead of relative to the parent's current flow/cursor
/// position.
pub fn out_of_flow(&self) -> bool {
self.0

23
src/library/shape.rs
View File

@ -49,7 +49,7 @@ impl<const S: ShapeKind> Layout for ShapeNode<S> {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut frames;
if let Some(child) = &self.0 {
let mut padding = styles.get(Self::PADDING);
@ -60,48 +60,47 @@ impl<const S: ShapeKind> Layout for ShapeNode<S> {
// Pad the child.
let child = child.clone().padded(Sides::splat(padding));
let mut pod = Regions::one(regions.current, regions.base, regions.expand);
let mut pod = Regions::one(regions.first, regions.base, regions.expand);
frames = child.layout(vm, &pod, styles)?;
// Relayout with full expansion into square region to make sure
// the result is really a square or circle.
if is_quadratic(S) {
let length = if regions.expand.x || regions.expand.y {
let target = regions.expand.select(regions.current, Size::zero());
let target = regions.expand.select(regions.first, Size::zero());
target.x.max(target.y)
} else {
let size = frames[0].item.size;
let size = frames[0].size;
let desired = size.x.max(size.y);
desired.min(regions.current.x).min(regions.current.y)
desired.min(regions.first.x).min(regions.first.y)
};
pod.current = Size::splat(length);
pod.first = Size::splat(length);
pod.expand = Spec::splat(true);
frames = child.layout(vm, &pod, styles)?;
frames[0].cts = Constraints::tight(regions);
}
} else {
// The default size that a shape takes on if it has no child and
// enough space.
let mut size =
Size::new(Length::pt(45.0), Length::pt(30.0)).min(regions.current);
Size::new(Length::pt(45.0), Length::pt(30.0)).min(regions.first);
if is_quadratic(S) {
let length = if regions.expand.x || regions.expand.y {
let target = regions.expand.select(regions.current, Size::zero());
let target = regions.expand.select(regions.first, Size::zero());
target.x.max(target.y)
} else {
size.x.min(size.y)
};
size = Size::splat(length);
} else {
size = regions.expand.select(regions.current, size);
size = regions.expand.select(regions.first, size);
}
frames = vec![Frame::new(size).constrain(Constraints::tight(regions))];
frames = vec![Arc::new(Frame::new(size))];
}
let frame = Arc::make_mut(&mut frames[0].item);
let frame = Arc::make_mut(&mut frames[0]);
// Add fill and/or stroke.
let fill = styles.get(Self::FILL);

25
src/library/stack.rs
View File

@ -31,7 +31,7 @@ impl Layout for StackNode {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let mut layouter = StackLayouter::new(self.dir, regions);
// Spacing to insert before the next node.
@ -106,7 +106,7 @@ pub struct StackLayouter {
/// fractional spacing.
items: Vec<StackItem>,
/// Finished frames for previous regions.
finished: Vec<Constrained<Arc<Frame>>>,
finished: Vec<Arc<Frame>>,
}
/// A prepared item in a stack layout.
@ -124,7 +124,7 @@ impl StackLayouter {
pub fn new(dir: Dir, regions: &Regions) -> Self {
let axis = dir.axis();
let expand = regions.expand;
let full = regions.current;
let full = regions.first;
// Disable expansion along the block axis for children.
let mut regions = regions.clone();
@ -149,7 +149,7 @@ impl StackLayouter {
SpacingKind::Linear(v) => {
// Resolve the linear and limit it to the remaining space.
let resolved = v.resolve(self.regions.base.get(self.axis));
let remaining = self.regions.current.get_mut(self.axis);
let remaining = self.regions.first.get_mut(self.axis);
let limited = resolved.min(*remaining);
*remaining -= limited;
self.used.main += limited;
@ -183,11 +183,11 @@ impl StackLayouter {
let len = frames.len();
for (i, frame) in frames.into_iter().enumerate() {
// Grow our size, shrink the region and save the frame for later.
let size = frame.item.size.to_gen(self.axis);
let size = frame.size.to_gen(self.axis);
self.used.main += size.main;
self.used.cross.set_max(size.cross);
*self.regions.current.get_mut(self.axis) -= size.main;
self.items.push(StackItem::Frame(frame.item, align));
*self.regions.first.get_mut(self.axis) -= size.main;
self.items.push(StackItem::Frame(frame, align));
if i + 1 < len {
self.finish_region();
@ -245,21 +245,16 @@ impl StackLayouter {
}
}
// Generate tight constraints for now.
let mut cts = Constraints::new(self.expand);
cts.exact = self.full.map(Some);
cts.base = self.regions.base.map(Some);
// Advance to the next region.
self.regions.next();
self.full = self.regions.current;
self.full = self.regions.first;
self.used = Gen::zero();
self.fr = Fractional::zero();
self.finished.push(output.constrain(cts));
self.finished.push(Arc::new(output));
}
/// Finish layouting and return the resulting frames.
pub fn finish(mut self) -> Vec<Constrained<Arc<Frame>>> {
pub fn finish(mut self) -> Vec<Arc<Frame>> {
self.finish_region();
self.finished
}

4
src/library/transform.rs
View File

@ -49,11 +49,11 @@ impl<const T: TransformKind> Layout for TransformNode<T> {
vm: &mut Vm,
regions: &Regions,
styles: StyleChain,
) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
) -> TypResult<Vec<Arc<Frame>>> {
let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
let mut frames = self.child.layout(vm, regions, styles)?;
for Constrained { item: frame, .. } in &mut frames {
for frame in &mut frames {
let Spec { x, y } = origin.zip(frame.size).map(|(o, s)| o.resolve(s));
let transform = Transform::translation(x, y)
.pre_concat(self.transform)

84
tests/typeset.rs
View File

@ -1,11 +1,10 @@
use std::env;
use std::ffi::OsStr;
use std::fs::{self, File};
use std::fs;
use std::ops::Range;
use std::path::Path;
use std::sync::Arc;
use filedescriptor::{FileDescriptor, StdioDescriptor::*};
use tiny_skia as sk;
use walkdir::WalkDir;
@ -16,7 +15,7 @@ use typst::geom::{Length, RgbaColor};
use typst::library::{PageNode, TextNode};
use typst::loading::FsLoader;
use typst::parse::Scanner;
use typst::source::{SourceFile, SourceId};
use typst::source::SourceFile;
use typst::syntax::Span;
use typst::{Context, Vm};
@ -269,19 +268,16 @@ fn test_part(
ok &= test_reparse(ctx.sources.get(id).src(), i, rng);
let mut vm = Vm::new(ctx);
let (frames, mut errors) = match vm.typeset(id) {
Ok(mut frames) => {
ok &= test_incremental(ctx, i, id, &frames);
if !compare_ref {
frames.clear();
}
(frames, vec![])
}
let (mut frames, mut errors) = match vm.typeset(id) {
Ok(frames) => (frames, vec![]),
Err(errors) => (vec![], *errors),
};
// Don't retain frames if we don't wanna compare with reference images.
if !compare_ref {
frames.clear();
}
// TODO: Also handle errors from other files.
errors.retain(|error| error.span.source == id);
for error in &mut errors {
@ -467,53 +463,6 @@ fn test_reparse(src: &str, i: usize, rng: &mut LinearShift) -> bool {
ok
}
fn test_incremental(
ctx: &mut Context,
i: usize,
id: SourceId,
frames: &[Arc<Frame>],
) -> bool {
let mut ok = true;
let reference = ctx.layout_cache.clone();
for level in 0 .. reference.levels() {
ctx.layout_cache = reference.clone();
ctx.layout_cache.retain(|x| x == level);
if ctx.layout_cache.is_empty() {
continue;
}
ctx.layout_cache.turnaround();
let cached = silenced(|| ctx.typeset(id).unwrap());
let total = reference.levels() - 1;
let misses = ctx
.layout_cache
.entries()
.filter(|e| e.level() == level && !e.hit() && e.age() == 2)
.count();
if misses > 0 {
println!(
" Subtest {i} relayout had {misses} cache misses on level {level} of {total} ❌",
);
ok = false;
}
if cached != frames {
println!(
" Subtest {i} relayout differs from clean pass on level {level} ❌",
);
ok = false;
}
}
ctx.layout_cache = reference;
ctx.layout_cache.turnaround();
ok
}
/// Draw all frames into one image with padding in between.
fn render(ctx: &mut Context, frames: &[Arc<Frame>]) -> sk::Pixmap {
let pixel_per_pt = 2.0;
@ -582,21 +531,6 @@ fn render_links(
}
}
/// Disable stdout and stderr during execution of `f`.
fn silenced<F, T>(f: F) -> T
where
F: FnOnce() -> T,
{
let path = if cfg!(windows) { "NUL" } else { "/dev/null" };
let null = File::create(path).unwrap();
let stderr = FileDescriptor::redirect_stdio(&null, Stderr).unwrap();
let stdout = FileDescriptor::redirect_stdio(&null, Stdout).unwrap();
let result = f();
FileDescriptor::redirect_stdio(&stderr, Stderr).unwrap();
FileDescriptor::redirect_stdio(&stdout, Stdout).unwrap();
result
}
/// This is an Linear-feedback shift register using XOR as its shifting
/// function. It can be used as PRNG.
struct LinearShift(u64);