Merge branch 'master' into watch_builder

tokio-rs · Sep 17, 2023 · 6ac814c · 6ac814c
2 parents 7012700 + d247e7f
commit 6ac814c
Show file tree

Hide file tree

Showing 35 changed files with 1,080 additions and 689 deletions.
diff --git a/README.md b/README.md
@@ -218,16 +218,17 @@ releases are:
 
  * `1.20.x` - LTS release until September 2023. (MSRV 1.49)
  * `1.25.x` - LTS release until March 2024. (MSRV 1.49)
+ * `1.32.x` - LTS release until September 2024 (MSRV 1.63)
 
 Each LTS release will continue to receive backported fixes for at least a year.
 If you wish to use a fixed minor release in your project, we recommend that you
 use an LTS release.
 
 To use a fixed minor version, you can specify the version with a tilde. For
-example, to specify that you wish to use the newest `1.18.x` patch release, you
+example, to specify that you wish to use the newest `1.25.x` patch release, you
 can use the following dependency specification:
 ```text
-tokio = { version = "~1.18", features = [...] }
+tokio = { version = "~1.25", features = [...] }
 ```
 
 ### Previous LTS releases

diff --git a/benches/Cargo.toml b/benches/Cargo.toml
@@ -9,7 +9,7 @@ test-util = ["tokio/test-util"]
 
 [dependencies]
 tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-bencher = "0.1.5"
+criterion = "0.5.1"
 rand = "0.8"
 rand_chacha = "0.3"
 

diff --git a/benches/copy.rs b/benches/copy.rs
@@ -1,4 +1,4 @@
-use bencher::{benchmark_group, benchmark_main, Bencher};
+use criterion::{criterion_group, criterion_main, Criterion};
 
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
@@ -174,65 +174,77 @@ fn rt() -> tokio::runtime::Runtime {
         .unwrap()
 }
 
-fn copy_mem_to_mem(b: &mut Bencher) {
+fn copy_mem_to_mem(c: &mut Criterion) {
     let rt = rt();
 
-    b.iter(|| {
-        let task = || async {
-            let mut source = repeat(0).take(SOURCE_SIZE);
-            let mut dest = Vec::new();
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
+    c.bench_function("copy_mem_to_mem", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut source = repeat(0).take(SOURCE_SIZE);
+                let mut dest = Vec::new();
+                copy(&mut source, &mut dest).await.unwrap();
+            };
+
+            rt.block_on(task());
+        })
+    });
 }
 
-fn copy_mem_to_slow_hdd(b: &mut Bencher) {
+fn copy_mem_to_slow_hdd(c: &mut Criterion) {
     let rt = rt();
 
-    b.iter(|| {
-        let task = || async {
-            let mut source = repeat(0).take(SOURCE_SIZE);
-            let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
+    c.bench_function("copy_mem_to_slow_hdd", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut source = repeat(0).take(SOURCE_SIZE);
+                let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
+                copy(&mut source, &mut dest).await.unwrap();
+            };
+
+            rt.block_on(task());
+        })
+    });
 }
 
-fn copy_chunk_to_mem(b: &mut Bencher) {
+fn copy_chunk_to_mem(c: &mut Criterion) {
     let rt = rt();
-    b.iter(|| {
-        let task = || async {
-            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
-            let mut dest = Vec::new();
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
+
+    c.bench_function("copy_chunk_to_mem", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut source =
+                    ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
+                let mut dest = Vec::new();
+                copy(&mut source, &mut dest).await.unwrap();
+            };
+
+            rt.block_on(task());
+        })
+    });
 }
 
-fn copy_chunk_to_slow_hdd(b: &mut Bencher) {
+fn copy_chunk_to_slow_hdd(c: &mut Criterion) {
     let rt = rt();
-    b.iter(|| {
-        let task = || async {
-            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
-            let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
-            copy(&mut source, &mut dest).await.unwrap();
-        };
-
-        rt.block_on(task());
-    })
+
+    c.bench_function("copy_chunk_to_slow_hdd", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut source =
+                    ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
+                let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
+                copy(&mut source, &mut dest).await.unwrap();
+            };
+
+            rt.block_on(task());
+        })
+    });
 }
 
