Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 213 insertions, 0 deletions

diff --git a/third_party/rust/itertools/benches/tuples.rs b/third_party/rust/itertools/benches/tuples.rs
new file mode 100644
index 0000000000..ea50aaaee1
--- /dev/null
+++ b/third_party/rust/itertools/benches/tuples.rs
@@ -0,0 +1,213 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use itertools::Itertools;
+
+fn s1(a: u32) -> u32 {
+    a
+}
+
+fn s2(a: u32, b: u32) -> u32 {
+    a + b
+}
+
+fn s3(a: u32, b: u32, c: u32) -> u32 {
+    a + b + c
+}
+
+fn s4(a: u32, b: u32, c: u32, d: u32) -> u32 {
+    a + b + c + d
+}
+
+fn sum_s1(s: &[u32]) -> u32 {
+    s1(s[0])
+}
+
+fn sum_s2(s: &[u32]) -> u32 {
+    s2(s[0], s[1])
+}
+
+fn sum_s3(s: &[u32]) -> u32 {
+    s3(s[0], s[1], s[2])
+}
+
+fn sum_s4(s: &[u32]) -> u32 {
+    s4(s[0], s[1], s[2], s[3])
+}
+
+fn sum_t1(s: &(&u32, )) -> u32 {
+    s1(*s.0)
+}
+
+fn sum_t2(s: &(&u32, &u32)) -> u32 {
+    s2(*s.0, *s.1)
+}
+
+fn sum_t3(s: &(&u32, &u32, &u32)) -> u32 {
+    s3(*s.0, *s.1, *s.2)
+}
+
+fn sum_t4(s: &(&u32, &u32, &u32, &u32)) -> u32 {
+    s4(*s.0, *s.1, *s.2, *s.3)
+}
+
+macro_rules! def_benchs {
+    ($N:expr;
+     $BENCH_GROUP:ident,
+     $TUPLE_FUN:ident,
+     $TUPLES:ident,
+     $TUPLE_WINDOWS:ident;
+     $SLICE_FUN:ident,
+     $CHUNKS:ident,
+     $WINDOWS:ident;
+     $FOR_CHUNKS:ident,
+     $FOR_WINDOWS:ident
+     ) => (
+        fn $FOR_CHUNKS(c: &mut Criterion) {
+            let v: Vec<u32> = (0.. $N * 1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($FOR_CHUNKS).replace('_', " "), move |b| {
+                b.iter(|| {
+                    let mut j = 0;
+                    for _ in 0..1_000 {
+                        s += $SLICE_FUN(&v[j..(j + $N)]);
+                        j += $N;
+                    }
+                    s
+                })
+            });
+        }
+
+        fn $FOR_WINDOWS(c: &mut Criterion) {
+            let v: Vec<u32> = (0..1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($FOR_WINDOWS).replace('_', " "), move |b| {
+                b.iter(|| {
+                    for i in 0..(1_000 - $N) {
+                        s += $SLICE_FUN(&v[i..(i + $N)]);
+                    }
+                    s
+                })
+            });
+        }
+
+        fn $TUPLES(c: &mut Criterion) {
+            let v: Vec<u32> = (0.. $N * 1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($TUPLES).replace('_', " "), move |b| {
+                b.iter(|| {
+                    for x in v.iter().tuples() {
+                        s += $TUPLE_FUN(&x);
+                    }
+                    s
+                })
+            });
+        }
+
+        fn $CHUNKS(c: &mut Criterion) {
+            let v: Vec<u32> = (0.. $N * 1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($CHUNKS).replace('_', " "), move |b| {
+                b.iter(|| {
+                    for x in v.chunks($N) {
+                        s += $SLICE_FUN(x);
+                    }
+                    s
+                })
+            });
+        }
+
+        fn $TUPLE_WINDOWS(c: &mut Criterion) {
+            let v: Vec<u32> = (0..1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($TUPLE_WINDOWS).replace('_', " "), move |b| {
+                b.iter(|| {
+                    for x in v.iter().tuple_windows() {
+                        s += $TUPLE_FUN(&x);
+                    }
+                    s
+                })
+            });
+        }
+
+        fn $WINDOWS(c: &mut Criterion) {
+            let v: Vec<u32> = (0..1_000).collect();
+            let mut s = 0;
+            c.bench_function(&stringify!($WINDOWS).replace('_', " "), move |b| {
+                b.iter(|| {
+                    for x in v.windows($N) {
+                        s += $SLICE_FUN(x);
+                    }
+                    s
+                })
+            });
+        }
+
+        criterion_group!(
+            $BENCH_GROUP,
+            $FOR_CHUNKS,
+            $FOR_WINDOWS,
+            $TUPLES,
+            $CHUNKS,
+            $TUPLE_WINDOWS,
+            $WINDOWS,
+        );
+    )
+}
+
+def_benchs!{
+    1;
+    benches_1,
+    sum_t1,
+    tuple_chunks_1,
+    tuple_windows_1;
+    sum_s1,
+    slice_chunks_1,
+    slice_windows_1;
+    for_chunks_1,
+    for_windows_1
+}
+
+def_benchs!{
+    2;
+    benches_2,
+    sum_t2,
+    tuple_chunks_2,
+    tuple_windows_2;
+    sum_s2,
+    slice_chunks_2,
+    slice_windows_2;
+    for_chunks_2,
+    for_windows_2
+}
+
+def_benchs!{
+    3;
+    benches_3,
+    sum_t3,
+    tuple_chunks_3,
+    tuple_windows_3;
+    sum_s3,
+    slice_chunks_3,
+    slice_windows_3;
+    for_chunks_3,
+    for_windows_3
+}
+
+def_benchs!{
+    4;
+    benches_4,
+    sum_t4,
+    tuple_chunks_4,
+    tuple_windows_4;
+    sum_s4,
+    slice_chunks_4,
+    slice_windows_4;
+    for_chunks_4,
+    for_windows_4
+}
+
+criterion_main!(
+    benches_1,
+    benches_2,
+    benches_3,
+    benches_4,
+);