Vendor dependencies for 0.3.0 release

vendor/read-fonts/benches/bench_helper.rs

@@ -0,0 +1,17 @@
+use read_fonts::collections::IntSet;
+
+use rand::Rng;
+
+pub fn random_set(size: u32, max_value: u32) -> IntSet<u32> {
+    let mut rng = rand::thread_rng();
+    let mut set = IntSet::<u32>::empty();
+    for _ in 0..size {
+        loop {
+            let candidate: u32 = rng.gen::<u32>() % max_value;
+            if set.insert(candidate) {
+                break;
+            }
+        }
+    }
+    set
+}

vendor/read-fonts/benches/int_set_benchmark.rs

@@ -0,0 +1,145 @@
+mod bench_helper;
+use bench_helper::random_set;
+use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use read_fonts::collections::IntSet;
+
+struct SetTest {
+    set_size: u32,
+    density: u32,
+}
+
+impl SetTest {
+    fn max_value(&self) -> u32 {
+        self.density * self.set_size
+    }
+}
+
+impl std::fmt::Display for SetTest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/{}", self.set_size, self.density)
+    }
+}
+
+fn set_parameters() -> Vec<SetTest> {
+    let mut inputs: Vec<SetTest> = Vec::<SetTest>::new();
+    for density in [2, 8, 64, 512] {
+        for set_size in [1024, 4096, 32_768, 65_536] {
+            inputs.push(SetTest { set_size, density })
+        }
+    }
+    inputs
+}
+
+pub fn insert_benchmark(c: &mut Criterion) {
+    const NUM_INSERTS: u32 = 1000;
+    let inputs = set_parameters();
+
+    for input in inputs {
+        c.bench_with_input(
+            BenchmarkId::new("BM_SetInsert_1000", &input),
+            &input,
+            |b, p: &SetTest| {
+                let set = random_set(p.set_size, p.max_value());
+                b.iter_batched(
+                    || set.clone(),
+                    |mut s| {
+                        for i in 0..NUM_INSERTS {
+                            let v: u32 = i.wrapping_mul(2_654_435_761) % p.max_value();
+                            s.insert(v);
+                        }
+                    },
+                    BatchSize::SmallInput,
+                )
+            },
+        );
+    }
+}
+
+pub fn ordered_extend_benchmark(c: &mut Criterion) {
+    let num_inserts = 1000u32;
+    let inputs = set_parameters();
+
+    for input in inputs {
+        c.bench_with_input(
+            BenchmarkId::new("BM_SetOrderedInsert_1000", &input),
+            &input,
+            |b, p: &SetTest| {
+                let set = random_set(p.set_size, p.max_value());
+                b.iter_batched(
+                    || set.clone(),
+                    |mut s| {
+                        s.extend(0..num_inserts);
+                    },
+                    BatchSize::SmallInput,
+                )
+            },
+        );
+    }
+}
+
+pub fn lookup_random_benchmark(c: &mut Criterion) {
+    let inputs = set_parameters();
+
+    for input in inputs {
+        let set = random_set(input.set_size, input.max_value());
+        let mut needle = input.max_value() / 2;
+        c.bench_with_input(
+            BenchmarkId::new("BM_SetLookup/random", &input),
+            &set,
+            |b, s: &IntSet<u32>| {
+                b.iter(|| {
+                    needle += 12345;
+                    s.contains(needle % input.max_value())
+                })
+            },
+        );
+    }
+}
+
+pub fn lookup_ordered_benchmark(c: &mut Criterion) {
+    let inputs = set_parameters();
+
+    for input in inputs {
+        let set = random_set(input.set_size, input.max_value());
+        let mut needle = input.max_value() / 2;
+        c.bench_with_input(
+            BenchmarkId::new("BM_SetLookup/ordered", &input),
+            &set,
+            |b, s: &IntSet<u32>| {
+                b.iter(|| {
+                    needle += 3;
+                    s.contains(needle % input.max_value())
+                })
+            },
+        );
+    }
+}
+
+pub fn iteration_benchmark(c: &mut Criterion) {
+    let inputs = set_parameters();
+
+    for input in inputs {
+        let set = random_set(input.set_size, input.max_value());
+        c.bench_with_input(
+            BenchmarkId::new("BM_SetIteration", &input),
+            &set,
+            |b, s: &IntSet<u32>| {
+                b.iter(|| {
+                    for v in s.iter() {
+                        black_box(v);
+                    }
+                })
+            },
+        );
+    }
+}
+
+criterion_group!(
+    benches,
+    insert_benchmark,
+    ordered_extend_benchmark,
+    lookup_random_benchmark,
+    lookup_ordered_benchmark,
+    iteration_benchmark,
+);
+criterion_main!(benches);

vendor/read-fonts/benches/sparse_bit_set_benchmark.rs

@@ -0,0 +1,68 @@
+mod bench_helper;
+
+use bench_helper::random_set;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use read_fonts::collections::int_set::{sparse_bit_set::to_sparse_bit_set_with_bf, IntSet};
+
+struct SparseSetTest {
+    set_size: u32,
+    density: u32,
+    branch_factor: u32,
+}
+
+impl SparseSetTest {
+    fn max_value(&self) -> u32 {
+        self.density * self.set_size
+    }
+}
+
+impl std::fmt::Display for SparseSetTest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "bf{}_{}/{}",
+            self.branch_factor, self.set_size, self.density
+        )
+    }
+}
+
+fn set_parameters() -> Vec<SparseSetTest> {
+    let mut inputs: Vec<SparseSetTest> = Vec::<SparseSetTest>::new();
+    for branch_factor in [2, 4, 8, 32] {
+        for density in [2, 8] {
+            for set_size in [1024, 4096, 32_768] {
+                inputs.push(SparseSetTest {
+                    set_size,
+                    density,
+                    branch_factor,
+                })
+            }
+        }
+    }
+    inputs
+}
+
+pub fn decode_benchmark(c: &mut Criterion) {
+    let inputs = set_parameters();
+
+    for input in inputs {
+        let set = random_set(input.set_size, input.max_value());
+        let encoded = match input.branch_factor {
+            2 => to_sparse_bit_set_with_bf::<2>(&set),
+            4 => to_sparse_bit_set_with_bf::<4>(&set),
+            8 => to_sparse_bit_set_with_bf::<8>(&set),
+            32 => to_sparse_bit_set_with_bf::<32>(&set),
+            _ => panic!("not implemented."),
+        };
+        c.bench_with_input(
+            BenchmarkId::new("BM_SparseSetDecode", &input),
+            &input,
+            |b, _: &SparseSetTest| {
+                b.iter(|| black_box(IntSet::<u32>::from_sparse_bit_set(&encoded)));
+            },
+        );
+    }
+}
+
+criterion_group!(benches, decode_benchmark);
+criterion_main!(benches);