sync: add mpsc::Receiver::recv_many (#6010)

benches/sync_mpsc.rs

@@ -73,6 +73,33 @@ fn contention_bounded(g: &mut BenchmarkGroup<WallTime>) {
     });
 }
 
+fn contention_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+    let rt = rt();
+
+    g.bench_function("bounded_recv_many", |b| {
+        b.iter(|| {
+            rt.block_on(async move {
+                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+
+                for _ in 0..5 {
+                    let tx = tx.clone();
+                    tokio::spawn(async move {
+                        for i in 0..1000 {
+                            tx.send(i).await.unwrap();
+                        }
+                    });
+                }
+
+                let mut buffer = Vec::<usize>::with_capacity(5_000);
+                let mut total = 0;
+                while total < 1_000 * 5 {
+                    total += rx.recv_many(&mut buffer, 5_000).await;
+                }
+            })
+        })
+    });
+}
+
 fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
     let rt = rt();
 
@@ -98,6 +125,33 @@ fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
     });
 }
 
+fn contention_bounded_full_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+    let rt = rt();
+
+    g.bench_function("bounded_full_recv_many", |b| {
+        b.iter(|| {
+            rt.block_on(async move {
+                let (tx, mut rx) = mpsc::channel::<usize>(100);
+
+                for _ in 0..5 {
+                    let tx = tx.clone();
+                    tokio::spawn(async move {
+                        for i in 0..1000 {
+                            tx.send(i).await.unwrap();
+                        }
+                    });
+                }
+
+                let mut buffer = Vec::<usize>::with_capacity(5_000);
+                let mut total = 0;
+                while total < 1_000 * 5 {
+                    total += rx.recv_many(&mut buffer, 5_000).await;
+                }
+            })
+        })
+    });
+}
+
 fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
     let rt = rt();
 
@@ -123,6 +177,33 @@ fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
     });
 }
 
+fn contention_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+    let rt = rt();
+
+    g.bench_function("unbounded_recv_many", |b| {
+        b.iter(|| {
+            rt.block_on(async move {
+                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
+
+                for _ in 0..5 {
+                    let tx = tx.clone();
+                    tokio::spawn(async move {
+                        for i in 0..1000 {
+                            tx.send(i).unwrap();
+                        }
+                    });
+                }
+
+                let mut buffer = Vec::<usize>::with_capacity(5_000);
+                let mut total = 0;
+                while total < 1_000 * 5 {
+                    total += rx.recv_many(&mut buffer, 5_000).await;
+                }
+            })
+        })
+    });
+}
+
 fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
     let rt = rt();
 
@@ -143,6 +224,28 @@ fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
     });
 }
 
+fn uncontented_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+    let rt = rt();
+
+    g.bench_function("bounded_recv_many", |b| {
+        b.iter(|| {
+            rt.block_on(async move {
+                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+
+                for i in 0..5000 {
+                    tx.send(i).await.unwrap();
+                }
+
+                let mut buffer = Vec::<usize>::with_capacity(5_000);
+                let mut total = 0;
+                while total < 1_000 * 5 {
+                    total += rx.recv_many(&mut buffer, 5_000).await;
+                }
+            })
+        })
+    });
+}
+
 fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
     let rt = rt();
 
@@ -163,6 +266,28 @@ fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
     });
 }
 
+fn uncontented_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+    let rt = rt();
+
+    g.bench_function("unbounded_recv_many", |b| {
+        b.iter(|| {
+            rt.block_on(async move {
+                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
+
+                for i in 0..5000 {
+                    tx.send(i).unwrap();
+                }
+
+                let mut buffer = Vec::<usize>::with_capacity(5_000);
+                let mut total = 0;
+                while total < 1_000 * 5 {
+                    total += rx.recv_many(&mut buffer, 5_000).await;
+                }
+            })
+        })
+    });
+}
+
 fn bench_create_medium(c: &mut Criterion) {
     let mut group = c.benchmark_group("create_medium");
     create_medium::<1>(&mut group);
@@ -181,15 +306,20 @@ fn bench_send(c: &mut Criterion) {
 fn bench_contention(c: &mut Criterion) {
     let mut group = c.benchmark_group("contention");
     contention_bounded(&mut group);
+    contention_bounded_recv_many(&mut group);
     contention_bounded_full(&mut group);
+    contention_bounded_full_recv_many(&mut group);
     contention_unbounded(&mut group);
+    contention_unbounded_recv_many(&mut group);
     group.finish();
 }
 
 fn bench_uncontented(c: &mut Criterion) {
     let mut group = c.benchmark_group("uncontented");
     uncontented_bounded(&mut group);
+    uncontented_bounded_recv_many(&mut group);
     uncontented_unbounded(&mut group);
+    uncontented_unbounded_recv_many(&mut group);
     group.finish();
 }