-benchmark_group!(
+criterion_group!(
     copy_bench,
     copy_mem_to_mem,
     copy_mem_to_slow_hdd,
     copy_chunk_to_mem,
     copy_chunk_to_slow_hdd,
 );
-benchmark_main!(copy_bench);
+criterion_main!(copy_bench);
diff --git a/benches/fs.rs b/benches/fs.rs
@@ -6,7 +6,7 @@ use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 use tokio_util::codec::{BytesCodec, FramedRead /*FramedWrite*/};
 
-use bencher::{benchmark_group, benchmark_main, Bencher};
+use criterion::{criterion_group, criterion_main, Criterion};
 
 use std::fs::File as StdFile;
 use std::io::Read as StdRead;
@@ -23,81 +23,90 @@ const BLOCK_COUNT: usize = 1_000;
 const BUFFER_SIZE: usize = 4096;
 const DEV_ZERO: &str = "/dev/zero";
 
-fn async_read_codec(b: &mut Bencher) {
+fn async_read_codec(c: &mut Criterion) {
     let rt = rt();
 
-    b.iter(|| {
-        let task = || async {
-            let file = File::open(DEV_ZERO).await.unwrap();
-            let mut input_stream = FramedRead::with_capacity(file, BytesCodec::new(), BUFFER_SIZE);
+    c.bench_function("async_read_codec", |b| {
+        b.iter(|| {
+            let task = || async {
+                let file = File::open(DEV_ZERO).await.unwrap();
+                let mut input_stream =
+                    FramedRead::with_capacity(file, BytesCodec::new(), BUFFER_SIZE);
 
-            for _i in 0..BLOCK_COUNT {
-                let _bytes = input_stream.next().await.unwrap();
-            }
-        };
+                for _i in 0..BLOCK_COUNT {
+                    let _bytes = input_stream.next().await.unwrap();
+                }
+            };
 
-        rt.block_on(task());
+            rt.block_on(task());
+        })
     });
 }
 
-fn async_read_buf(b: &mut Bencher) {
+fn async_read_buf(c: &mut Criterion) {
     let rt = rt();
 
-    b.iter(|| {
-        let task = || async {
-            let mut file = File::open(DEV_ZERO).await.unwrap();
-            let mut buffer = [0u8; BUFFER_SIZE];
-
-            for _i in 0..BLOCK_COUNT {
-                let count = file.read(&mut buffer).await.unwrap();
-                if count == 0 {
-                    break;
+    c.bench_function("async_read_buf", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut file = File::open(DEV_ZERO).await.unwrap();
+                let mut buffer = [0u8; BUFFER_SIZE];
+
+                for _i in 0..BLOCK_COUNT {
+                    let count = file.read(&mut buffer).await.unwrap();
+                    if count == 0 {
+                        break;
+                    }
                 }
-            }
-        };
+            };
 
-        rt.block_on(task());
+            rt.block_on(task());
+        });
     });
 }
 
-fn async_read_std_file(b: &mut Bencher) {
+fn async_read_std_file(c: &mut Criterion) {
     let rt = rt();
 
-    let task = || async {
-        let mut file = tokio::task::block_in_place(|| Box::pin(StdFile::open(DEV_ZERO).unwrap()));
+    c.bench_function("async_read_std_file", |b| {
+        b.iter(|| {
+            let task = || async {
+                let mut file =
+                    tokio::task::block_in_place(|| Box::pin(StdFile::open(DEV_ZERO).unwrap()));
 
-        for _i in 0..BLOCK_COUNT {
-            let mut buffer = [0u8; BUFFER_SIZE];
-            let mut file_ref = file.as_mut();
+                for _i in 0..BLOCK_COUNT {
+                    let mut buffer = [0u8; BUFFER_SIZE];
+                    let mut file_ref = file.as_mut();
 
-            tokio::task::block_in_place(move || {
-                file_ref.read_exact(&mut buffer).unwrap();
-            });
-        }
-    };
+                    tokio::task::block_in_place(move || {
+                        file_ref.read_exact(&mut buffer).unwrap();
+                    });
+                }
+            };
 
-    b.iter(|| {
-        rt.block_on(task());
+            rt.block_on(task());
+        });
     });
 }
 
-fn sync_read(b: &mut Bencher) {
-    b.iter(|| {
-        let mut file = StdFile::open(DEV_ZERO).unwrap();
-        let mut buffer = [0u8; BUFFER_SIZE];
+fn sync_read(c: &mut Criterion) {
+    c.bench_function("sync_read", |b| {
+        b.iter(|| {
+            let mut file = StdFile::open(DEV_ZERO).unwrap();
+            let mut buffer = [0u8; BUFFER_SIZE];
 
-        for _i in 0..BLOCK_COUNT {
-            file.read_exact(&mut buffer).unwrap();
-        }
+            for _i in 0..BLOCK_COUNT {
+                file.read_exact(&mut buffer).unwrap();
+            }
+        })
     });
 }
 
-benchmark_group!(
+criterion_group!(
     file,
     async_read_std_file,
     async_read_buf,
     async_read_codec,
     sync_read
 );
-
-benchmark_main!(file);
+criterion_main!(file);