From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/tinyvec/benches/macros.rs | 52 ++++ vendor/tinyvec/benches/smallvec.rs | 500 +++++++++++++++++++++++++++++++++++++ 2 files changed, 552 insertions(+) create mode 100644 vendor/tinyvec/benches/macros.rs create mode 100644 vendor/tinyvec/benches/smallvec.rs (limited to 'vendor/tinyvec/benches') diff --git a/vendor/tinyvec/benches/macros.rs b/vendor/tinyvec/benches/macros.rs new file mode 100644 index 000000000..16be57b7c --- /dev/null +++ b/vendor/tinyvec/benches/macros.rs @@ -0,0 +1,52 @@ +use criterion::{criterion_group, criterion_main, Criterion}; + +use tinyvec::tiny_vec; + +fn bench_tinyvec_macro(c: &mut Criterion) { + let mut g = c.benchmark_group("tinyvec_macro"); + + g.bench_function("0 of 32", |b| { + b.iter(|| tiny_vec!([u8; 32])); + }); + + g.bench_function("16 of 32", |b| { + b.iter(|| { + tiny_vec!([u8; 32]=> + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + ) + }); + }); + + g.bench_function("32 of 32", |b| { + b.iter(|| { + tiny_vec!([u8; 32]=> + 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, + ) + }); + }); + + g.bench_function("33 of 32", |b| { + b.iter(|| { + tiny_vec!([u8; 32]=> + 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, + ) + }); + }); + + g.bench_function("64 of 32", |b| { + b.iter(|| { + tiny_vec!([u8; 32]=> + 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, + ) + }); + }); +} + +criterion_group!(benches, bench_tinyvec_macro); +criterion_main!(benches); diff --git a/vendor/tinyvec/benches/smallvec.rs b/vendor/tinyvec/benches/smallvec.rs new file mode 100644 index 000000000..8cd16d3ec --- /dev/null +++ b/vendor/tinyvec/benches/smallvec.rs @@ -0,0 +1,500 @@ +//! Benchmarks that compare TinyVec to SmallVec +//! +//! All the following commentary is based on the latest nightly at the time: +//! rustc 1.55.0 (c8dfcfe04 2021-09-06). +//! +//! Some of these benchmarks are just a few instructions, so we put our own for loop inside +//! the criterion::Bencher::iter call. This seems to improve the stability of measurements, and it +//! has the wonderful side effect of making the emitted assembly easier to follow. Some of these +//! benchmarks are totally inlined so that there are no calls at all in the hot path, so finding +//! this for loop is an easy way to find your way around the emitted assembly. +//! +//! The clear method is cheaper to call for arrays of elements without a Drop impl, so wherever +//! possible we reuse a single object in the benchmark loop, with a clear + black_box on each +//! iteration in an attempt to not make that visible to the optimizer. +//! +//! We always call black_box(&v), instead of v = black_box(v) because the latter does a move of the +//! inline array, which is linear in the size of the array and thus varies based on the array type +//! being benchmarked, and this move can be more expensive than the function we're trying to +//! benchmark. +//! +//! We also black_box the input to each method call. This has a significant effect on the assembly +//! emitted, for example if we do not black_box the range we iterate over in the ::push benchmarks, +//! the loop is unrolled. It's not entirely clear if it's better to black_box the iterator that +//! yields the items being pushed, or to black_box at a deeper level: v.push(black_box(i)) for +//! example. Anecdotally, it seems like the latter approach produces unreasonably bad assembly. +//! + +use criterion::{black_box, criterion_group, criterion_main, Criterion}; +use smallvec::SmallVec; +use std::iter::FromIterator; +use tinyvec::TinyVec; + +const ITERS: usize = 10_000; + +macro_rules! tinyvec_benches { + ($c:expr, $type:ty ; $len:expr) => {{ + let mut g = $c.benchmark_group(concat!( + "TinyVec_", + stringify!($type), + "_", + stringify!($len) + )); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::default" + ), + |b| { + b.iter(|| { + for _ in 0..ITERS { + let v: TinyVec<[$type; $len]> = TinyVec::default(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::clone" + ), + |b| { + b.iter(|| { + let outer: TinyVec<[$type; $len]> = + black_box(TinyVec::from_iter(0..=($len as usize - 1) as _)); + for _ in 0..ITERS { + let v = outer.clone(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::clear" + ), + |b| { + b.iter(|| { + let mut v: TinyVec<[$type; $len]> = TinyVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::push" + ), + |b| { + b.iter(|| { + let mut v: TinyVec<[$type; $len]> = TinyVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + for i in black_box(0..=($len as usize - 1) as _) { + v.push(i); + } + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::from_iter" + ), + |b| { + b.iter(|| { + for _ in 0..ITERS { + let v: TinyVec<[$type; $len]> = + TinyVec::from_iter(black_box(0..=($len as usize - 1) as _)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::from_slice" + ), + |b| { + b.iter(|| { + let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7]; + for _ in 0..ITERS { + let v: TinyVec<[$type; $len]> = TinyVec::from(black_box(data)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::extend" + ), + |b| { + b.iter(|| { + let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default()); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + v.extend(black_box(0..=($len as usize - 1) as _)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::extend_from_slice" + ), + |b| { + b.iter(|| { + let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]); + let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default()); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + v.extend_from_slice(data); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::insert" + ), + |b| { + b.iter(|| { + let mut v: TinyVec<[$type; $len]> = TinyVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + for i in black_box(0..=($len as usize - 1) as _) { + v.insert(i as usize, i); + } + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "TinyVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::remove" + ), + |b| { + b.iter(|| { + let outer: TinyVec<[$type; $len]> = + black_box(TinyVec::from_iter(0..=($len as usize - 1) as _)); + for _ in 0..ITERS { + let mut v = outer.clone(); + for i in black_box((0..=($len as usize - 1) as _).rev()) { + v.remove(i); + } + black_box(&v); + } + }); + }, + ); + }}; +} + +fn tinyvec_benches(c: &mut Criterion) { + tinyvec_benches!(c, u8; 8); + tinyvec_benches!(c, u8; 16); + tinyvec_benches!(c, u8; 32); + tinyvec_benches!(c, u8; 64); + tinyvec_benches!(c, u8; 128); + tinyvec_benches!(c, u8; 256); + tinyvec_benches!(c, u64; 2); + tinyvec_benches!(c, u64; 4); + tinyvec_benches!(c, u64; 8); + tinyvec_benches!(c, u64; 16); + tinyvec_benches!(c, u64; 32); +} + +macro_rules! smallvec_benches { + ($c:expr, $type:ty ; $len:expr) => {{ + let mut g = $c.benchmark_group(concat!( + "SmallVec_", + stringify!($type), + "_", + stringify!($len) + )); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::default" + ), + |b| { + b.iter(|| { + for _ in 0..ITERS { + let v: SmallVec<[$type; $len]> = SmallVec::default(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::clone" + ), + |b| { + b.iter(|| { + let outer: SmallVec<[$type; $len]> = + black_box(SmallVec::from_iter(0..=($len as usize - 1) as _)); + for _ in 0..ITERS { + let v = outer.clone(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::clear" + ), + |b| { + b.iter(|| { + let mut v: SmallVec<[$type; $len]> = SmallVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::push" + ), + |b| { + b.iter(|| { + let mut v: SmallVec<[$type; $len]> = SmallVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + for i in black_box(0..=($len as usize - 1) as _) { + v.push(i); + } + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::from_iter" + ), + |b| { + b.iter(|| { + for _ in 0..ITERS { + let v: SmallVec<[$type; $len]> = + SmallVec::from_iter(black_box(0..=($len as usize - 1) as _)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::from_slice" + ), + |b| { + b.iter(|| { + let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7]; + for _ in 0..ITERS { + let v: SmallVec<[$type; $len]> = SmallVec::from(black_box(data)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::extend" + ), + |b| { + b.iter(|| { + let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default()); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + v.extend(black_box(0..=($len as usize - 1) as _)); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::extend_from_slice" + ), + |b| { + b.iter(|| { + let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]); + let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default()); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + v.extend_from_slice(data); + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::insert" + ), + |b| { + b.iter(|| { + let mut v: SmallVec<[$type; $len]> = SmallVec::default(); + for _ in 0..ITERS { + v.clear(); + black_box(&v); + for i in black_box(0..=($len as usize - 1) as _) { + v.insert(i as usize, i); + } + black_box(&v); + } + }); + }, + ); + + g.bench_function( + concat!( + "SmallVec<[", + stringify!($type), + "; ", + stringify!($len), + "]>::remove" + ), + |b| { + b.iter(|| { + let outer: SmallVec<[$type; $len]> = + black_box(SmallVec::from_iter(0..=($len as usize - 1) as _)); + for _ in 0..ITERS { + let mut v = outer.clone(); + for i in black_box((0..=($len as usize - 1) as _).rev()) { + v.remove(i); + } + black_box(&v); + } + }); + }, + ); + }}; +} + +fn smallvec_benches(c: &mut Criterion) { + smallvec_benches!(c, u8; 8); + smallvec_benches!(c, u8; 16); + smallvec_benches!(c, u8; 32); + smallvec_benches!(c, u8; 64); + smallvec_benches!(c, u8; 128); + smallvec_benches!(c, u8; 256); + smallvec_benches!(c, u64; 2); + smallvec_benches!(c, u64; 4); + smallvec_benches!(c, u64; 8); + smallvec_benches!(c, u64; 16); + smallvec_benches!(c, u64; 32); +} + +criterion_group!(benches, tinyvec_benches, smallvec_benches); +criterion_main!(benches); -- cgit v1.2.3