Add time to supported wasm features

.cargo/config

@@ -0,0 +1,2 @@
+# [build]
+# rustflags = ["--cfg", "tokio_unstable"]

.circleci/config.yml

@@ -22,4 +22,4 @@ jobs:
 workflows:
   ci:
     jobs:
-      - test-arm
+      - test-arm

.cirrus.yml

@@ -1,10 +1,8 @@
-only_if: $CIRRUS_TAG == '' && ($CIRRUS_PR != '' || $CIRRUS_BRANCH == 'master' || $CIRRUS_BRANCH =~ 'tokio-.*')
-auto_cancellation: $CIRRUS_BRANCH != 'master' && $CIRRUS_BRANCH !=~ 'tokio-.*'
 freebsd_instance:
-  image_family: freebsd-13-1
+  image: freebsd-12-3-release-amd64
 env:
   RUST_STABLE: stable
-  RUST_NIGHTLY: nightly-2022-10-25
+  RUST_NIGHTLY: nightly-2022-03-21
   RUSTFLAGS: -D warnings
 
 # Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the
@@ -14,7 +12,7 @@ env:
 task:
   name: FreeBSD 64-bit
   setup_script:
-    - pkg install -y bash
+    - pkg install -y bash curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
     - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
     - . $HOME/.cargo/env
@@ -31,7 +29,7 @@ task:
     RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
     RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
   setup_script:
-    - pkg install -y bash
+    - pkg install -y bash curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
     - sh rustup.sh -y --profile minimal --default-toolchain $RUST_NIGHTLY
     - . $HOME/.cargo/env
@@ -45,7 +43,7 @@ task:
 task:
   name: FreeBSD 32-bit
   setup_script:
-    - pkg install -y bash
+    - pkg install -y bash curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
     - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
     - . $HOME/.cargo/env

.clippy.toml

@@ -1 +1 @@
-msrv = "1.56"
+msrv = "1.49"

.github/labeler.yml

@@ -1,28 +1,8 @@
 
-R-loom-sync:
+R-loom:
 - tokio/src/sync/*
 - tokio/src/sync/**/*
-
-R-loom-time-driver:
-- tokio/src/runtime/time/*
-- tokio/src/runtime/time/**/*
-
-R-loom-current-thread:
-- tokio/src/runtime/scheduler/*
-- tokio/src/runtime/scheduler/current_thread/*
-- tokio/src/runtime/task/*
-- tokio/src/runtime/task/**
-
-R-loom-multi-thread:
-- tokio/src/runtime/scheduler/*
-- tokio/src/runtime/scheduler/multi_thread/*
-- tokio/src/runtime/scheduler/multi_thread/**
-- tokio/src/runtime/task/*
-- tokio/src/runtime/task/**
-
-R-loom-multi-thread-alt:
-- tokio/src/runtime/scheduler/*
-- tokio/src/runtime/scheduler/multi_thread_alt/*
-- tokio/src/runtime/scheduler/multi_thread_alt/**
-- tokio/src/runtime/task/*
-- tokio/src/runtime/task/**
+- tokio-util/src/sync/*
+- tokio-util/src/sync/**/*
+- tokio/src/runtime/*
+- tokio/src/runtime/**/*

.github/workflows/audit.yml

@@ -9,22 +9,14 @@ on:
   schedule:
     - cron: '0 2 * * *' # run at 2 AM UTC
 
-permissions:
-  contents: read
-
 jobs:
   security-audit:
-    permissions:
-      checks: write  # for rustsec/audit-check to create check
-      contents: read  # for actions/checkout to fetch code
-      issues: write  # for rustsec/audit-check to create issues
     runs-on: ubuntu-latest
     if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
       - uses: actions/checkout@v3
 
       - name: Audit Check
-        # https://github.com/rustsec/audit-check/issues/2
-        uses: rustsec/audit-check@master
+        uses: actions-rs/audit-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -6,17 +6,13 @@ on:
 
 name: CI
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
   # Change to specific Rust release to pin
   rust_stable: stable
-  rust_nightly: nightly-2023-05-18
-  rust_clippy: 1.65.0
+  rust_nightly: nightly-2022-07-26
+  rust_clippy: 1.52.0
   # When updating this, also update:
   # - README.md
   # - tokio/README.md
@@ -25,34 +21,25 @@ env:
   # - tokio-util/Cargo.toml
   # - tokio-test/Cargo.toml
   # - tokio-stream/Cargo.toml
-  rust_min: 1.63.0
+  rust_min: 1.49.0
 
 defaults:
   run:
     shell: bash
 
-permissions:
-  contents: read
-
 jobs:
-  # Depends on all actions that are required for a "successful" CI run.
+  # Depends on all action sthat are required for a "successful" CI run.
   tests-pass:
     name: all systems go
     runs-on: ubuntu-latest
     needs:
-      - test-tokio-full
-      - test-workspace-all-features
-      - test-integration-tests-per-feature
+      - test
       - test-parking_lot
       - valgrind
       - test-unstable
       - miri
       - asan
-      - cross-check
-      - cross-test-with-parking_lot
-      - cross-test-without-parking_lot
-      - no-atomic-u64-test
-      - no-atomic-u64-check
+      - cross
       - features
       - minrust
       - minimal-versions
@@ -62,30 +49,13 @@ jobs:
       - loom-compile
       - check-readme
       - test-hyper
-      - x86_64-fortanix-unknown-sgx
-      - check-redox
       - wasm32-unknown-unknown
       - wasm32-wasi
       - check-external-types
-      - check-fuzzing
-      - check-unstable-mt-counters
     steps:
       - run: exit 0
 
-  # Basic actions that must pass before we kick off more expensive tests.
-  basics:
-    name: basic checks
-    runs-on: ubuntu-latest
-    needs:
-      - clippy
-      - fmt
-      - docs
-      - minrust
-    steps:
-      - run: exit 0
-
-  test-tokio-full:
-    needs: basics
+  test:
     name: test tokio full
     runs-on: ${{ matrix.os }}
     strategy:
@@ -97,77 +67,25 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - name: Install Rust
+        run: rustup update stable
+      - uses: Swatinem/rust-cache@v1
+      - name: Install cargo-hack
+        run: cargo install cargo-hack
 
       # Run `tokio` with `full` features. This excludes testing utilities which
       # can alter the runtime behavior of Tokio.
       - name: test tokio full
-        run: |
-          set -euxo pipefail
-          cargo nextest run --features full
-          cargo test --doc --features full
+        run: cargo test --features full
         working-directory: tokio
 
-  test-workspace-all-features:
-    needs: basics
-    name: test all crates in the workspace with all features
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: Swatinem/rust-cache@v2
-
       # Test **all** crates in the workspace with all features.
       - name: test all --all-features
-        run: |
-          set -euxo pipefail
-          cargo nextest run --workspace --all-features
-          cargo test --doc --workspace --all-features
-
-  test-integration-tests-per-feature:
-    needs: basics
-    name: Run integration tests for each feature
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-hack
-
-      - uses: Swatinem/rust-cache@v2
+        run: cargo test --workspace --all-features
 
       # Run integration tests for each feature
       - name: test tests-integration --each-feature
@@ -179,9 +97,9 @@ jobs:
         run: cargo hack test --each-feature
         working-directory: tests-build
 
-      # Check benchmarks. Run of benchmarks is done by bench.yml workflow.
-      - name: Check benches
-        run: cargo check --benches
+      # Build benchmarks. Run of benchmarks is done by bench.yml workflow.
+      - name: build benches
+        run: cargo build --benches
         working-directory: benches
         # bench.yml workflow runs benchmarks only on linux.
         if: startsWith(matrix.os, 'ubuntu')
@@ -195,38 +113,38 @@ jobs:
     # This relies on the potentially affected Tokio type being listed in
     # `tokio/tokio/tests/async_send_sync.rs`.
     name: compile tests with parking lot send guards
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-
+            override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Enable parking_lot send_guard feature
         # Inserts the line "plsend = ["parking_lot/send_guard"]" right after [features]
         run: sed -i '/\[features\]/a plsend = ["parking_lot/send_guard"]' tokio/Cargo.toml
-
-      - uses: Swatinem/rust-cache@v2
-      - name: Check tests with all features enabled
-        run: cargo check --workspace --all-features --tests
+      - name: Compile tests with all features enabled
+        run: cargo build --workspace --all-features --tests
 
   valgrind:
     name: valgrind
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
+            override: true
+      - uses: Swatinem/rust-cache@v1
 
       - name: Install Valgrind
-        uses: taiki-e/install-action@valgrind
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y valgrind
 
-      - uses: Swatinem/rust-cache@v2
       # Compile tests
       - name: cargo build test-mem
         run: cargo build --features rt-net --bin test-mem
@@ -234,7 +152,7 @@ jobs:
 
       # Run with valgrind
       - name: Run valgrind test-mem
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all --fair-sched=yes ./target/debug/test-mem
+        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/debug/test-mem
 
       # Compile tests
       - name: cargo build test-process-signal
@@ -243,37 +161,28 @@ jobs:
 
       # Run with valgrind
       - name: Run valgrind test-process-signal
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all --fair-sched=yes ./target/debug/test-process-signal
+        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/debug/test-process-signal
 
   test-unstable:
     name: test tokio full --unstable
-    needs: basics
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        include:
-          - os: windows-latest
-          - os: ubuntu-latest
-          - os: macos-latest
+        os:
+          - windows-latest
+          - ubuntu-latest
+          - macos-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - uses: Swatinem/rust-cache@v1
       # Run `tokio` with "unstable" cfg flag.
       - name: test tokio full --cfg unstable
-        run: |
-          set -euxo pipefail
-          cargo nextest run --all-features
-          cargo test --doc --all-features
+        run: cargo test --all-features
         working-directory: tokio
         env:
           RUSTFLAGS: --cfg tokio_unstable -Dwarnings
@@ -281,96 +190,29 @@ jobs:
           # the unstable cfg to RustDoc
           RUSTDOCFLAGS: --cfg tokio_unstable
 
-  test-unstable-taskdump:
-    name: test tokio full --unstable --taskdump
-    needs: basics
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-            toolchain: ${{ env.rust_stable }}
-
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: Swatinem/rust-cache@v2
-      # Run `tokio` with "unstable" and "taskdump" cfg flags.
-      - name: test tokio full --cfg unstable --cfg taskdump
-        run: |
-          set -euxo pipefail
-          cargo nextest run --all-features
-          cargo test --doc --all-features
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg tokio_unstable --cfg tokio_taskdump -Dwarnings
-          # in order to run doctests for unstable features, we must also pass
-          # the unstable cfg to RustDoc
-          RUSTDOCFLAGS: --cfg tokio_unstable --cfg tokio_taskdump
-
-  check-unstable-mt-counters:
-    name: check tokio full --internal-mt-counters
-    needs: basics
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-      - uses: Swatinem/rust-cache@v2
-      # Run `tokio` with "unstable" and "taskdump" cfg flags.
-      - name: check tokio full --cfg unstable --cfg internal-mt-counters
-        run: |
-          set -euxo pipefail
-          cargo nextest run --all-features
-          cargo test --doc --all-features
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg tokio_unstable --cfg tokio_internal_mt_counters -Dwarnings
-          # in order to run doctests for unstable features, we must also pass
-          # the unstable cfg to RustDoc
-          RUSTDOCFLAGS: --cfg tokio_unstable --cfg tokio_internal_mt_counters
-
   miri:
     name: miri
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
           components: miri
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: miri
         # Many of tests in tokio/tests and doctests use #[tokio::test] or
         # #[tokio::main] that calls epoll_create1 that Miri does not support.
-        run: |
-          cargo miri test --features full --lib --no-fail-fast
+        run: cargo miri test --features full --lib --no-fail-fast
         working-directory: tokio
         env:
-          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-strict-provenance -Zmiri-retag-fields
+          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-tag-raw-pointers
+          PROPTEST_CASES: 10
 
   asan:
     name: asan
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
@@ -378,218 +220,72 @@ jobs:
         # Required to resolve symbols in sanitizer output
         run: sudo apt-get install -y llvm
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: asan
-        run: cargo test --workspace --all-features --target x86_64-unknown-linux-gnu --tests -- --test-threads 1 --nocapture
+        run: cargo test --workspace --all-features --target x86_64-unknown-linux-gnu --tests -- --test-threads 1
         env:
-          RUSTFLAGS: -Z sanitizer=address --cfg tokio_no_tuning_tests
+          RUSTFLAGS: -Z sanitizer=address
           # Ignore `trybuild` errors as they are irrelevant and flaky on nightly
           TRYBUILD: overwrite
 
-  semver:
-    name: semver
-    needs: basics
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Check semver
-        uses: obi1kenobi/cargo-semver-checks-action@v2
-        with:
-          rust-toolchain: ${{ env.rust_stable }}
-          release-type: minor
-
-  cross-check:
-    name: cross-check
-    needs: basics
+  cross:
+    name: cross
     runs-on: ubuntu-latest
     strategy:
       matrix:
         target:
+          - i686-unknown-linux-gnu
           - powerpc-unknown-linux-gnu
           - powerpc64-unknown-linux-gnu
+          - mips-unknown-linux-gnu
           - arm-linux-androideabi
+          - mipsel-unknown-linux-musl
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
           target: ${{ matrix.target }}
-
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo check --workspace --all-features --target ${{ matrix.target }}
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: check
+          args: --workspace --all-features --target ${{ matrix.target }}
+      - uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: check
+          args: --workspace --all-features --target ${{ matrix.target }}
         env:
           RUSTFLAGS: --cfg tokio_unstable -Dwarnings
 
-  cross-test-with-parking_lot:
-    needs: basics
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - target: i686-unknown-linux-gnu
-            rustflags: --cfg tokio_taskdump
-          - target: armv5te-unknown-linux-gnueabi
-          - target: armv7-unknown-linux-gnueabihf
-          - target: aarch64-unknown-linux-gnu
-            rustflags: --cfg tokio_taskdump
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.rust_stable }}
-          target: ${{ matrix.target }}
-
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: taiki-e/setup-cross-toolchain-action@v1
-        with:
-          target: ${{ matrix.target }}
-
-      - uses: Swatinem/rust-cache@v2
-      - name: Tests run with all features (including parking_lot)
-        run: |
-          set -euxo pipefail
-          cargo nextest run -p tokio --all-features --target ${{ matrix.target }}
-          cargo test --doc -p tokio --all-features --target ${{ matrix.target }}
-        env:
-          RUST_TEST_THREADS: 1
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_tuning_tests ${{ matrix.rustflags }}
-
-  cross-test-without-parking_lot:
-    needs: basics
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - target: i686-unknown-linux-gnu
-            rustflags: --cfg tokio_taskdump
-          - target: armv5te-unknown-linux-gnueabi
-          - target: armv7-unknown-linux-gnueabihf
-          - target: aarch64-unknown-linux-gnu
-            rustflags: --cfg tokio_taskdump
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.rust_stable }}
-          target: ${{ matrix.target }}
-
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: taiki-e/setup-cross-toolchain-action@v1
-        with:
-          target: ${{ matrix.target }}
-
-      - name: Remove `parking_lot` from `full` feature
-        run: sed -i '0,/parking_lot/{/parking_lot/d;}' tokio/Cargo.toml
-
-      - uses: Swatinem/rust-cache@v2
-      # The `tokio_no_parking_lot` cfg is here to ensure the `sed` above does not silently break.
-      - name: Tests run with all features (without parking_lot)
-        run: |
-          set -euxo pipefail
-          cargo nextest run -p tokio --features full,test-util --target ${{ matrix.target }}
-          cargo test --doc -p tokio --features full,test-util --target ${{ matrix.target }}
-        env:
-          RUST_TEST_THREADS: 1
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings --cfg tokio_no_parking_lot --cfg tokio_no_tuning_tests ${{ matrix.rustflags }}
-
-  # See https://github.com/tokio-rs/tokio/issues/5187
-  no-atomic-u64-test:
-    name: Test tokio --all-features on i686-unknown-linux-gnu without AtomicU64
-    needs: basics
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          components: rust-src
-
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-
-      - uses: taiki-e/setup-cross-toolchain-action@v1
-        with:
-          target: i686-unknown-linux-gnu
-
-      - uses: Swatinem/rust-cache@v2
-      - name: test tokio --all-features
-        run: |
-          cargo nextest run -Zbuild-std --target target-specs/i686-unknown-linux-gnu.json -p tokio --all-features
-          cargo test --doc -Zbuild-std --target target-specs/i686-unknown-linux-gnu.json -p tokio --all-features
-        env:
-          RUST_TEST_THREADS: 1
-          RUSTFLAGS: --cfg tokio_unstable --cfg tokio_taskdump -Dwarnings --cfg tokio_no_tuning_tests
-
-  no-atomic-u64-check:
-    name: Check tokio --feature-powerset --depth 2 on i686-unknown-linux-gnu without AtomicU64
-    needs: basics
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          components: rust-src
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-hack
-
-      - uses: Swatinem/rust-cache@v2
-
-      # https://github.com/tokio-rs/tokio/pull/5356
-      # https://github.com/tokio-rs/tokio/issues/5373
-      - name: Check
-        run: cargo hack check -Zbuild-std --target target-specs/i686-unknown-linux-gnu.json -p tokio --feature-powerset --depth 2 --keep-going
-        env:
-          RUSTFLAGS: --cfg tokio_unstable --cfg tokio_taskdump -Dwarnings
-
   features:
-    name: features ${{ matrix.name }}
-    needs: basics
+    name: features
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - { name: "", rustflags: "" }
-          # Try with unstable feature flags
-          - { name: "--unstable", rustflags: "--cfg tokio_unstable -Dwarnings" }
-          # Try with unstable and taskdump feature flags
-          - { name: "--unstable --taskdump", rustflags: "--cfg tokio_unstable -Dwarnings --cfg tokio_taskdump" }
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
           target: ${{ matrix.target }}
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-
-      - uses: Swatinem/rust-cache@v2
-      - name: check --feature-powerset ${{ matrix.name }}
-        run: cargo hack check --all --feature-powerset --depth 2 --keep-going
+        run: cargo install cargo-hack
+      - name: check --each-feature
+        run: cargo hack check --all --each-feature -Z avoid-dev-deps
+      # Try with unstable feature flags
+      - name: check --each-feature --unstable
+        run: cargo hack check --all --each-feature -Z avoid-dev-deps
         env:
-          RUSTFLAGS: ${{ matrix.rustflags }}
+          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
 
   minrust:
     name: minrust
@@ -597,29 +293,27 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_min }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_min }}
-      - uses: Swatinem/rust-cache@v2
-      - name: "check --workspace --all-features"
+          override: true
+      - uses: Swatinem/rust-cache@v1
+      - name: "test --workspace --all-features"
         run: cargo check --workspace --all-features
-        env:
-          RUSTFLAGS: "" # remove -Dwarnings
 
   minimal-versions:
     name: minimal-versions
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-
-      - uses: Swatinem/rust-cache@v2
+        run: cargo install cargo-hack
       - name: "check --all-features -Z minimal-versions"
         run: |
           # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
@@ -630,7 +324,7 @@ jobs:
           cargo hack check --all-features --ignore-private
       - name: "check --all-features --unstable -Z minimal-versions"
         env:
-          RUSTFLAGS: --cfg tokio_unstable --cfg tokio_taskdump -Dwarnings
+          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
         run: |
           # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
           # from determining minimal versions based on dev-dependencies.
@@ -645,17 +339,18 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
+          override: true
           components: rustfmt
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
       # Check fmt
       - name: "rustfmt --check"
         # Workaround for rust-lang/cargo#7732
         run: |
-          if ! rustfmt --check --edition 2021 $(git ls-files '*.rs'); then
-            printf "Please run \`rustfmt --edition 2021 \$(git ls-files '*.rs')\` to fix rustfmt errors.\nSee CONTRIBUTING.md for more details.\n" >&2
+          if ! rustfmt --check --edition 2018 $(git ls-files '*.rs'); then
+            printf "Please run \`rustfmt --edition 2018 \$(git ls-files '*.rs')\` to fix rustfmt errors.\nSee CONTRIBUTING.md for more details.\n" >&2
             exit 1
           fi
 
@@ -665,14 +360,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_clippy }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_clippy }}
+          override: true
           components: clippy
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
       # Run clippy
       - name: "clippy --all"
-        run: cargo clippy --all --tests --all-features --no-deps
+        run: cargo clippy --all --tests --all-features
 
   docs:
     name: docs
@@ -680,28 +376,28 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: "doc --lib --all-features"
-        run: |
-          cargo doc --lib --no-deps --all-features --document-private-items
+        run: cargo doc --lib --no-deps --all-features --document-private-items
         env:
-          RUSTFLAGS: --cfg docsrs --cfg tokio_unstable --cfg tokio_taskdump
-          RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable --cfg tokio_taskdump -Dwarnings
+          RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
+          RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
 
   loom-compile:
     name: build loom tests
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: build --cfg loom
         run: cargo test --no-run --lib --features full
         working-directory: tokio
@@ -722,7 +418,6 @@ jobs:
 
   test-hyper:
     name: Test hyper
-    needs: basics
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -733,23 +428,19 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-
-      - name: Clone hyper
-        run: git clone https://github.com/hyperium/hyper.git
-
-      - name: Checkout the latest release because HEAD maybe contains breakage.
+          override: true
+      - uses: Swatinem/rust-cache@v1
+      - name: Test hyper
         run: |
           set -x
+          git clone https://github.com/hyperium/hyper.git
+          cd hyper
+          # checkout the latest release because HEAD maybe contains breakage.
           tag=$(git describe --abbrev=0 --tags)
           git checkout "${tag}"
-        working-directory: hyper
-
-      - name: Patch hyper to use tokio from this repository
-        run: |
-          set -x
           echo '[workspace]' >>Cargo.toml
           echo '[patch.crates-io]' >>Cargo.toml
           echo 'tokio = { path = "../tokio" }' >>Cargo.toml
@@ -757,90 +448,50 @@ jobs:
           echo 'tokio-stream = { path = "../tokio-stream" }' >>Cargo.toml
           echo 'tokio-test = { path = "../tokio-test" }' >>Cargo.toml
           git diff
-        working-directory: hyper
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # The cargo workspaces and target directory configuration.
-          # These entries are separated by newlines and have the form
-          # `$workspace -> $target`. The `$target` part is treated as a directory
-          # relative to the `$workspace` and defaults to "target" if not explicitly given.
-          # default: ". -> target"
-          workspaces: "./hyper"
-
-      - name: Test hyper
-        run: cargo test --features full
-        working-directory: hyper
-
-  x86_64-fortanix-unknown-sgx:
-    name: build tokio for x86_64-fortanix-unknown-sgx
-    needs: basics
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          target: x86_64-fortanix-unknown-sgx
-      - uses: Swatinem/rust-cache@v2
-      # NOTE: Currently the only test we can run is to build tokio with rt and sync features.
-      - name: build tokio
-        run: cargo build --target x86_64-fortanix-unknown-sgx --features rt,sync
-        working-directory: tokio
-
-  check-redox:
-    name: build tokio for redox-os
-    needs: basics
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          target: x86_64-unknown-redox
-      - name: check tokio on redox
-        run: cargo check --target x86_64-unknown-redox --all-features
-        working-directory: tokio
+          cargo test --features full
 
   wasm32-unknown-unknown:
     name: test tokio for wasm32-unknown-unknown
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
+          override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install wasm-pack
-        uses: taiki-e/install-action@wasm-pack
-
-      - uses: Swatinem/rust-cache@v2
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
       - name: test tokio
         run: wasm-pack test --node -- --features "macros sync"
         working-directory: tokio
 
   wasm32-wasi:
     name: wasm32-wasi
-    needs: basics
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_stable }}
-          targets: wasm32-wasi
+          override: true
+      - uses: Swatinem/rust-cache@v1
 
       # Install dependencies
-      - name: Install cargo-hack, wasmtime, and cargo-wasi
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-hack,wasmtime,cargo-wasi
+      - name: Install cargo-hack
+        run: cargo install cargo-hack
+
+      - name: Install wasm32-wasi target
+        run: rustup target add wasm32-wasi
+
+      - name: Install wasmtime
+        run: cargo install wasmtime-cli
+
+      - name: Install cargo-wasi
+        run: cargo install cargo-wasi
 
-      - uses: Swatinem/rust-cache@v2
       - name: WASI test tokio full
         run: cargo test -p tokio --target wasm32-wasi --features full
         env:
@@ -865,49 +516,25 @@ jobs:
         working-directory: tests-integration
 
   check-external-types:
-    name: check-external-types (${{ matrix.os }})
-    needs: basics
+    name: check-external-types
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os:
           - windows-latest
           - ubuntu-latest
-        rust:
-          # `check-external-types` requires a specific Rust nightly version. See
-          # the README for details: https://github.com/awslabs/cargo-check-external-types
-          - nightly-2023-05-31
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ matrix.rust }}
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: ${{ matrix.rust }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Install cargo-check-external-types
-        uses: taiki-e/cache-cargo-install-action@v1
-        with:
-          tool: [email protected]
-      - name: check-external-types
-        run: cargo check-external-types --all-features --config external-types.toml
-        working-directory: tokio
-
-  check-fuzzing:
-    name: check-fuzzing
-    needs: basics
-    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_nightly }}
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: ${{ env.rust_nightly }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Install cargo-fuzz
-        run: cargo install cargo-fuzz
-      - name: Check /tokio/
-        run: cargo fuzz check --all-features
+          override: true
+      - uses: Swatinem/rust-cache@v1
+      - name: check-external-types
+        run: |
+          set -x
+          cargo install cargo-check-external-types --locked --version 0.1.3
+          cargo check-external-types --all-features --config external-types.toml
         working-directory: tokio
-      - name: Check /tokio-stream/
-        run: cargo fuzz check --all-features
-        working-directory: tokio-stream
+

.github/workflows/labeler.yml

@@ -4,18 +4,8 @@ on:
 
 # See .github/labeler.yml file
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
 jobs:
   triage:
-    permissions:
-      contents: read  # for actions/labeler to determine modified files
-      pull-requests: write  # for actions/labeler to add labels to PRs
     runs-on: ubuntu-latest
     if: github.repository_owner == 'tokio-rs'
     steps:

.github/workflows/loom.yml

@@ -7,116 +7,39 @@ on:
 
 name: Loom
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
 env:
-  RUSTFLAGS: -Dwarnings --cfg loom --cfg tokio_unstable -C debug_assertions
-  LOOM_MAX_PREEMPTIONS: 2
-  LOOM_MAX_BRANCHES: 10000
+  RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
   # Change to specific Rust release to pin
   rust_stable: stable
 
-permissions:
-  contents: read
-
 jobs:
-  loom-sync:
-    name: loom tokio::sync
+  loom:
+    name: loom
     # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-sync') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: run tests
-        run: cargo test --lib --release --features full -- --nocapture sync::tests
-        working-directory: tokio
-
-  loom-time-driver:
-    name: loom time driver
-    # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-time-driver') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: run tests
-        run: cargo test --lib --release --features full -- --nocapture runtime::time::tests
-        working-directory: tokio
-
-  loom-current-thread:
-    name: loom current-thread scheduler
-    # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-current-thread') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: run tests
-        run: cargo test --lib --release --features full -- --nocapture loom_current_thread
-        working-directory: tokio
-
-  loom-multi-thread:
-    name: loom multi-thread scheduler
-    # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-multi-thread') || (github.base_ref == null))
+    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom') || (github.base_ref == null))
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        include:
-          - scope: loom_multi_thread::group_a
-          - scope: loom_multi_thread::group_b
-          - scope: loom_multi_thread::group_c
-          - scope: loom_multi_thread::group_d
+        scope:
+          - --skip loom_pool
+          - loom_pool::group_a
+          - loom_pool::group_b
+          - loom_pool::group_c
+          - loom_pool::group_d
+          - time::driver
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
+            override: true
+      - uses: Swatinem/rust-cache@v1
       - name: loom ${{ matrix.scope }}
-        run: cargo test --lib --release --features full -- $SCOPE
-        working-directory: tokio
-        env:
-          SCOPE: ${{ matrix.scope }}
-
-  loom-multi-thread-alt:
-    name: loom ALT multi-thread scheduler
-    # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-multi-thread-alt') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - scope: loom_multi_thread_alt::group_a
-          - scope: loom_multi_thread_alt::group_b
-          - scope: loom_multi_thread_alt::group_c
-          - scope: loom_multi_thread_alt::group_d
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: loom ${{ matrix.scope }}
-        run: cargo test --lib --release --features full -- $SCOPE
+        run: cargo test --lib --release --features full -- --nocapture $SCOPE
         working-directory: tokio
         env:
+          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
+          LOOM_MAX_PREEMPTIONS: 2
           SCOPE: ${{ matrix.scope }}

.github/workflows/pr-audit.yml

@@ -8,13 +8,6 @@ on:
     paths:
       - '**/Cargo.toml'
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
 jobs:
   security-audit:
     runs-on: ubuntu-latest
@@ -23,10 +16,17 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Install cargo-audit
-        run: cargo install cargo-audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-audit
 
       - name: Generate lockfile
-        run: cargo generate-lockfile
+        uses: actions-rs/cargo@v1
+        with:
+          command: generate-lockfile
 
       - name: Audit dependencies
-        run: cargo audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: audit

.github/workflows/stress-test.yml

@@ -5,19 +5,12 @@ on:
     branches:
       - master
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
   # Change to specific Rust release to pin
   rust_stable: stable
 
-permissions:
-  contents: read
-
 jobs:
   stress-test:
     name: Stress Test
@@ -29,17 +22,20 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
+        uses: actions-rs/toolchain@v1
         with:
             toolchain: ${{ env.rust_stable }}
+            override: true
+      - uses: Swatinem/rust-cache@v1
       - name: Install Valgrind
-        uses: taiki-e/install-action@valgrind
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y valgrind
 
-      - uses: Swatinem/rust-cache@v2
       # Compiles each of the stress test examples.
       - name: Compile stress test examples
         run: cargo build -p stress-test --release --example ${{ matrix.stress-test }}
 
       # Runs each of the examples using Valgrind. Detects leaks and displays them.
       - name: Run valgrind
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all --fair-sched=yes ./target/release/examples/${{ matrix.stress-test }}
+        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

.gitignore

@@ -2,4 +2,3 @@ target
 Cargo.lock
 
 .cargo/config.toml
-.cargo/config

CONTRIBUTING.md

@@ -131,11 +131,8 @@ cargo check --all-features
 cargo test --all-features
 ```
 
-Ideally, you should use the same version of clippy as the one used in CI
-(defined by `env.rust_clippy` in [ci.yml][ci.yml]), because newer versions
-might have new lints:
-
-[ci.yml]: .github/workflows/ci.yml
+Clippy must be run using the MSRV, so Tokio can avoid having to `#[allow]` new
+lints whose fixes would be incompatible with the current MSRV:
 
 <!--
 When updating this, also update:
@@ -149,7 +146,7 @@ When updating this, also update:
 -->
 
 ```
-cargo +1.65.0 clippy --all --tests --all-features
+cargo +1.49.0 clippy --all --tests --all-features
 ```
 
 When building documentation normally, the markers that list the features
@@ -173,10 +170,10 @@ command below instead:
 
 ```
 # Mac or Linux
-rustfmt --check --edition 2021 $(git ls-files '*.rs')
+rustfmt --check --edition 2018 $(git ls-files '*.rs')
 
 # Powershell
-Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2021 $_.FullName }
+Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2018 $_.FullName }
 ```
 The `--check` argument prints the things that need to be fixed. If you remove
 it, `rustfmt` will update your files locally instead.
@@ -190,7 +187,7 @@ LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
 
 You can run miri tests with
 ```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" \
+MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" PROPTEST_CASES=10 \
     cargo +nightly miri test --features full --lib
 ```
 
@@ -200,22 +197,8 @@ If the change being proposed alters code (as opposed to only documentation for
 example), it is either adding new functionality to Tokio or it is fixing
 existing, broken functionality. In both of these cases, the pull request should
 include one or more tests to ensure that Tokio does not regress in the future.
-There are two ways to write tests: [integration tests][integration-tests]
-and [documentation tests][documentation-tests].
-(Tokio avoids [unit tests][unit-tests] as much as possible).
-
-Tokio uses [conditional compilation attributes][conditional-compilation]
-throughout the codebase, to modify rustc's behavior. Code marked with such
-attributes can be enabled using RUSTFLAGS and RUSTDOCFLAGS environment
-variables. One of the most prevalent flags passed in these variables is
-the `--cfg` option. To run tests in a particular file, check first what
-options #![cfg] declaration defines for that file.
-
-For instance, to run a test marked with the 'tokio_unstable' cfg option,
-you must pass this flag to the compiler when running the test.
-```
-$ RUSTFLAGS="--cfg tokio_unstable" cargo test -p tokio --all-features --test rt_metrics
-```
+There are two ways to write tests: integration tests and documentation tests
+(Tokio avoids unit tests as much as possible).
 
 #### Integration tests
 
@@ -226,31 +209,6 @@ utilities available to use in tests, no matter the crate being tested.
 The best strategy for writing a new integration test is to look at existing
 integration tests in the crate and follow the style.
 
-#### Fuzz tests
-
-Some of our crates include a set of fuzz tests, this will be marked by a
-directory `fuzz`. It is a good idea to run fuzz tests after each change.
-To get started with fuzz testing you'll need to install
-[cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz).
-
-`cargo install cargo-fuzz`
-
-To list the available fuzzing harnesses you can run;
-
-```bash
-$ cd tokio
-$ cargo fuzz list
-fuzz_linked_list
-````
-
-Running a fuzz test is as simple as;
-
-`cargo fuzz run fuzz_linked_list`
-
-**NOTE**: Keep in mind that by default when running a fuzz test the fuzz
-harness will run forever and will only exit if you `ctrl-c` or it finds
-a bug.
-
 #### Documentation tests
 
 Ideally, every API has at least one [documentation test] that demonstrates how to
@@ -675,7 +633,3 @@ When releasing a new version of a crate, follow these steps:
    entry for that release version into your editor and close the window.
 
 [keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md
-[unit-tests]: https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html
-[integration-tests]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
-[documentation-tests]: https://doc.rust-lang.org/rust-by-example/testing/doc_testing.html
-[conditional-compilation]: https://doc.rust-lang.org/reference/conditional-compilation.html

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+
 members = [
   "tokio",
   "tokio-macros",

Cross.toml

@@ -1,5 +1,4 @@
 [build.env]
 passthrough = [
     "RUSTFLAGS",
-    "RUST_BACKTRACE",
 ]

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -56,7 +56,7 @@ Make sure you activated the full features of the tokio crate on Cargo.toml:
 
 ```toml
 [dependencies]
-tokio = { version = "1.32.0", features = ["full"] }
+tokio = { version = "1.20.1", features = ["full"] }
 ```
 Then, on your main.rs:
 
@@ -187,21 +187,7 @@ When updating this, also update:
 
 Tokio will keep a rolling MSRV (minimum supported rust version) policy of **at
 least** 6 months. When increasing the MSRV, the new Rust version must have been
-released at least six months ago. The current MSRV is 1.63.
-
-Note that the MSRV is not increased automatically, and only as part of a minor
-release. The MSRV history for past minor releases can be found below:
-
- * 1.30 to now - Rust 1.63
- * 1.27 to 1.29 - Rust 1.56
- * 1.17 to 1.26 - Rust 1.49
- * 1.15 to 1.16 - Rust 1.46
- * 1.0 to 1.14 - Rust 1.45
-
-Note that although we try to avoid the situation where a dependency transitively
-increases the MSRV of Tokio, we do not guarantee that this does not happen.
-However, every minor release will have some set of versions of dependencies that
-works with the MSRV of that minor release.
+released at least six months ago. The current MSRV is 1.49.0.
 
 ## Release schedule
 
@@ -216,27 +202,20 @@ warrants a patch release with a fix for the bug, it will be backported and
 released as a new patch release for each LTS minor version. Our current LTS
 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)
+ * `1.18.x` - LTS release until January 2023
+ * `1.20.x` - LTS release until April 2023.
 
-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.
+Each LTS release will continue to receive backported fixes for at least half 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.25.x` patch release, you
+example, to specify that you wish to use the newest `1.18.x` patch release, you
 can use the following dependency specification:
 ```text
-tokio = { version = "~1.25", features = [...] }
+tokio = { version = "~1.18", features = [...] }
 ```
 
-### Previous LTS releases
-
- * `1.8.x` - LTS release until February 2022.
- * `1.14.x` - LTS release until June 2022.
- * `1.18.x` - LTS release until June 2023.
-
 ## License
 
 This project is licensed under the [MIT license].

benches/Cargo.toml

@@ -2,16 +2,11 @@
 name = "benches"
 version = "0.0.0"
 publish = false
-edition = "2021"
-
-[features]
-test-util = ["tokio/test-util"]
+edition = "2018"
 
 [dependencies]
 tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-criterion = "0.5.1"
-rand = "0.8"
-rand_chacha = "0.3"
+bencher = "0.1.5"
 
 [dev-dependencies]
 tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
@@ -30,30 +25,11 @@ name = "sync_mpsc"
 path = "sync_mpsc.rs"
 harness = false
 
-[[bench]]
-name = "sync_mpsc_oneshot"
-path = "sync_mpsc_oneshot.rs"
-harness = false
-
-[[bench]]
-name = "sync_watch"
-path = "sync_watch.rs"
-harness = false
-
-[[bench]]
-name = "rt_current_thread"
-path = "rt_current_thread.rs"
-harness = false
-
 [[bench]]
 name = "rt_multi_threaded"
 path = "rt_multi_threaded.rs"
 harness = false
 
-[[bench]]
-name = "sync_notify"
-path = "sync_notify.rs"
-harness = false
 
 [[bench]]
 name = "sync_rwlock"
@@ -74,13 +50,3 @@ harness = false
 name = "fs"
 path = "fs.rs"
 harness = false
-
-[[bench]]
-name = "copy"
-path = "copy.rs"
-harness = false
-
-[[bench]]
-name = "time_now"
-path = "time_now.rs"
-harness = false

benches/copy.rs

@@ -1,250 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
-
-use tokio::io::{copy, repeat, AsyncRead, AsyncReadExt, AsyncWrite};
-use tokio::time::{interval, Interval, MissedTickBehavior};
-
-use std::task::Poll;
-use std::time::Duration;
-
-const KILO: usize = 1024;
-
-// Tunable parameters if you want to change this benchmark. If reader and writer
-// are matched in kilobytes per second, then this only exposes buffering to the
-// benchmark.
-const RNG_SEED: u64 = 0;
-// How much data to copy in a single benchmark run
-const SOURCE_SIZE: u64 = 256 * KILO as u64;
-// Read side provides CHUNK_SIZE every READ_SERVICE_PERIOD. If it's not called
-// frequently, it'll burst to catch up (representing OS buffers draining)
-const CHUNK_SIZE: usize = 2 * KILO;
-const READ_SERVICE_PERIOD: Duration = Duration::from_millis(1);
-// Write side buffers up to WRITE_BUFFER, and flushes to disk every
-// WRITE_SERVICE_PERIOD.
-const WRITE_BUFFER: usize = 40 * KILO;
-const WRITE_SERVICE_PERIOD: Duration = Duration::from_millis(20);
-// How likely you are to have to wait for previously written data to be flushed
-// because another writer claimed the buffer space
-const PROBABILITY_FLUSH_WAIT: f64 = 0.1;
-
-/// A slow writer that aims to simulate HDD behaviour under heavy load.
-///
-/// There is a limited buffer, which is fully drained on the next write after
-/// a time limit is reached. Flush waits for the time limit to be reached
-/// and then drains the buffer.
-///
-/// At random, the HDD will stall writers while it flushes out all buffers. If
-/// this happens to you, you will be unable to write until the next time the
-/// buffer is drained.
-struct SlowHddWriter {
-    service_intervals: Interval,
-    blocking_rng: ChaCha20Rng,
-    buffer_size: usize,
-    buffer_used: usize,
-}
-
-impl SlowHddWriter {
-    fn new(service_interval: Duration, buffer_size: usize) -> Self {
-        let blocking_rng = ChaCha20Rng::seed_from_u64(RNG_SEED);
-        let mut service_intervals = interval(service_interval);
-        service_intervals.set_missed_tick_behavior(MissedTickBehavior::Delay);
-        Self {
-            service_intervals,
-            blocking_rng,
-            buffer_size,
-            buffer_used: 0,
-        }
-    }
-
-    fn service_write(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        // If we hit a service interval, the buffer can be cleared
-        let res = self.service_intervals.poll_tick(cx).map(|_| Ok(()));
-        if let Poll::Ready(_) = res {
-            self.buffer_used = 0;
-        }
-        res
-    }
-
-    fn write_bytes(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        writeable: usize,
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let service_res = self.as_mut().service_write(cx);
-
-        if service_res.is_pending() && self.blocking_rng.gen_bool(PROBABILITY_FLUSH_WAIT) {
-            return Poll::Pending;
-        }
-        let available = self.buffer_size - self.buffer_used;
-
-        if available == 0 {
-            assert!(service_res.is_pending());
-            Poll::Pending
-        } else {
-            let written = available.min(writeable);
-            self.buffer_used += written;
-            Poll::Ready(Ok(written))
-        }
-    }
-}
-
-impl Unpin for SlowHddWriter {}
-
-impl AsyncWrite for SlowHddWriter {
-    fn poll_write(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &[u8],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        self.write_bytes(cx, buf.len())
-    }
-
-    fn poll_flush(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        self.service_write(cx)
-    }
-
-    fn poll_shutdown(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        self.service_write(cx)
-    }
-
-    fn poll_write_vectored(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        bufs: &[std::io::IoSlice<'_>],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let writeable = bufs.into_iter().fold(0, |acc, buf| acc + buf.len());
-        self.write_bytes(cx, writeable)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-}
-
-/// A reader that limits the maximum chunk it'll give you back
-///
-/// Simulates something reading from a slow link - you get one chunk per call,
-/// and you are offered chunks on a schedule
-struct ChunkReader {
-    data: Vec<u8>,
-    service_intervals: Interval,
-}
-
-impl ChunkReader {
-    fn new(chunk_size: usize, service_interval: Duration) -> Self {
-        let mut service_intervals = interval(service_interval);
-        service_intervals.set_missed_tick_behavior(MissedTickBehavior::Burst);
-        let data: Vec<u8> = std::iter::repeat(0).take(chunk_size).collect();
-        Self {
-            data,
-            service_intervals,
-        }
-    }
-}
-
-impl AsyncRead for ChunkReader {
-    fn poll_read(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        if self.service_intervals.poll_tick(cx).is_pending() {
-            return Poll::Pending;
-        }
-        buf.put_slice(&self.data[..buf.remaining().min(self.data.len())]);
-        Poll::Ready(Ok(()))
-    }
-}
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
-        .enable_time()
-        .build()
-        .unwrap()
-}
-
-fn copy_mem_to_mem(c: &mut Criterion) {
-    let rt = rt();
-
-    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(c: &mut Criterion) {
-    let rt = rt();
-
-    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(c: &mut Criterion) {
-    let rt = rt();
-
-    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(c: &mut Criterion) {
-    let rt = rt();
-
-    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());
-        })
-    });
-}
-
-criterion_group!(
-    copy_bench,
-    copy_mem_to_mem,
-    copy_mem_to_slow_hdd,
-    copy_chunk_to_mem,
-    copy_chunk_to_slow_hdd,
-);
-criterion_main!(copy_bench);

benches/fs.rs

@@ -6,7 +6,7 @@ use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 use tokio_util::codec::{BytesCodec, FramedRead /*FramedWrite*/};
 
-use criterion::{criterion_group, criterion_main, Criterion};
+use bencher::{benchmark_group, benchmark_main, Bencher};
 
 use std::fs::File as StdFile;
 use std::io::Read as StdRead;
@@ -23,90 +23,81 @@ const BLOCK_COUNT: usize = 1_000;
 const BUFFER_SIZE: usize = 4096;
 const DEV_ZERO: &str = "/dev/zero";
 
-fn async_read_codec(c: &mut Criterion) {
+fn async_read_codec(b: &mut Bencher) {
     let rt = rt();
 
-    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);
+    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(c: &mut Criterion) {
+fn async_read_buf(b: &mut Bencher) {
     let rt = rt();
 
-    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());
-        });
-    });
-}
-
-fn async_read_std_file(c: &mut Criterion) {
-    let rt = rt();
-
-    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();
-
-                    tokio::task::block_in_place(move || {
-                        file_ref.read_exact(&mut buffer).unwrap();
-                    });
-                }
-            };
-
-            rt.block_on(task());
-        });
-    });
-}
-
-fn sync_read(c: &mut Criterion) {
-    c.bench_function("sync_read", |b| {
-        b.iter(|| {
-            let mut file = StdFile::open(DEV_ZERO).unwrap();
+    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 {
-                file.read_exact(&mut buffer).unwrap();
+                let count = file.read(&mut buffer).await.unwrap();
+                if count == 0 {
+                    break;
+                }
             }
-        })
+        };
+
+        rt.block_on(task());
     });
 }
 
-criterion_group!(
+fn async_read_std_file(b: &mut Bencher) {
+    let rt = rt();
+
+    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();
+
+            tokio::task::block_in_place(move || {
+                file_ref.read_exact(&mut buffer).unwrap();
+            });
+        }
+    };
+
+    b.iter(|| {
+        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];
+
+        for _i in 0..BLOCK_COUNT {
+            file.read_exact(&mut buffer).unwrap();
+        }
+    });
+}
+
+benchmark_group!(
     file,
     async_read_std_file,
     async_read_buf,
     async_read_codec,
     sync_read
 );
-criterion_main!(file);
+
+benchmark_main!(file);

benches/rt_current_thread.rs

@@ -1,89 +0,0 @@
-//! Benchmark implementation details of the threaded scheduler. These benches are
-//! intended to be used as a form of regression testing and not as a general
-//! purpose benchmark demonstrating real-world performance.
-
-use tokio::runtime::{self, Runtime};
-
-use criterion::{criterion_group, criterion_main, Criterion};
-
-const NUM_SPAWN: usize = 1_000;
-
-fn spawn_many_local(c: &mut Criterion) {
-    let rt = rt();
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-
-    c.bench_function("spawn_many_local", |b| {
-        b.iter(|| {
-            rt.block_on(async {
-                for _ in 0..NUM_SPAWN {
-                    handles.push(tokio::spawn(async move {}));
-                }
-
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-}
-
-fn spawn_many_remote_idle(c: &mut Criterion) {
-    let rt = rt();
-    let rt_handle = rt.handle();
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-
-    c.bench_function("spawn_many_remote_idle", |b| {
-        b.iter(|| {
-            for _ in 0..NUM_SPAWN {
-                handles.push(rt_handle.spawn(async {}));
-            }
-
-            rt.block_on(async {
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-}
-
-fn spawn_many_remote_busy(c: &mut Criterion) {
-    let rt = rt();
-    let rt_handle = rt.handle();
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-
-    rt.spawn(async {
-        fn iter() {
-            tokio::spawn(async { iter() });
-        }
-
-        iter()
-    });
-
-    c.bench_function("spawn_many_remote_busy", |b| {
-        b.iter(|| {
-            for _ in 0..NUM_SPAWN {
-                handles.push(rt_handle.spawn(async {}));
-            }
-
-            rt.block_on(async {
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-}
-
-fn rt() -> Runtime {
-    runtime::Builder::new_current_thread().build().unwrap()
-}
-
-criterion_group!(
-    scheduler,
-    spawn_many_local,
-    spawn_many_remote_idle,
-    spawn_many_remote_busy
-);
-
-criterion_main!(scheduler);

benches/rt_multi_threaded.rs

@@ -5,173 +5,67 @@
 use tokio::runtime::{self, Runtime};
 use tokio::sync::oneshot;
 
+use bencher::{benchmark_group, benchmark_main, Bencher};
+use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::Relaxed;
-use std::sync::atomic::{AtomicBool, AtomicUsize};
 use std::sync::{mpsc, Arc};
-use std::time::{Duration, Instant};
 
-use criterion::{criterion_group, criterion_main, Criterion};
+fn spawn_many(b: &mut Bencher) {
+    const NUM_SPAWN: usize = 10_000;
 
-const NUM_WORKERS: usize = 4;
-const NUM_SPAWN: usize = 10_000;
-const STALL_DUR: Duration = Duration::from_micros(10);
-
-fn spawn_many_local(c: &mut Criterion) {
     let rt = rt();
 
     let (tx, rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
 
-    c.bench_function("spawn_many_local", |b| {
-        b.iter(|| {
-            rem.store(NUM_SPAWN, Relaxed);
+    b.iter(|| {
+        rem.store(NUM_SPAWN, Relaxed);
 
-            rt.block_on(async {
-                for _ in 0..NUM_SPAWN {
-                    let tx = tx.clone();
-                    let rem = rem.clone();
-
-                    tokio::spawn(async move {
-                        if 1 == rem.fetch_sub(1, Relaxed) {
-                            tx.send(()).unwrap();
-                        }
-                    });
-                }
-
-                let _ = rx.recv().unwrap();
-            });
-        })
-    });
-}
-
-fn spawn_many_remote_idle(c: &mut Criterion) {
-    let rt = rt();
-
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-
-    c.bench_function("spawn_many_remote_idle", |b| {
-        b.iter(|| {
+        rt.block_on(async {
             for _ in 0..NUM_SPAWN {
-                handles.push(rt.spawn(async {}));
-            }
-
-            rt.block_on(async {
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-}
-
-// The runtime is busy with tasks that consume CPU time and yield. Yielding is a
-// lower notification priority than spawning / regular notification.
-fn spawn_many_remote_busy1(c: &mut Criterion) {
-    let rt = rt();
-    let rt_handle = rt.handle();
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-    let flag = Arc::new(AtomicBool::new(true));
-
-    // Spawn some tasks to keep the runtimes busy
-    for _ in 0..(2 * NUM_WORKERS) {
-        let flag = flag.clone();
-        rt.spawn(async move {
-            while flag.load(Relaxed) {
-                tokio::task::yield_now().await;
-                stall();
-            }
-        });
-    }
-
-    c.bench_function("spawn_many_remote_busy1", |b| {
-        b.iter(|| {
-            for _ in 0..NUM_SPAWN {
-                handles.push(rt_handle.spawn(async {}));
-            }
-
-            rt.block_on(async {
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-
-    flag.store(false, Relaxed);
-}
-
-// The runtime is busy with tasks that consume CPU time and spawn new high-CPU
-// tasks. Spawning goes via a higher notification priority than yielding.
-fn spawn_many_remote_busy2(c: &mut Criterion) {
-    const NUM_SPAWN: usize = 1_000;
-
-    let rt = rt();
-    let rt_handle = rt.handle();
-    let mut handles = Vec::with_capacity(NUM_SPAWN);
-    let flag = Arc::new(AtomicBool::new(true));
-
-    // Spawn some tasks to keep the runtimes busy
-    for _ in 0..(NUM_WORKERS) {
-        let flag = flag.clone();
-        fn iter(flag: Arc<AtomicBool>) {
-            tokio::spawn(async {
-                if flag.load(Relaxed) {
-                    stall();
-                    iter(flag);
-                }
-            });
-        }
-        rt.spawn(async {
-            iter(flag);
-        });
-    }
-
-    c.bench_function("spawn_many_remote_busy2", |b| {
-        b.iter(|| {
-            for _ in 0..NUM_SPAWN {
-                handles.push(rt_handle.spawn(async {}));
-            }
-
-            rt.block_on(async {
-                for handle in handles.drain(..) {
-                    handle.await.unwrap();
-                }
-            });
-        })
-    });
-
-    flag.store(false, Relaxed);
-}
-
-fn yield_many(c: &mut Criterion) {
-    const NUM_YIELD: usize = 1_000;
-    const TASKS: usize = 200;
-
-    c.bench_function("yield_many", |b| {
-        let rt = rt();
-        let (tx, rx) = mpsc::sync_channel(TASKS);
-
-        b.iter(move || {
-            for _ in 0..TASKS {
                 let tx = tx.clone();
+                let rem = rem.clone();
 
-                rt.spawn(async move {
-                    for _ in 0..NUM_YIELD {
-                        tokio::task::yield_now().await;
+                tokio::spawn(async move {
+                    if 1 == rem.fetch_sub(1, Relaxed) {
+                        tx.send(()).unwrap();
                     }
-
-                    tx.send(()).unwrap();
                 });
             }
 
-            for _ in 0..TASKS {
-                let _ = rx.recv().unwrap();
-            }
-        })
+            let _ = rx.recv().unwrap();
+        });
     });
 }
 
-fn ping_pong(c: &mut Criterion) {
+fn yield_many(b: &mut Bencher) {
+    const NUM_YIELD: usize = 1_000;
+    const TASKS: usize = 200;
+
+    let rt = rt();
+
+    let (tx, rx) = mpsc::sync_channel(TASKS);
+
+    b.iter(move || {
+        for _ in 0..TASKS {
+            let tx = tx.clone();
+
+            rt.spawn(async move {
+                for _ in 0..NUM_YIELD {
+                    tokio::task::yield_now().await;
+                }
+
+                tx.send(()).unwrap();
+            });
+        }
+
+        for _ in 0..TASKS {
+            let _ = rx.recv().unwrap();
+        }
+    });
+}
+
+fn ping_pong(b: &mut Bencher) {
     const NUM_PINGS: usize = 1_000;
 
     let rt = rt();
@@ -179,46 +73,46 @@ fn ping_pong(c: &mut Criterion) {
     let (done_tx, done_rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
 
-    c.bench_function("ping_pong", |b| {
-        b.iter(|| {
-            let done_tx = done_tx.clone();
-            let rem = rem.clone();
-            rem.store(NUM_PINGS, Relaxed);
+    b.iter(|| {
+        let done_tx = done_tx.clone();
+        let rem = rem.clone();
+        rem.store(NUM_PINGS, Relaxed);
 
-            rt.block_on(async {
-                tokio::spawn(async move {
-                    for _ in 0..NUM_PINGS {
-                        let rem = rem.clone();
-                        let done_tx = done_tx.clone();
+        rt.block_on(async {
+            tokio::spawn(async move {
+                for _ in 0..NUM_PINGS {
+                    let rem = rem.clone();
+                    let done_tx = done_tx.clone();
+
+                    tokio::spawn(async move {
+                        let (tx1, rx1) = oneshot::channel();
+                        let (tx2, rx2) = oneshot::channel();
 
                         tokio::spawn(async move {
-                            let (tx1, rx1) = oneshot::channel();
-                            let (tx2, rx2) = oneshot::channel();
-
-                            tokio::spawn(async move {
-                                rx1.await.unwrap();
-                                tx2.send(()).unwrap();
-                            });
-
-                            tx1.send(()).unwrap();
-                            rx2.await.unwrap();
-
-                            if 1 == rem.fetch_sub(1, Relaxed) {
-                                done_tx.send(()).unwrap();
-                            }
+                            rx1.await.unwrap();
+                            tx2.send(()).unwrap();
                         });
-                    }
-                });
 
-                done_rx.recv().unwrap();
+                        tx1.send(()).unwrap();
+                        rx2.await.unwrap();
+
+                        if 1 == rem.fetch_sub(1, Relaxed) {
+                            done_tx.send(()).unwrap();
+                        }
+                    });
+                }
             });
-        })
+
+            done_rx.recv().unwrap();
+        });
     });
 }
 
-fn chained_spawn(c: &mut Criterion) {
+fn chained_spawn(b: &mut Bencher) {
     const ITER: usize = 1_000;
 
+    let rt = rt();
+
     fn iter(done_tx: mpsc::SyncSender<()>, n: usize) {
         if n == 0 {
             done_tx.send(()).unwrap();
@@ -229,48 +123,29 @@ fn chained_spawn(c: &mut Criterion) {
         }
     }
 
-    c.bench_function("chained_spawn", |b| {
-        let rt = rt();
-        let (done_tx, done_rx) = mpsc::sync_channel(1000);
+    let (done_tx, done_rx) = mpsc::sync_channel(1000);
 
-        b.iter(move || {
-            let done_tx = done_tx.clone();
+    b.iter(move || {
+        let done_tx = done_tx.clone();
 
-            rt.block_on(async {
-                tokio::spawn(async move {
-                    iter(done_tx, ITER);
-                });
-
-                done_rx.recv().unwrap();
+        rt.block_on(async {
+            tokio::spawn(async move {
+                iter(done_tx, ITER);
             });
-        })
+
+            done_rx.recv().unwrap();
+        });
     });
 }
 
 fn rt() -> Runtime {
     runtime::Builder::new_multi_thread()
-        .worker_threads(NUM_WORKERS)
+        .worker_threads(4)
         .enable_all()
         .build()
         .unwrap()
 }
 
-fn stall() {
-    let now = Instant::now();
-    while now.elapsed() < STALL_DUR {
-        std::thread::yield_now();
-    }
-}
+benchmark_group!(scheduler, spawn_many, ping_pong, yield_many, chained_spawn,);
 
-criterion_group!(
-    scheduler,
-    spawn_many_local,
-    spawn_many_remote_idle,
-    spawn_many_remote_busy1,
-    spawn_many_remote_busy2,
-    ping_pong,
-    yield_many,
-    chained_spawn,
-);
-
-criterion_main!(scheduler);
+benchmark_main!(scheduler);

benches/signal.rs

@@ -1,7 +1,7 @@
 //! Benchmark the delay in propagating OS signals to any listeners.
 #![cfg(unix)]
 
-use criterion::{criterion_group, criterion_main, Criterion};
+use bencher::{benchmark_group, benchmark_main, Bencher};
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -41,7 +41,7 @@ pub fn send_signal(signal: libc::c_int) {
     }
 }
 
-fn many_signals(c: &mut Criterion) {
+fn many_signals(bench: &mut Bencher) {
     let num_signals = 10;
     let (tx, mut rx) = mpsc::channel(num_signals);
 
@@ -75,23 +75,21 @@ fn many_signals(c: &mut Criterion) {
     // tasks have been polled at least once
     rt.block_on(Spinner::new());
 
-    c.bench_function("many_signals", |b| {
-        b.iter(|| {
-            rt.block_on(async {
-                send_signal(libc::SIGCHLD);
-                for _ in 0..num_signals {
-                    rx.recv().await.expect("channel closed");
-                }
+    bench.iter(|| {
+        rt.block_on(async {
+            send_signal(libc::SIGCHLD);
+            for _ in 0..num_signals {
+                rx.recv().await.expect("channel closed");
+            }
 
-                send_signal(libc::SIGIO);
-                for _ in 0..num_signals {
-                    rx.recv().await.expect("channel closed");
-                }
-            });
-        })
+            send_signal(libc::SIGIO);
+            for _ in 0..num_signals {
+                rx.recv().await.expect("channel closed");
+            }
+        });
     });
 }
 
-criterion_group!(signal_group, many_signals);
+benchmark_group!(signal_group, many_signals,);
 
-criterion_main!(signal_group);
+benchmark_main!(signal_group);

benches/spawn.rs

@@ -2,7 +2,10 @@
 //! This essentially measure the time to enqueue a task in the local and remote
 //! case.
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+#[macro_use]
+extern crate bencher;
+
+use bencher::{black_box, Bencher};
 
 async fn work() -> usize {
     let val = 1 + 1;
@@ -10,77 +13,67 @@ async fn work() -> usize {
     black_box(val)
 }
 
-fn basic_scheduler_spawn(c: &mut Criterion) {
+fn basic_scheduler_spawn(bench: &mut Bencher) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
-
-    c.bench_function("basic_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
+    bench.iter(|| {
+        runtime.block_on(async {
+            let h = tokio::spawn(work());
+            assert_eq!(h.await.unwrap(), 2);
+        });
     });
 }
 
-fn basic_scheduler_spawn10(c: &mut Criterion) {
+fn basic_scheduler_spawn10(bench: &mut Bencher) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
-
-    c.bench_function("basic_scheduler_spawn10", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let mut handles = Vec::with_capacity(10);
-                for _ in 0..10 {
-                    handles.push(tokio::spawn(work()));
-                }
-                for handle in handles {
-                    assert_eq!(handle.await.unwrap(), 2);
-                }
-            });
-        })
+    bench.iter(|| {
+        runtime.block_on(async {
+            let mut handles = Vec::with_capacity(10);
+            for _ in 0..10 {
+                handles.push(tokio::spawn(work()));
+            }
+            for handle in handles {
+                assert_eq!(handle.await.unwrap(), 2);
+            }
+        });
     });
 }
 
-fn threaded_scheduler_spawn(c: &mut Criterion) {
+fn threaded_scheduler_spawn(bench: &mut Bencher) {
     let runtime = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
         .unwrap();
-    c.bench_function("threaded_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
+    bench.iter(|| {
+        runtime.block_on(async {
+            let h = tokio::spawn(work());
+            assert_eq!(h.await.unwrap(), 2);
+        });
     });
 }
 
-fn threaded_scheduler_spawn10(c: &mut Criterion) {
+fn threaded_scheduler_spawn10(bench: &mut Bencher) {
     let runtime = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
         .unwrap();
-    c.bench_function("threaded_scheduler_spawn10", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let mut handles = Vec::with_capacity(10);
-                for _ in 0..10 {
-                    handles.push(tokio::spawn(work()));
-                }
-                for handle in handles {
-                    assert_eq!(handle.await.unwrap(), 2);
-                }
-            });
-        })
+    bench.iter(|| {
+        runtime.block_on(async {
+            let mut handles = Vec::with_capacity(10);
+            for _ in 0..10 {
+                handles.push(tokio::spawn(work()));
+            }
+            for handle in handles {
+                assert_eq!(handle.await.unwrap(), 2);
+            }
+        });
     });
 }
 
-criterion_group!(
+bencher::benchmark_group!(
     spawn,
     basic_scheduler_spawn,
     basic_scheduler_spawn10,
@@ -88,4 +81,4 @@ criterion_group!(
     threaded_scheduler_spawn10,
 );
 
-criterion_main!(spawn);
+bencher::benchmark_main!(spawn);

benches/sync_mpsc.rs

@@ -1,23 +1,8 @@
+use bencher::{black_box, Bencher};
 use tokio::sync::mpsc;
 
-use criterion::measurement::WallTime;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
-#[derive(Debug, Copy, Clone)]
-struct Medium([usize; 64]);
-impl Default for Medium {
-    fn default() -> Self {
-        Medium([0; 64])
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-struct Large([Medium; 64]);
-impl Default for Large {
-    fn default() -> Self {
-        Large([Medium::default(); 64])
-    }
-}
+type Medium = [usize; 64];
+type Large = [Medium; 64];
 
 fn rt() -> tokio::runtime::Runtime {
     tokio::runtime::Builder::new_multi_thread()
@@ -26,176 +11,169 @@ fn rt() -> tokio::runtime::Runtime {
         .unwrap()
 }
 
-fn create_medium<const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>) {
-    g.bench_function(SIZE.to_string(), |b| {
-        b.iter(|| {
-            black_box(&mpsc::channel::<Medium>(SIZE));
-        })
+fn create_1_medium(b: &mut Bencher) {
+    b.iter(|| {
+        black_box(&mpsc::channel::<Medium>(1));
     });
 }
 
-fn send_data<T: Default, const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>, prefix: &str) {
+fn create_100_medium(b: &mut Bencher) {
+    b.iter(|| {
+        black_box(&mpsc::channel::<Medium>(100));
+    });
+}
+
+fn create_100_000_medium(b: &mut Bencher) {
+    b.iter(|| {
+        black_box(&mpsc::channel::<Medium>(100_000));
+    });
+}
+
+fn send_medium(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function(format!("{}_{}", prefix, SIZE), |b| {
-        b.iter(|| {
-            let (tx, mut rx) = mpsc::channel::<T>(SIZE);
+    b.iter(|| {
+        let (tx, mut rx) = mpsc::channel::<Medium>(1000);
 
-            let _ = rt.block_on(tx.send(T::default()));
+        let _ = rt.block_on(tx.send([0; 64]));
 
-            rt.block_on(rx.recv()).unwrap();
-        })
+        rt.block_on(rx.recv()).unwrap();
     });
 }
 
-fn contention_bounded(g: &mut BenchmarkGroup<WallTime>) {
+fn send_large(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("bounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+    b.iter(|| {
+        let (tx, mut rx) = mpsc::channel::<Large>(1000);
 
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
+        let _ = rt.block_on(tx.send([[0; 64]; 64]));
 
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
+        rt.block_on(rx.recv()).unwrap();
     });
 }
 
-fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_bounded(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("bounded_full", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(100);
+    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();
-                        }
-                    });
-                }
+            for _ in 0..5 {
+                let tx = tx.clone();
+                tokio::spawn(async move {
+                    for i in 0..1000 {
+                        tx.send(i).await.unwrap();
+                    }
+                });
+            }
 
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
+            for _ in 0..1_000 * 5 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_bounded_full(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
+    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).unwrap();
-                        }
-                    });
-                }
+            for _ in 0..5 {
+                let tx = tx.clone();
+                tokio::spawn(async move {
+                    for i in 0..1000 {
+                        tx.send(i).await.unwrap();
+                    }
+                });
+            }
 
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
+            for _ in 0..1_000 * 5 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_unbounded(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("bounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+    b.iter(|| {
+        rt.block_on(async move {
+            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
 
-                for i in 0..5000 {
-                    tx.send(i).await.unwrap();
-                }
+            for _ in 0..5 {
+                let tx = tx.clone();
+                tokio::spawn(async move {
+                    for i in 0..1000 {
+                        tx.send(i).unwrap();
+                    }
+                });
+            }
 
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
+            for _ in 0..1_000 * 5 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
+fn uncontented_bounded(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
+    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).unwrap();
-                }
+            for i in 0..5000 {
+                tx.send(i).await.unwrap();
+            }
 
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
+            for _ in 0..5_000 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn bench_create_medium(c: &mut Criterion) {
-    let mut group = c.benchmark_group("create_medium");
-    create_medium::<1>(&mut group);
-    create_medium::<100>(&mut group);
-    create_medium::<100_000>(&mut group);
-    group.finish();
+fn uncontented_unbounded(b: &mut Bencher) {
+    let rt = rt();
+
+    b.iter(|| {
+        rt.block_on(async move {
+            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
+
+            for i in 0..5000 {
+                tx.send(i).unwrap();
+            }
+
+            for _ in 0..5_000 {
+                let _ = rx.recv().await;
+            }
+        })
+    });
 }
 
-fn bench_send(c: &mut Criterion) {
-    let mut group = c.benchmark_group("send");
-    send_data::<Medium, 1000>(&mut group, "medium");
-    send_data::<Large, 1000>(&mut group, "large");
-    group.finish();
-}
+bencher::benchmark_group!(
+    create,
+    create_1_medium,
+    create_100_medium,
+    create_100_000_medium
+);
 
-fn bench_contention(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention");
-    contention_bounded(&mut group);
-    contention_bounded_full(&mut group);
-    contention_unbounded(&mut group);
-    group.finish();
-}
+bencher::benchmark_group!(send, send_medium, send_large);
 
-fn bench_uncontented(c: &mut Criterion) {
-    let mut group = c.benchmark_group("uncontented");
-    uncontented_bounded(&mut group);
-    uncontented_unbounded(&mut group);
-    group.finish();
-}
+bencher::benchmark_group!(
+    contention,
+    contention_bounded,
+    contention_bounded_full,
+    contention_unbounded,
+    uncontented_bounded,
+    uncontented_unbounded
+);
 
-criterion_group!(create, bench_create_medium);
-criterion_group!(send, bench_send);
-criterion_group!(contention, bench_contention);
-criterion_group!(uncontented, bench_uncontented);
-
-criterion_main!(create, send, contention, uncontented);
+bencher::benchmark_main!(create, send, contention);

benches/sync_mpsc_oneshot.rs

@@ -1,56 +0,0 @@
-use tokio::{
-    runtime::Runtime,
-    sync::{mpsc, oneshot},
-};
-
-use criterion::{criterion_group, criterion_main, Criterion};
-
-fn request_reply_current_thread(c: &mut Criterion) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    request_reply(c, rt);
-}
-
-fn request_reply_multi_threaded(c: &mut Criterion) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap();
-
-    request_reply(c, rt);
-}
-
-fn request_reply(b: &mut Criterion, rt: Runtime) {
-    let tx = rt.block_on(async move {
-        let (tx, mut rx) = mpsc::channel::<oneshot::Sender<()>>(10);
-        tokio::spawn(async move {
-            while let Some(reply) = rx.recv().await {
-                reply.send(()).unwrap();
-            }
-        });
-        tx
-    });
-
-    b.bench_function("request_reply", |b| {
-        b.iter(|| {
-            let task_tx = tx.clone();
-            rt.block_on(async move {
-                for _ in 0..1_000 {
-                    let (o_tx, o_rx) = oneshot::channel();
-                    task_tx.send(o_tx).await.unwrap();
-                    let _ = o_rx.await;
-                }
-            })
-        })
-    });
-}
-
-criterion_group!(
-    sync_mpsc_oneshot_group,
-    request_reply_current_thread,
-    request_reply_multi_threaded,
-);
-
-criterion_main!(sync_mpsc_oneshot_group);

benches/sync_notify.rs

@@ -1,104 +0,0 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-
-use tokio::sync::Notify;
-
-use criterion::measurement::WallTime;
-use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
-fn notify_waiters<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-    let notify = Arc::new(Notify::new());
-    let counter = Arc::new(AtomicUsize::new(0));
-    for _ in 0..N_WAITERS {
-        rt.spawn({
-            let notify = notify.clone();
-            let counter = counter.clone();
-            async move {
-                loop {
-                    notify.notified().await;
-                    counter.fetch_add(1, Ordering::Relaxed);
-                }
-            }
-        });
-    }
-
-    const N_ITERS: usize = 500;
-    g.bench_function(N_WAITERS.to_string(), |b| {
-        b.iter(|| {
-            counter.store(0, Ordering::Relaxed);
-            loop {
-                notify.notify_waiters();
-                if counter.load(Ordering::Relaxed) >= N_ITERS {
-                    break;
-                }
-            }
-        })
-    });
-}
-
-fn notify_one<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-    let notify = Arc::new(Notify::new());
-    let counter = Arc::new(AtomicUsize::new(0));
-    for _ in 0..N_WAITERS {
-        rt.spawn({
-            let notify = notify.clone();
-            let counter = counter.clone();
-            async move {
-                loop {
-                    notify.notified().await;
-                    counter.fetch_add(1, Ordering::Relaxed);
-                }
-            }
-        });
-    }
-
-    const N_ITERS: usize = 500;
-    g.bench_function(N_WAITERS.to_string(), |b| {
-        b.iter(|| {
-            counter.store(0, Ordering::Relaxed);
-            loop {
-                notify.notify_one();
-                if counter.load(Ordering::Relaxed) >= N_ITERS {
-                    break;
-                }
-            }
-        })
-    });
-}
-
-fn bench_notify_one(c: &mut Criterion) {
-    let mut group = c.benchmark_group("notify_one");
-    notify_one::<10>(&mut group);
-    notify_one::<50>(&mut group);
-    notify_one::<100>(&mut group);
-    notify_one::<200>(&mut group);
-    notify_one::<500>(&mut group);
-    group.finish();
-}
-
-fn bench_notify_waiters(c: &mut Criterion) {
-    let mut group = c.benchmark_group("notify_waiters");
-    notify_waiters::<10>(&mut group);
-    notify_waiters::<50>(&mut group);
-    notify_waiters::<100>(&mut group);
-    notify_waiters::<200>(&mut group);
-    notify_waiters::<500>(&mut group);
-    group.finish();
-}
-
-criterion_group!(
-    notify_waiters_simple,
-    bench_notify_one,
-    bench_notify_waiters
-);
-
-criterion_main!(notify_waiters_simple);

benches/sync_rwlock.rs

@@ -1,30 +1,26 @@
+use bencher::{black_box, Bencher};
 use std::sync::Arc;
 use tokio::{sync::RwLock, task};
 
-use criterion::measurement::WallTime;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
-fn read_uncontended(g: &mut BenchmarkGroup<WallTime>) {
+fn read_uncontended(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
         .build()
         .unwrap();
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                for _ in 0..6 {
-                    let read = lock.read().await;
-                    let _read = black_box(read);
-                }
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            for _ in 0..6 {
+                let read = lock.read().await;
+                let _read = black_box(read);
+            }
         })
     });
 }
 
-fn read_concurrent_uncontended_multi(g: &mut BenchmarkGroup<WallTime>) {
+fn read_concurrent_uncontended_multi(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
         .build()
@@ -36,25 +32,23 @@ fn read_concurrent_uncontended_multi(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read_concurrent_multi", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                let j = tokio::try_join! {
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone()))
-                };
-                j.unwrap();
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            let j = tokio::try_join! {
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone()))
+            };
+            j.unwrap();
         })
     });
 }
 
-fn read_concurrent_uncontended(g: &mut BenchmarkGroup<WallTime>) {
+fn read_concurrent_uncontended(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
@@ -65,24 +59,22 @@ fn read_concurrent_uncontended(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read_concurrent", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                tokio::join! {
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone())
-                };
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            tokio::join! {
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone())
+            };
         })
     });
 }
 
-fn read_concurrent_contended_multi(g: &mut BenchmarkGroup<WallTime>) {
+fn read_concurrent_contended_multi(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
         .build()
@@ -94,26 +86,24 @@ fn read_concurrent_contended_multi(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read_concurrent_multi", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                let write = lock.write().await;
-                let j = tokio::try_join! {
-                    async move { drop(write); Ok(()) },
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                    task::spawn(task(lock.clone())),
-                };
-                j.unwrap();
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            let write = lock.write().await;
+            let j = tokio::try_join! {
+                async move { drop(write); Ok(()) },
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+                task::spawn(task(lock.clone())),
+            };
+            j.unwrap();
         })
     });
 }
 
-fn read_concurrent_contended(g: &mut BenchmarkGroup<WallTime>) {
+fn read_concurrent_contended(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
@@ -124,40 +114,29 @@ fn read_concurrent_contended(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read_concurrent", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                let write = lock.write().await;
-                tokio::join! {
-                    async move { drop(write) },
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                    task(lock.clone()),
-                };
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            let write = lock.write().await;
+            tokio::join! {
+                async move { drop(write) },
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+                task(lock.clone()),
+            };
         })
     });
 }
 
-fn bench_contention(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention");
-    read_concurrent_contended(&mut group);
-    read_concurrent_contended_multi(&mut group);
-    group.finish();
-}
+bencher::benchmark_group!(
+    sync_rwlock,
+    read_uncontended,
+    read_concurrent_uncontended,
+    read_concurrent_uncontended_multi,
+    read_concurrent_contended,
+    read_concurrent_contended_multi
+);
 
-fn bench_uncontented(c: &mut Criterion) {
-    let mut group = c.benchmark_group("uncontented");
-    read_uncontended(&mut group);
-    read_concurrent_uncontended(&mut group);
-    read_concurrent_uncontended_multi(&mut group);
-    group.finish();
-}
-
-criterion_group!(contention, bench_contention);
-criterion_group!(uncontented, bench_uncontented);
-
-criterion_main!(contention, uncontented);
+bencher::benchmark_main!(sync_rwlock);

benches/sync_semaphore.rs

@@ -1,36 +1,21 @@
+use bencher::Bencher;
 use std::sync::Arc;
-use tokio::runtime::Runtime;
 use tokio::{sync::Semaphore, task};
 
-use criterion::measurement::WallTime;
-use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
-fn single_rt() -> Runtime {
-    tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap()
-}
-
-fn multi_rt() -> Runtime {
-    tokio::runtime::Builder::new_multi_thread()
+fn uncontended(b: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
         .build()
-        .unwrap()
-}
-
-fn uncontended(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
+        .unwrap();
 
     let s = Arc::new(Semaphore::new(10));
-    g.bench_function("multi", |b| {
-        b.iter(|| {
-            let s = s.clone();
-            rt.block_on(async move {
-                for _ in 0..6 {
-                    let permit = s.acquire().await;
-                    drop(permit);
-                }
-            })
+    b.iter(|| {
+        let s = s.clone();
+        rt.block_on(async move {
+            for _ in 0..6 {
+                let permit = s.acquire().await;
+                drop(permit);
+            }
         })
     });
 }
@@ -40,108 +25,101 @@ async fn task(s: Arc<Semaphore>) {
     drop(permit);
 }
 
-fn uncontended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
+fn uncontended_concurrent_multi(b: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(6)
+        .build()
+        .unwrap();
 
     let s = Arc::new(Semaphore::new(10));
-    g.bench_function("concurrent_multi", |b| {
-        b.iter(|| {
-            let s = s.clone();
-            rt.block_on(async move {
-                let j = tokio::try_join! {
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone()))
-                };
-                j.unwrap();
-            })
+    b.iter(|| {
+        let s = s.clone();
+        rt.block_on(async move {
+            let j = tokio::try_join! {
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone()))
+            };
+            j.unwrap();
         })
     });
 }
 
-fn uncontended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = single_rt();
+fn uncontended_concurrent_single(b: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
 
     let s = Arc::new(Semaphore::new(10));
-    g.bench_function("concurrent_single", |b| {
-        b.iter(|| {
-            let s = s.clone();
-            rt.block_on(async move {
-                tokio::join! {
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone())
-                };
-            })
+    b.iter(|| {
+        let s = s.clone();
+        rt.block_on(async move {
+            tokio::join! {
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone())
+            };
         })
     });
 }
 
-fn contended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
+fn contended_concurrent_multi(b: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(6)
+        .build()
+        .unwrap();
 
     let s = Arc::new(Semaphore::new(5));
-    g.bench_function("concurrent_multi", |b| {
-        b.iter(|| {
-            let s = s.clone();
-            rt.block_on(async move {
-                let j = tokio::try_join! {
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone())),
-                    task::spawn(task(s.clone()))
-                };
-                j.unwrap();
-            })
+    b.iter(|| {
+        let s = s.clone();
+        rt.block_on(async move {
+            let j = tokio::try_join! {
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone())),
+                task::spawn(task(s.clone()))
+            };
+            j.unwrap();
         })
     });
 }
 
-fn contended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = single_rt();
+fn contended_concurrent_single(b: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
 
     let s = Arc::new(Semaphore::new(5));
-    g.bench_function("concurrent_single", |b| {
-        b.iter(|| {
-            let s = s.clone();
-            rt.block_on(async move {
-                tokio::join! {
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone()),
-                    task(s.clone())
-                };
-            })
+    b.iter(|| {
+        let s = s.clone();
+        rt.block_on(async move {
+            tokio::join! {
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone()),
+                task(s.clone())
+            };
         })
     });
 }
 
-fn bench_contention(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention");
-    contended_concurrent_multi(&mut group);
-    contended_concurrent_single(&mut group);
-    group.finish();
-}
+bencher::benchmark_group!(
+    sync_semaphore,
+    uncontended,
+    uncontended_concurrent_multi,
+    uncontended_concurrent_single,
+    contended_concurrent_multi,
+    contended_concurrent_single
+);
 
-fn bench_uncontented(c: &mut Criterion) {
-    let mut group = c.benchmark_group("uncontented");
-    uncontended(&mut group);
-    uncontended_concurrent_multi(&mut group);
-    uncontended_concurrent_single(&mut group);
-    group.finish();
-}
-
-criterion_group!(contention, bench_contention);
-criterion_group!(uncontented, bench_uncontented);
-
-criterion_main!(contention, uncontented);
+bencher::benchmark_main!(sync_semaphore);

benches/sync_watch.rs

@@ -1,67 +0,0 @@
-use rand::prelude::*;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-use tokio::sync::{watch, Notify};
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
-fn do_work(rng: &mut impl RngCore) -> u32 {
-    use std::fmt::Write;
-    let mut message = String::new();
-    for i in 1..=10 {
-        let _ = write!(&mut message, " {i}={}", rng.gen::<f64>());
-    }
-    message
-        .as_bytes()
-        .iter()
-        .map(|&c| c as u32)
-        .fold(0, u32::wrapping_add)
-}
-
-fn contention_resubscribe(c: &mut Criterion) {
-    const NTASK: u64 = 1000;
-
-    let rt = rt();
-    let (snd, rcv) = watch::channel(0i32);
-    let wg = Arc::new((AtomicU64::new(0), Notify::new()));
-    for n in 0..NTASK {
-        let mut rcv = rcv.clone();
-        let wg = wg.clone();
-        let mut rng = rand::rngs::StdRng::seed_from_u64(n);
-        rt.spawn(async move {
-            while rcv.changed().await.is_ok() {
-                let _ = *rcv.borrow(); // contend on rwlock
-                let r = do_work(&mut rng);
-                let _ = black_box(r);
-                if wg.0.fetch_sub(1, Ordering::Release) == 1 {
-                    wg.1.notify_one();
-                }
-            }
-        });
-    }
-
-    c.bench_function("contention_resubscribe", |b| {
-        b.iter(|| {
-            rt.block_on(async {
-                for _ in 0..100 {
-                    assert_eq!(wg.0.fetch_add(NTASK, Ordering::Relaxed), 0);
-                    let _ = snd.send(black_box(42));
-                    while wg.0.load(Ordering::Acquire) > 0 {
-                        wg.1.notified().await;
-                    }
-                }
-            });
-        })
-    });
-}
-
-criterion_group!(contention, contention_resubscribe);
-
-criterion_main!(contention);

benches/time_now.rs

@@ -1,24 +0,0 @@
-//! Benchmark spawning a task onto the basic and threaded Tokio executors.
-//! This essentially measure the time to enqueue a task in the local and remote
-//! case.
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-fn time_now_current_thread(c: &mut Criterion) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_time()
-        .build()
-        .unwrap();
-
-    c.bench_function("time_now_current_thread", |b| {
-        b.iter(|| {
-            rt.block_on(async {
-                black_box(tokio::time::Instant::now());
-            })
-        })
-    });
-}
-
-criterion_group!(time_now, time_now_current_thread);
-
-criterion_main!(time_now);

examples/Cargo.toml

@@ -2,7 +2,7 @@
 name = "examples"
 version = "0.0.0"
 publish = false
-edition = "2021"
+edition = "2018"
 
 # If you copy one of the examples into a new project, you should be using
 # [dependencies] instead, and delete the **path**.
@@ -24,8 +24,8 @@ httpdate = "1.0"
 once_cell = "1.5.2"
 rand = "0.8.3"
 
-[target.'cfg(windows)'.dev-dependencies.windows-sys]
-version = "0.48"
+[target.'cfg(windows)'.dev-dependencies.winapi]
+version = "0.3.8"
 
 [[example]]
 name = "chat"
@@ -75,6 +75,7 @@ path = "tinyhttp.rs"
 name = "custom-executor"
 path = "custom-executor.rs"
 
+
 [[example]]
 name = "custom-executor-tokio-context"
 path = "custom-executor-tokio-context.rs"
@@ -90,7 +91,3 @@ path = "named-pipe-ready.rs"
 [[example]]
 name = "named-pipe-multi-client"
 path = "named-pipe-multi-client.rs"
-
-[[example]]
-name = "dump"
-path = "dump.rs"

examples/dump.rs

@@ -1,90 +0,0 @@
-//! This example demonstrates tokio's experimental task dumping functionality.
-//! This application deadlocks. Input CTRL+C to display traces of each task, or
-//! input CTRL+C twice within 1 second to quit.
-
-#[cfg(all(
-    tokio_unstable,
-    tokio_taskdump,
-    target_os = "linux",
-    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
-))]
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    use std::sync::Arc;
-    use tokio::sync::Barrier;
-
-    #[inline(never)]
-    async fn a(barrier: Arc<Barrier>) {
-        b(barrier).await
-    }
-
-    #[inline(never)]
-    async fn b(barrier: Arc<Barrier>) {
-        c(barrier).await
-    }
-
-    #[inline(never)]
-    async fn c(barrier: Arc<Barrier>) {
-        barrier.wait().await;
-    }
-
-    // Prints a task dump upon receipt of CTRL+C, or returns if CTRL+C is
-    // inputted twice within a second.
-    async fn dump_or_quit() {
-        use tokio::time::{timeout, Duration, Instant};
-        let handle = tokio::runtime::Handle::current();
-        let mut last_signal: Option<Instant> = None;
-        // wait for CTRL+C
-        while let Ok(_) = tokio::signal::ctrl_c().await {
-            // exit if a CTRL+C is inputted twice within 1 second
-            if let Some(time_since_last_signal) = last_signal.map(|i| i.elapsed()) {
-                if time_since_last_signal < Duration::from_secs(1) {
-                    return;
-                }
-            }
-            last_signal = Some(Instant::now());
-
-            // capture a dump, and print each trace
-            println!("{:-<80}", "");
-            if let Ok(dump) = timeout(Duration::from_secs(2), handle.dump()).await {
-                for (i, task) in dump.tasks().iter().enumerate() {
-                    let trace = task.trace();
-                    println!("TASK {i}:");
-                    println!("{trace}\n");
-                }
-            } else {
-                println!("Task dumping timed out. Use a native debugger (like gdb) to debug the deadlock.");
-            }
-            println!("{:-<80}", "");
-            println!("Input CTRL+C twice within 1 second to exit.");
-        }
-    }
-
-    println!("This program has a deadlock.");
-    println!("Input CTRL+C to print a task dump.");
-    println!("Input CTRL+C twice within 1 second to exit.");
-
-    // oops! this barrier waits for one more task than will ever come.
-    let barrier = Arc::new(Barrier::new(3));
-
-    let task_1 = tokio::spawn(a(barrier.clone()));
-    let task_2 = tokio::spawn(a(barrier));
-
-    tokio::select!(
-        _ = dump_or_quit() => {},
-        _ = task_1 => {},
-        _ = task_2 => {},
-    );
-
-    Ok(())
-}
-
-#[cfg(not(all(
-    tokio_unstable,
-    tokio_taskdump,
-    target_os = "linux",
-    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
-)))]
-fn main() {
-    println!("task dumps are not available")
-}

examples/hello_world.rs

@@ -1,7 +1,9 @@
+//! Hello world server.
+//!
 //! A simple client that opens a TCP stream, writes "hello world\n", and closes
 //! the connection.
 //!
-//! To start a server that this client can talk to on port 6142, you can use this command:
+//! You can test this out by running:
 //!
 //!     ncat -l 6142
 //!
@@ -24,7 +26,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
     let mut stream = TcpStream::connect("127.0.0.1:6142").await?;
     println!("created stream");
 
-    let result = stream.write_all(b"hello world\n").await;
+    let result = stream.write(b"hello world\n").await;
     println!("wrote to stream; success={:?}", result.is_ok());
 
     Ok(())

examples/named-pipe-multi-client.rs

@@ -6,7 +6,7 @@ async fn windows_main() -> io::Result<()> {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
     use tokio::time;
-    use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;
+    use winapi::shared::winerror;
 
     const PIPE_NAME: &str = r"\\.\pipe\named-pipe-multi-client";
     const N: usize = 10;
@@ -59,7 +59,7 @@ async fn windows_main() -> io::Result<()> {
             let mut client = loop {
                 match ClientOptions::new().open(PIPE_NAME) {
                     Ok(client) => break client,
-                    Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
+                    Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (),
                     Err(e) => return Err(e),
                 }
 

examples/proxy.rs

@@ -22,7 +22,8 @@
 
 #![warn(rust_2018_idioms)]
 
-use tokio::io::copy_bidirectional;
+use tokio::io;
+use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 
 use futures::FutureExt;
@@ -43,19 +44,36 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let listener = TcpListener::bind(listen_addr).await?;
 
-    while let Ok((mut inbound, _)) = listener.accept().await {
-        let mut outbound = TcpStream::connect(server_addr.clone()).await?;
-
-        tokio::spawn(async move {
-            copy_bidirectional(&mut inbound, &mut outbound)
-                .map(|r| {
-                    if let Err(e) = r {
-                        println!("Failed to transfer; error={}", e);
-                    }
-                })
-                .await
+    while let Ok((inbound, _)) = listener.accept().await {
+        let transfer = transfer(inbound, server_addr.clone()).map(|r| {
+            if let Err(e) = r {
+                println!("Failed to transfer; error={}", e);
+            }
         });
+
+        tokio::spawn(transfer);
     }
 
     Ok(())
 }
+
+async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn Error>> {
+    let mut outbound = TcpStream::connect(proxy_addr).await?;
+
+    let (mut ri, mut wi) = inbound.split();
+    let (mut ro, mut wo) = outbound.split();
+
+    let client_to_server = async {
+        io::copy(&mut ri, &mut wo).await?;
+        wo.shutdown().await
+    };
+
+    let server_to_client = async {
+        io::copy(&mut ro, &mut wi).await?;
+        wi.shutdown().await
+    };
+
+    tokio::try_join!(client_to_server, server_to_client)?;
+
+    Ok(())
+}

examples/tinyhttp.rs

@@ -180,11 +180,8 @@ impl Decoder for Http {
                 headers[i] = Some((k, v));
             }
 
-            let method = http::Method::try_from(r.method.unwrap())
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
             (
-                method,
+                toslice(r.method.unwrap().as_bytes()),
                 toslice(r.path.unwrap().as_bytes()),
                 r.version.unwrap(),
                 amt,
@@ -198,7 +195,7 @@ impl Decoder for Http {
         }
         let data = src.split_to(amt).freeze();
         let mut ret = Request::builder();
-        ret = ret.method(method);
+        ret = ret.method(&data[method.0..method.1]);
         let s = data.slice(path.0..path.1);
         let s = unsafe { String::from_utf8_unchecked(Vec::from(s.as_ref())) };
         ret = ret.uri(s);

stress-test/Cargo.toml

@@ -2,7 +2,7 @@
 name = "stress-test"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
+edition = "2018"
 publish = false
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

target-specs/i686-unknown-linux-gnu.json

@@ -1,40 +0,0 @@
-{
-  "arch": "x86",
-  "cpu": "pentium4",
-  "crt-static-respected": true,
-  "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128",
-  "dynamic-linking": true,
-  "env": "gnu",
-  "has-rpath": true,
-  "has-thread-local": true,
-  "llvm-target": "i686-unknown-linux-gnu",
-  "max-atomic-width": 32,
-  "os": "linux",
-  "position-independent-executables": true,
-  "pre-link-args": {
-    "gcc": [
-      "-m32"
-    ]
-  },
-  "relro-level": "full",
-  "stack-probes": {
-    "kind": "inline-or-call",
-    "min-llvm-version-for-inline": [
-      16,
-      0,
-      0
-    ]
-  },
-  "supported-sanitizers": [
-    "address"
-  ],
-  "supported-split-debuginfo": [
-    "packed",
-    "unpacked",
-    "off"
-  ],
-  "target-family": [
-    "unix"
-  ],
-  "target-pointer-width": "32"
-}

tests-build/Cargo.toml

@@ -2,7 +2,7 @@
 name = "tests-build"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
+edition = "2018"
 publish = false
 
 [features]

tests-build/tests/fail/macros_invalid_input.rs

@@ -36,10 +36,13 @@ async fn test_worker_threads_not_int() {}
 async fn test_worker_threads_and_current_thread() {}
 
 #[tokio::test(crate = 456)]
-async fn test_crate_not_path_int() {}
+async fn test_crate_not_ident_int() {}
 
 #[tokio::test(crate = "456")]
-async fn test_crate_not_path_invalid() {}
+async fn test_crate_not_ident_invalid() {}
+
+#[tokio::test(crate = "abc::edf")]
+async fn test_crate_not_ident_path() {}
 
 #[tokio::test]
 #[test]

tests-build/tests/fail/macros_invalid_input.stderr

@@ -64,28 +64,34 @@ error: The `worker_threads` option requires the `multi_thread` runtime flavor. U
 35 | #[tokio::test(flavor = "current_thread", worker_threads = 4)]
    |                                                           ^
 
-error: Failed to parse value of `crate` as path.
+error: Failed to parse value of `crate` as ident.
   --> $DIR/macros_invalid_input.rs:38:23
    |
 38 | #[tokio::test(crate = 456)]
    |                       ^^^
 
-error: Failed to parse value of `crate` as path: "456"
+error: Failed to parse value of `crate` as ident: "456"
   --> $DIR/macros_invalid_input.rs:41:23
    |
 41 | #[tokio::test(crate = "456")]
    |                       ^^^^^
 
-error: second test attribute is supplied
-  --> $DIR/macros_invalid_input.rs:45:1
+error: Failed to parse value of `crate` as ident: "abc::edf"
+  --> $DIR/macros_invalid_input.rs:44:23
    |
-45 | #[test]
+44 | #[tokio::test(crate = "abc::edf")]
+   |                       ^^^^^^^^^^
+
+error: second test attribute is supplied
+  --> $DIR/macros_invalid_input.rs:48:1
+   |
+48 | #[test]
    | ^^^^^^^
 
 error: duplicated attribute
-  --> $DIR/macros_invalid_input.rs:45:1
+  --> $DIR/macros_invalid_input.rs:48:1
    |
-45 | #[test]
+48 | #[test]
    | ^^^^^^^
    |
 note: the lint level is defined here

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,33 +1,33 @@
 error[E0308]: mismatched types
- --> tests/fail/macros_type_mismatch.rs:5:5
+ --> $DIR/macros_type_mismatch.rs:5:5
   |
 4 | async fn missing_semicolon_or_return_type() {
   |                                             - help: a return type might be missing here: `-> _`
 5 |     Ok(())
-  |     ^^^^^^ expected `()`, found `Result<(), _>`
+  |     ^^^^^^ expected `()`, found enum `Result`
   |
   = note: expected unit type `()`
                   found enum `Result<(), _>`
 
 error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:10:5
+  --> $DIR/macros_type_mismatch.rs:10:5
    |
 9  | async fn missing_return_type() {
    |                                - help: a return type might be missing here: `-> _`
 10 |     return Ok(());
-   |     ^^^^^^^^^^^^^^ expected `()`, found `Result<(), _>`
+   |     ^^^^^^^^^^^^^^ expected `()`, found enum `Result`
    |
    = note: expected unit type `()`
                    found enum `Result<(), _>`
 
 error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:23:5
+  --> $DIR/macros_type_mismatch.rs:23:5
    |
 14 | async fn extra_semicolon() -> Result<(), ()> {
    |                               -------------- expected `Result<(), ()>` because of return type
 ...
 23 |     Ok(());
-   |     ^^^^^^^ expected `Result<(), ()>`, found `()`
+   |     ^^^^^^^ expected enum `Result`, found `()`
    |
    = note:   expected enum `Result<(), ()>`
            found unit type `()`
@@ -38,7 +38,7 @@ help: try adding an expression at the end of the block
    |
 
 error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:32:5
+  --> $DIR/macros_type_mismatch.rs:32:5
    |
 30 | async fn issue_4635() {
    |                       - help: try adding a return type: `-> i32`

tests-integration/Cargo.toml

@@ -2,7 +2,7 @@
 name = "tests-integration"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
+edition = "2018"
 publish = false
 
 [[bin]]
@@ -58,4 +58,3 @@ tokio = { path = "../tokio" }
 tokio-test = { path = "../tokio-test", optional = true }
 doc-comment = "0.3.1"
 futures = { version = "0.3.0", features = ["async-await"] }
-bytes = "1.0.0"

tests-integration/tests/process_stdio.rs

@@ -7,6 +7,7 @@ use tokio::process::{Child, Command};
 use tokio_test::assert_ok;
 
 use futures::future::{self, FutureExt};
+use std::convert::TryInto;
 use std::env;
 use std::io;
 use std::process::{ExitStatus, Stdio};
@@ -189,54 +190,3 @@ async fn pipe_from_one_command_to_another() {
     assert!(second_status.expect("second status").success());
     assert!(third_status.expect("third status").success());
 }
-
-#[tokio::test]
-async fn vectored_writes() {
-    use bytes::{Buf, Bytes};
-    use std::{io::IoSlice, pin::Pin};
-    use tokio::io::AsyncWrite;
-
-    let mut cat = cat().spawn().unwrap();
-    let mut stdin = cat.stdin.take().unwrap();
-    let are_writes_vectored = stdin.is_write_vectored();
-    let mut stdout = cat.stdout.take().unwrap();
-
-    let write = async {
-        let mut input = Bytes::from_static(b"hello\n").chain(Bytes::from_static(b"world!\n"));
-        let mut writes_completed = 0;
-
-        futures::future::poll_fn(|cx| loop {
-            let mut slices = [IoSlice::new(&[]); 2];
-            let vectored = input.chunks_vectored(&mut slices);
-            if vectored == 0 {
-                return std::task::Poll::Ready(std::io::Result::Ok(()));
-            }
-            let n = futures::ready!(Pin::new(&mut stdin).poll_write_vectored(cx, &slices))?;
-            writes_completed += 1;
-            input.advance(n);
-        })
-        .await?;
-
-        drop(stdin);
-
-        std::io::Result::Ok(writes_completed)
-    };
-
-    let read = async {
-        let mut buffer = Vec::with_capacity(6 + 7);
-        stdout.read_to_end(&mut buffer).await?;
-        std::io::Result::Ok(buffer)
-    };
-
-    let (write, read, status) = future::join3(write, read, cat.wait()).await;
-
-    assert!(status.unwrap().success());
-
-    let writes_completed = write.unwrap();
-    // on unix our small payload should always fit in whatever default sized pipe with a single
-    // syscall. if multiple are used, then the forwarding does not work, or we are on a platform
-    // for which the `std` does not support vectored writes.
-    assert_eq!(writes_completed == 1, are_writes_vectored);
-
-    assert_eq!(&read.unwrap(), b"hello\nworld!\n");
-}

tokio-macros/CHANGELOG.md

@@ -1,44 +1,3 @@
-# 2.1.0 (April 25th, 2023)
-
-- macros: fix typo in `#[tokio::test]` docs ([#5636])
-- macros: make entrypoints more efficient ([#5621])
-
-[#5621]: https://github.com/tokio-rs/tokio/pull/5621
-[#5636]: https://github.com/tokio-rs/tokio/pull/5636
-
-# 2.0.0 (March 24th, 2023)
-
-This major release updates the dependency on the syn crate to 2.0.0, and
-increases the MSRV to 1.56.
-
-As part of this release, we are adopting a policy of depending on a specific minor
-release of tokio-macros. This prevents Tokio from being able to pull in many different
-versions of tokio-macros.
-
-- macros: update `syn` ([#5572])
-- macros: accept path as crate rename ([#5557])
-
-[#5572]: https://github.com/tokio-rs/tokio/pull/5572
-[#5557]: https://github.com/tokio-rs/tokio/pull/5557
-
-# 1.8.2 (November 30th, 2022)
-
-- fix a regression introduced in 1.8.1 ([#5244])
-
-[#5244]: https://github.com/tokio-rs/tokio/pull/5244
-
-# 1.8.1 (November 29th, 2022)
-
-(yanked)
-
-- macros: Pin Futures in `#[tokio::test]` to stack ([#5205])
-- macros: Reduce usage of last statement spans in proc-macros ([#5092])
-- macros: Improve the documentation for `#[tokio::test]` ([#4761])
-
-[#5205]: https://github.com/tokio-rs/tokio/pull/5205
-[#5092]: https://github.com/tokio-rs/tokio/pull/5092
-[#4761]: https://github.com/tokio-rs/tokio/pull/4761
-
 # 1.8.0 (June 4th, 2022)
 
 - macros: always emit return statement ([#4636])

tokio-macros/Cargo.toml

@@ -3,10 +3,10 @@ name = "tokio-macros"
 # When releasing to crates.io:
 # - Remove path dependencies
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-1.x.y" git tag.
-version = "2.1.0"
-edition = "2021"
-rust-version = "1.56"
+# - Create "tokio-macros-1.0.x" git tag.
+version = "1.8.0"
+edition = "2018"
+rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -24,7 +24,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.7"
 quote = "1"
-syn = { version = "2.0", features = ["full"] }
+syn = { version = "1.0.56", features = ["full"] }
 
 [dev-dependencies]
 tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }

tokio-macros/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-macros/src/entry.rs

@@ -1,10 +1,10 @@
-use proc_macro2::{Span, TokenStream, TokenTree};
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span};
 use quote::{quote, quote_spanned, ToTokens};
-use syn::parse::{Parse, ParseStream, Parser};
-use syn::{braced, Attribute, Ident, Path, Signature, Visibility};
+use syn::parse::Parser;
 
 // syn::AttributeArgs does not implement syn::Parse
-type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![,]>;
+type AttributeArgs = syn::punctuated::Punctuated<syn::NestedMeta, syn::Token![,]>;
 
 #[derive(Clone, Copy, PartialEq)]
 enum RuntimeFlavor {
@@ -29,7 +29,7 @@ struct FinalConfig {
     flavor: RuntimeFlavor,
     worker_threads: Option<usize>,
     start_paused: Option<bool>,
-    crate_name: Option<Path>,
+    crate_name: Option<String>,
 }
 
 /// Config used in case of the attribute not being able to build a valid config
@@ -47,7 +47,7 @@ struct Configuration {
     worker_threads: Option<(usize, Span)>,
     start_paused: Option<(bool, Span)>,
     is_test: bool,
-    crate_name: Option<Path>,
+    crate_name: Option<String>,
 }
 
 impl Configuration {
@@ -112,8 +112,8 @@ impl Configuration {
         if self.crate_name.is_some() {
             return Err(syn::Error::new(span, "`crate` set multiple times."));
         }
-        let name_path = parse_path(name, span, "crate")?;
-        self.crate_name = Some(name_path);
+        let name_ident = parse_ident(name, span, "crate")?;
+        self.crate_name = Some(name_ident.to_string());
         Ok(())
     }
 
@@ -199,22 +199,23 @@ fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result<String, syn::E
     }
 }
 
-fn parse_path(lit: syn::Lit, span: Span, field: &str) -> Result<Path, syn::Error> {
+fn parse_ident(lit: syn::Lit, span: Span, field: &str) -> Result<Ident, syn::Error> {
     match lit {
         syn::Lit::Str(s) => {
             let err = syn::Error::new(
                 span,
                 format!(
-                    "Failed to parse value of `{}` as path: \"{}\"",
+                    "Failed to parse value of `{}` as ident: \"{}\"",
                     field,
                     s.value()
                 ),
             );
-            s.parse::<syn::Path>().map_err(|_| err.clone())
+            let path = s.parse::<syn::Path>().map_err(|_| err.clone())?;
+            path.get_ident().cloned().ok_or(err)
         }
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{}` as path.", field),
+            format!("Failed to parse value of `{}` as ident.", field),
         )),
     }
 }
@@ -230,7 +231,7 @@ fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, syn::Erro
 }
 
 fn build_config(
-    input: &ItemFn,
+    input: syn::ItemFn,
     args: AttributeArgs,
     is_test: bool,
     rt_multi_thread: bool,
@@ -245,7 +246,7 @@ fn build_config(
 
     for arg in args {
         match arg {
-            syn::Meta::NameValue(namevalue) => {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(namevalue)) => {
                 let ident = namevalue
                     .path
                     .get_ident()
@@ -254,26 +255,34 @@ fn build_config(
                     })?
                     .to_string()
                     .to_lowercase();
-                let lit = match &namevalue.value {
-                    syn::Expr::Lit(syn::ExprLit { lit, .. }) => lit,
-                    expr => return Err(syn::Error::new_spanned(expr, "Must be a literal")),
-                };
                 match ident.as_str() {
                     "worker_threads" => {
-                        config.set_worker_threads(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_worker_threads(
+                            namevalue.lit.clone(),
+                            syn::spanned::Spanned::span(&namevalue.lit),
+                        )?;
                     }
                     "flavor" => {
-                        config.set_flavor(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_flavor(
+                            namevalue.lit.clone(),
+                            syn::spanned::Spanned::span(&namevalue.lit),
+                        )?;
                     }
                     "start_paused" => {
-                        config.set_start_paused(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_start_paused(
+                            namevalue.lit.clone(),
+                            syn::spanned::Spanned::span(&namevalue.lit),
+                        )?;
                     }
                     "core_threads" => {
                         let msg = "Attribute `core_threads` is renamed to `worker_threads`";
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
                     "crate" => {
-                        config.set_crate_name(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_crate_name(
+                            namevalue.lit.clone(),
+                            syn::spanned::Spanned::span(&namevalue.lit),
+                        )?;
                     }
                     name => {
                         let msg = format!(
@@ -284,7 +293,7 @@ fn build_config(
                     }
                 }
             }
-            syn::Meta::Path(path) => {
+            syn::NestedMeta::Meta(syn::Meta::Path(path)) => {
                 let name = path
                     .get_ident()
                     .ok_or_else(|| syn::Error::new_spanned(&path, "Must have specified ident"))?
@@ -324,13 +333,18 @@ fn build_config(
     config.build()
 }
 
-fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenStream {
+fn parse_knobs(mut input: syn::ItemFn, is_test: bool, config: FinalConfig) -> TokenStream {
     input.sig.asyncness = None;
 
     // If type mismatch occurs, the current rustc points to the last statement.
     let (last_stmt_start_span, last_stmt_end_span) = {
-        let mut last_stmt = input.stmts.last().cloned().unwrap_or_default().into_iter();
-
+        let mut last_stmt = input
+            .block
+            .stmts
+            .last()
+            .map(ToTokens::into_token_stream)
+            .unwrap_or_default()
+            .into_iter();
         // `Span` on stable Rust has a limitation that only points to the first
         // token, not the whole tokens. We can work around this limitation by
         // using the first/last span of the tokens like
@@ -340,24 +354,23 @@ fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenSt
         (start, end)
     };
 
-    let crate_path = config
-        .crate_name
-        .map(ToTokens::into_token_stream)
-        .unwrap_or_else(|| Ident::new("tokio", last_stmt_start_span).into_token_stream());
+    let crate_name = config.crate_name.as_deref().unwrap_or("tokio");
+
+    let crate_ident = Ident::new(crate_name, last_stmt_start_span);
 
     let mut rt = match config.flavor {
         RuntimeFlavor::CurrentThread => quote_spanned! {last_stmt_start_span=>
-            #crate_path::runtime::Builder::new_current_thread()
+            #crate_ident::runtime::Builder::new_current_thread()
         },
         RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=>
-            #crate_path::runtime::Builder::new_multi_thread()
+            #crate_ident::runtime::Builder::new_multi_thread()
         },
     };
     if let Some(v) = config.worker_threads {
-        rt = quote_spanned! {last_stmt_start_span=> #rt.worker_threads(#v) };
+        rt = quote! { #rt.worker_threads(#v) };
     }
     if let Some(v) = config.start_paused {
-        rt = quote_spanned! {last_stmt_start_span=> #rt.start_paused(#v) };
+        rt = quote! { #rt.start_paused(#v) };
     }
 
     let header = if is_test {
@@ -368,53 +381,34 @@ fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenSt
         quote! {}
     };
 
-    let body_ident = quote! { body };
-    let last_block = quote_spanned! {last_stmt_end_span=>
-        #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
+    let body = &input.block;
+    let brace_token = input.block.brace_token;
+    input.block = syn::parse2(quote_spanned! {last_stmt_end_span=>
         {
-            return #rt
-                .enable_all()
-                .build()
-                .expect("Failed building the Runtime")
-                .block_on(#body_ident);
+            let body = async #body;
+            #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
+            {
+                return #rt
+                    .enable_all()
+                    .build()
+                    .expect("Failed building the Runtime")
+                    .block_on(body);
+            }
         }
+    })
+    .expect("Parsing failure");
+    input.block.brace_token = brace_token;
+
+    let result = quote! {
+        #header
+        #input
     };
 
-    let body = input.body();
-
-    // For test functions pin the body to the stack and use `Pin<&mut dyn
-    // Future>` to reduce the amount of `Runtime::block_on` (and related
-    // functions) copies we generate during compilation due to the generic
-    // parameter `F` (the future to block on). This could have an impact on
-    // performance, but because it's only for testing it's unlikely to be very
-    // large.
-    //
-    // We don't do this for the main function as it should only be used once so
-    // there will be no benefit.
-    let body = if is_test {
-        let output_type = match &input.sig.output {
-            // For functions with no return value syn doesn't print anything,
-            // but that doesn't work as `Output` for our boxed `Future`, so
-            // default to `()` (the same type as the function output).
-            syn::ReturnType::Default => quote! { () },
-            syn::ReturnType::Type(_, ret_type) => quote! { #ret_type },
-        };
-        quote! {
-            let body = async #body;
-            #crate_path::pin!(body);
-            let body: ::core::pin::Pin<&mut dyn ::core::future::Future<Output = #output_type>> = body;
-        }
-    } else {
-        quote! {
-            let body = async #body;
-        }
-    };
-
-    input.into_tokens(header, body, last_block)
+    result.into()
 }
 
 fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenStream {
-    tokens.extend(error.into_compile_error());
+    tokens.extend(TokenStream::from(error.into_compile_error()));
     tokens
 }
 
@@ -423,7 +417,7 @@ pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
     // If any of the steps for this macro fail, we still want to expand to an item that is as close
     // to the expected output as possible. This helps out IDEs such that completions and other
     // related features keep working.
-    let input: ItemFn = match syn::parse2(item.clone()) {
+    let input: syn::ItemFn = match syn::parse(item.clone()) {
         Ok(it) => it,
         Err(e) => return token_stream_with_error(item, e),
     };
@@ -433,8 +427,8 @@ pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
         Err(syn::Error::new_spanned(&input.sig.ident, msg))
     } else {
         AttributeArgs::parse_terminated
-            .parse2(args)
-            .and_then(|args| build_config(&input, args, false, rt_multi_thread))
+            .parse(args)
+            .and_then(|args| build_config(input.clone(), args, false, rt_multi_thread))
     };
 
     match config {
@@ -447,17 +441,17 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
     // If any of the steps for this macro fail, we still want to expand to an item that is as close
     // to the expected output as possible. This helps out IDEs such that completions and other
     // related features keep working.
-    let input: ItemFn = match syn::parse2(item.clone()) {
+    let input: syn::ItemFn = match syn::parse(item.clone()) {
         Ok(it) => it,
         Err(e) => return token_stream_with_error(item, e),
     };
-    let config = if let Some(attr) = input.attrs().find(|attr| attr.meta.path().is_ident("test")) {
+    let config = if let Some(attr) = input.attrs.iter().find(|attr| attr.path.is_ident("test")) {
         let msg = "second test attribute is supplied";
-        Err(syn::Error::new_spanned(attr, msg))
+        Err(syn::Error::new_spanned(&attr, msg))
     } else {
         AttributeArgs::parse_terminated
-            .parse2(args)
-            .and_then(|args| build_config(&input, args, true, rt_multi_thread))
+            .parse(args)
+            .and_then(|args| build_config(input.clone(), args, true, rt_multi_thread))
     };
 
     match config {
@@ -465,127 +459,3 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
         Err(e) => token_stream_with_error(parse_knobs(input, true, DEFAULT_ERROR_CONFIG), e),
     }
 }
-
-struct ItemFn {
-    outer_attrs: Vec<Attribute>,
-    vis: Visibility,
-    sig: Signature,
-    brace_token: syn::token::Brace,
-    inner_attrs: Vec<Attribute>,
-    stmts: Vec<proc_macro2::TokenStream>,
-}
-
-impl ItemFn {
-    /// Access all attributes of the function item.
-    fn attrs(&self) -> impl Iterator<Item = &Attribute> {
-        self.outer_attrs.iter().chain(self.inner_attrs.iter())
-    }
-
-    /// Get the body of the function item in a manner so that it can be
-    /// conveniently used with the `quote!` macro.
-    fn body(&self) -> Body<'_> {
-        Body {
-            brace_token: self.brace_token,
-            stmts: &self.stmts,
-        }
-    }
-
-    /// Convert our local function item into a token stream.
-    fn into_tokens(
-        self,
-        header: proc_macro2::TokenStream,
-        body: proc_macro2::TokenStream,
-        last_block: proc_macro2::TokenStream,
-    ) -> TokenStream {
-        let mut tokens = proc_macro2::TokenStream::new();
-        header.to_tokens(&mut tokens);
-
-        // Outer attributes are simply streamed as-is.
-        for attr in self.outer_attrs {
-            attr.to_tokens(&mut tokens);
-        }
-
-        // Inner attributes require extra care, since they're not supported on
-        // blocks (which is what we're expanded into) we instead lift them
-        // outside of the function. This matches the behaviour of `syn`.
-        for mut attr in self.inner_attrs {
-            attr.style = syn::AttrStyle::Outer;
-            attr.to_tokens(&mut tokens);
-        }
-
-        self.vis.to_tokens(&mut tokens);
-        self.sig.to_tokens(&mut tokens);
-
-        self.brace_token.surround(&mut tokens, |tokens| {
-            body.to_tokens(tokens);
-            last_block.to_tokens(tokens);
-        });
-
-        tokens
-    }
-}
-
-impl Parse for ItemFn {
-    #[inline]
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        // This parse implementation has been largely lifted from `syn`, with
-        // the exception of:
-        // * We don't have access to the plumbing necessary to parse inner
-        //   attributes in-place.
-        // * We do our own statements parsing to avoid recursively parsing
-        //   entire statements and only look for the parts we're interested in.
-
-        let outer_attrs = input.call(Attribute::parse_outer)?;
-        let vis: Visibility = input.parse()?;
-        let sig: Signature = input.parse()?;
-
-        let content;
-        let brace_token = braced!(content in input);
-        let inner_attrs = Attribute::parse_inner(&content)?;
-
-        let mut buf = proc_macro2::TokenStream::new();
-        let mut stmts = Vec::new();
-
-        while !content.is_empty() {
-            if let Some(semi) = content.parse::<Option<syn::Token![;]>>()? {
-                semi.to_tokens(&mut buf);
-                stmts.push(buf);
-                buf = proc_macro2::TokenStream::new();
-                continue;
-            }
-
-            // Parse a single token tree and extend our current buffer with it.
-            // This avoids parsing the entire content of the sub-tree.
-            buf.extend([content.parse::<TokenTree>()?]);
-        }
-
-        if !buf.is_empty() {
-            stmts.push(buf);
-        }
-
-        Ok(Self {
-            outer_attrs,
-            vis,
-            sig,
-            brace_token,
-            inner_attrs,
-            stmts,
-        })
-    }
-}
-
-struct Body<'a> {
-    brace_token: syn::token::Brace,
-    // Statements, with terminating `;`.
-    stmts: &'a [TokenStream],
-}
-
-impl ToTokens for Body<'_> {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        self.brace_token.surround(tokens, |tokens| {
-            for stmt in self.stmts {
-                stmt.to_tokens(tokens);
-            }
-        })
-    }
-}

tokio-macros/src/lib.rs

@@ -39,13 +39,6 @@ use proc_macro::TokenStream;
 /// function is called often, it is preferable to create the runtime using the
 /// runtime builder so the runtime can be reused across calls.
 ///
-/// # Non-worker async function
-///
-/// Note that the async function marked with this macro does not run as a
-/// worker. The expectation is that other tasks are spawned by the function here.
-/// Awaiting on other futures from the function provided here will not
-/// perform as fast as those spawned as workers.
-///
 /// # Multi-threaded runtime
 ///
 /// To use the multi-threaded runtime, the macro can be configured using
@@ -204,12 +197,12 @@ use proc_macro::TokenStream;
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::main(args.into(), item.into(), true).into()
+    entry::main(args, item, true)
 }
 
 /// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
 /// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
 /// ## Function arguments:
 ///
@@ -269,7 +262,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::main(args.into(), item.into(), false).into()
+    entry::main(args, item, false)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment.
@@ -295,7 +288,8 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 ///
 /// The `worker_threads` option configures the number of worker threads, and
-/// defaults to the number of cpus on the system.
+/// defaults to the number of cpus on the system. This is the default
+/// flavor.
 ///
 /// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
 /// flag.
@@ -426,7 +420,7 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::test(args.into(), item.into(), true).into()
+    entry::test(args, item, true)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment
@@ -441,7 +435,7 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::test(args.into(), item.into(), false).into()
+    entry::test(args, item, false)
 }
 
 /// Always fails with the error message below.

tokio-macros/src/select.rs

@@ -1,7 +1,7 @@
 use proc_macro::{TokenStream, TokenTree};
 use proc_macro2::Span;
 use quote::quote;
-use syn::{parse::Parser, Ident};
+use syn::Ident;
 
 pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
     // passed in is: `(_ _ _)` with one `_` per branch
@@ -46,7 +46,7 @@ pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream {
     // If this isn't a pattern, we return the token stream as-is. The select!
     // macro is using it in a location requiring a pattern, so an error will be
     // emitted there.
-    let mut input: syn::Pat = match syn::Pat::parse_single.parse(input.clone()) {
+    let mut input: syn::Pat = match syn::parse(input.clone()) {
         Ok(it) => it,
         Err(_) => return input,
     };
@@ -58,6 +58,7 @@ pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream {
 // Removes any occurrences of ref or mut in the provided pattern.
 fn clean_pattern(pat: &mut syn::Pat) {
     match pat {
+        syn::Pat::Box(_box) => {}
         syn::Pat::Lit(_literal) => {}
         syn::Pat::Macro(_macro) => {}
         syn::Pat::Path(_path) => {}
@@ -93,16 +94,16 @@ fn clean_pattern(pat: &mut syn::Pat) {
             }
         }
         syn::Pat::TupleStruct(tuple) => {
-            for elem in tuple.elems.iter_mut() {
+            for elem in tuple.pat.elems.iter_mut() {
                 clean_pattern(elem);
             }
         }
         syn::Pat::Reference(reference) => {
             reference.mutability = None;
-            clean_pattern(&mut reference.pat);
+            clean_pattern(&mut *reference.pat);
         }
         syn::Pat::Type(type_pat) => {
-            clean_pattern(&mut type_pat.pat);
+            clean_pattern(&mut *type_pat.pat);
         }
         _ => {}
     }

tokio-stream/CHANGELOG.md

@@ -1,46 +1,3 @@
-# 0.1.14 (April 26th, 2023)
-
-This bugfix release bumps the minimum version of Tokio to 1.15, which is
-necessary for `timeout_repeating` to compile. ([#5657])
-
-[#5657]: https://github.com/tokio-rs/tokio/pull/5657
-
-# 0.1.13 (April 25th, 2023)
-
-This release bumps the MSRV of tokio-stream to 1.56.
-
-- stream: add "full" feature flag ([#5639])
-- stream: add `StreamExt::timeout_repeating` ([#5577])
-- stream: add `StreamNotifyClose` ([#4851])
-
-[#4851]: https://github.com/tokio-rs/tokio/pull/4851
-[#5577]: https://github.com/tokio-rs/tokio/pull/5577
-[#5639]: https://github.com/tokio-rs/tokio/pull/5639
-
-# 0.1.12 (January 20, 2023)
-
-- time: remove `Unpin` bound on `Throttle` methods ([#5105])
-- time: document that `throttle` operates on ms granularity ([#5101])
-- sync: add `WatchStream::from_changes` ([#5432])
-
-[#5105]: https://github.com/tokio-rs/tokio/pull/5105
-[#5101]: https://github.com/tokio-rs/tokio/pull/5101
-[#5432]: https://github.com/tokio-rs/tokio/pull/5432
-
-# 0.1.11 (October 11, 2022)
-
-- time: allow `StreamExt::chunks_timeout` outside of a runtime ([#5036])
-
-[#5036]: https://github.com/tokio-rs/tokio/pull/5036
-
-# 0.1.10 (Sept 18, 2022)
-
-- time: add `StreamExt::chunks_timeout` ([#4695])
-- stream: add track_caller to public APIs ([#4786])
-
-[#4695]: https://github.com/tokio-rs/tokio/pull/4695
-[#4786]: https://github.com/tokio-rs/tokio/pull/4786
-
 # 0.1.9 (June 4, 2022)
 
 - deps: upgrade `tokio-util` dependency to `0.7.x` ([#3762])

tokio-stream/Cargo.toml

@@ -4,9 +4,9 @@ name = "tokio-stream"
 # - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.14"
-edition = "2021"
-rust-version = "1.56"
+version = "0.1.9"
+edition = "2018"
+rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -18,16 +18,6 @@ categories = ["asynchronous"]
 
 [features]
 default = ["time"]
-
-full = [
-    "time",
-    "net",
-    "io-util",
-    "fs",
-    "sync",
-    "signal"
-]
-
 time = ["tokio/time"]
 net = ["tokio/net"]
 io-util = ["tokio/io-util"]
@@ -37,8 +27,8 @@ signal = ["tokio/signal"]
 
 [dependencies]
 futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.11"
-tokio = { version = "1.15.0", path = "../tokio", features = ["sync"] }
+pin-project-lite = "0.2.0"
+tokio = { version = "1.8.0", path = "../tokio", features = ["sync"] }
 tokio-util = { version = "0.7.0", path = "../tokio-util", optional = true }
 
 [dev-dependencies]
@@ -48,6 +38,9 @@ parking_lot = "0.12.0"
 tokio-test = { path = "../tokio-test" }
 futures = { version = "0.3", default-features = false }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+proptest = "1"
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

tokio-stream/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-stream/fuzz/.gitignore

@@ -1,4 +0,0 @@
-target
-corpus
-artifacts
-coverage

tokio-stream/fuzz/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "tokio-stream-fuzz"
-version = "0.0.0"
-publish = false
-edition = "2021"
-
-[package.metadata]
-cargo-fuzz = true
-
-[dependencies]
-libfuzzer-sys = "0.4"
-tokio-test = { path = "../../tokio-test" }
-
-[dependencies.tokio-stream]
-path = ".."
-
-
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
-
-[profile.release]
-debug = 1
-
-[[bin]]
-name = "fuzz_stream_map"
-path = "fuzz_targets/fuzz_stream_map.rs"
-test = false
-doc = false

tokio-stream/fuzz/fuzz_targets/fuzz_stream_map.rs

@@ -1,72 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-use std::pin::Pin;
-
-use tokio_stream::{self as stream, Stream, StreamMap};
-use tokio_test::{assert_pending, assert_ready, task};
-
-macro_rules! assert_ready_none {
-    ($($t:tt)*) => {
-        match assert_ready!($($t)*) {
-            None => {}
-            Some(v) => panic!("expected `None`, got `Some({:?})`", v),
-        }
-    };
-}
-
-fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream<Item = U>>> {
-    Box::pin(s)
-}
-
-fuzz_target!(|data: [bool; 64]| {
-    use std::task::{Context, Poll};
-
-    struct DidPoll<T> {
-        did_poll: bool,
-        inner: T,
-    }
-
-    impl<T: Stream + Unpin> Stream for DidPoll<T> {
-        type Item = T::Item;
-
-        fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T::Item>> {
-            self.did_poll = true;
-            Pin::new(&mut self.inner).poll_next(cx)
-        }
-    }
-
-    // Try the test with each possible length.
-    for len in 0..data.len() {
-        let mut map = task::spawn(StreamMap::new());
-        let mut expect = 0;
-
-        for (i, is_empty) in data[..len].iter().copied().enumerate() {
-            let inner = if is_empty {
-                pin_box(stream::empty::<()>())
-            } else {
-                expect += 1;
-                pin_box(stream::pending::<()>())
-            };
-
-            let stream = DidPoll {
-                did_poll: false,
-                inner,
-            };
-
-            map.insert(i, stream);
-        }
-
-        if expect == 0 {
-            assert_ready_none!(map.poll_next());
-        } else {
-            assert_pending!(map.poll_next());
-
-            assert_eq!(expect, map.values().count());
-
-            for stream in map.values() {
-                assert!(stream.did_poll);
-            }
-        }
-    }
-});

tokio-stream/src/lib.rs

@@ -63,12 +63,12 @@
 //! [`tokio-util`] provides the [`StreamReader`] and [`ReaderStream`]
 //! types when the io feature is enabled.
 //!
-//! [`tokio-util`]: https://docs.rs/tokio-util/latest/tokio_util/codec/index.html
-//! [`tokio::io`]: https://docs.rs/tokio/latest/tokio/io/index.html
-//! [`AsyncRead`]: https://docs.rs/tokio/latest/tokio/io/trait.AsyncRead.html
-//! [`AsyncWrite`]: https://docs.rs/tokio/latest/tokio/io/trait.AsyncWrite.html
-//! [`ReaderStream`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.ReaderStream.html
-//! [`StreamReader`]: https://docs.rs/tokio-util/latest/tokio_util/io/struct.StreamReader.html
+//! [`tokio-util`]: https://docs.rs/tokio-util/0.4/tokio_util/codec/index.html
+//! [`tokio::io`]: https://docs.rs/tokio/1.0/tokio/io/index.html
+//! [`AsyncRead`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncRead.html
+//! [`AsyncWrite`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncWrite.html
+//! [`ReaderStream`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.ReaderStream.html
+//! [`StreamReader`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.StreamReader.html
 
 #[macro_use]
 mod macros;
@@ -96,8 +96,5 @@ pub use pending::{pending, Pending};
 mod stream_map;
 pub use stream_map::StreamMap;
 
-mod stream_close;
-pub use stream_close::StreamNotifyClose;
-
 #[doc(no_inline)]
 pub use futures_core::Stream;

tokio-stream/src/stream_close.rs

@@ -1,93 +0,0 @@
-use crate::Stream;
-use pin_project_lite::pin_project;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-pin_project! {
-    /// A `Stream` that wraps the values in an `Option`.
-    ///
-    /// Whenever the wrapped stream yields an item, this stream yields that item
-    /// wrapped in `Some`. When the inner stream ends, then this stream first
-    /// yields a `None` item, and then this stream will also end.
-    ///
-    /// # Example
-    ///
-    /// Using `StreamNotifyClose` to handle closed streams with `StreamMap`.
-    ///
-    /// ```
-    /// use tokio_stream::{StreamExt, StreamMap, StreamNotifyClose};
-    ///
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let mut map = StreamMap::new();
-    ///     let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-    ///     let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-    ///     map.insert(0, stream);
-    ///     map.insert(1, stream2);
-    ///     while let Some((key, val)) = map.next().await {
-    ///         match val {
-    ///             Some(val) => println!("got {val:?} from stream {key:?}"),
-    ///             None => println!("stream {key:?} closed"),
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    #[must_use = "streams do nothing unless polled"]
-    pub struct StreamNotifyClose<S> {
-        #[pin]
-        inner: Option<S>,
-    }
-}
-
-impl<S> StreamNotifyClose<S> {
-    /// Create a new `StreamNotifyClose`.
-    pub fn new(stream: S) -> Self {
-        Self {
-            inner: Some(stream),
-        }
-    }
-
-    /// Get back the inner `Stream`.
-    ///
-    /// Returns `None` if the stream has reached its end.
-    pub fn into_inner(self) -> Option<S> {
-        self.inner
-    }
-}
-
-impl<S> Stream for StreamNotifyClose<S>
-where
-    S: Stream,
-{
-    type Item = Option<S::Item>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        // We can't invoke poll_next after it ended, so we unset the inner stream as a marker.
-        match self
-            .as_mut()
-            .project()
-            .inner
-            .as_pin_mut()
-            .map(|stream| S::poll_next(stream, cx))
-        {
-            Some(Poll::Ready(Some(item))) => Poll::Ready(Some(Some(item))),
-            Some(Poll::Ready(None)) => {
-                self.project().inner.set(None);
-                Poll::Ready(Some(None))
-            }
-            Some(Poll::Pending) => Poll::Pending,
-            None => Poll::Ready(None),
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        if let Some(inner) = &self.inner {
-            // We always return +1 because when there's stream there's atleast one more item.
-            let (l, u) = inner.size_hint();
-            (l.saturating_add(1), u.and_then(|u| u.checked_add(1)))
-        } else {
-            (0, Some(0))
-        }
-    }
-}

tokio-stream/src/stream_ext.rs

@@ -57,10 +57,8 @@ use try_next::TryNext;
 
 cfg_time! {
     pub(crate) mod timeout;
-    pub(crate) mod timeout_repeating;
     use timeout::Timeout;
-    use timeout_repeating::TimeoutRepeating;
-    use tokio::time::{Duration, Interval};
+    use tokio::time::Duration;
     mod throttle;
     use throttle::{throttle, Throttle};
     mod chunks_timeout;
@@ -926,9 +924,7 @@ pub trait StreamExt: Stream {
     /// If the wrapped stream yields a value before the deadline is reached, the
     /// value is returned. Otherwise, an error is returned. The caller may decide
     /// to continue consuming the stream and will eventually get the next source
-    /// stream value once it becomes available. See
-    /// [`timeout_repeating`](StreamExt::timeout_repeating) for an alternative
-    /// where the timeouts will repeat.
+    /// stream value once it becomes available.
     ///
     /// # Notes
     ///
@@ -975,26 +971,7 @@ pub trait StreamExt: Stream {
     /// assert_eq!(int_stream.try_next().await, Ok(None));
     /// # }
     /// ```
-    ///
-    /// Once a timeout error is received, no further events will be received
-    /// unless the wrapped stream yields a value (timeouts do not repeat).
-    ///
-    /// ```
-    /// # #[tokio::main(flavor = "current_thread", start_paused = true)]
-    /// # async fn main() {
-    /// use tokio_stream::{StreamExt, wrappers::IntervalStream};
-    /// use std::time::Duration;
-    /// let interval_stream = IntervalStream::new(tokio::time::interval(Duration::from_millis(100)));
-    /// let timeout_stream = interval_stream.timeout(Duration::from_millis(10));
-    /// tokio::pin!(timeout_stream);
-    ///
-    /// // Only one timeout will be received between values in the source stream.
-    /// assert!(timeout_stream.try_next().await.is_ok());
-    /// assert!(timeout_stream.try_next().await.is_err(), "expected one timeout");
-    /// assert!(timeout_stream.try_next().await.is_ok(), "expected no more timeouts");
-    /// # }
-    /// ```
-    #[cfg(feature = "time")]
+    #[cfg(all(feature = "time"))]
     #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
     fn timeout(self, duration: Duration) -> Timeout<Self>
     where
@@ -1003,99 +980,8 @@ pub trait StreamExt: Stream {
         Timeout::new(self, duration)
     }
 
-    /// Applies a per-item timeout to the passed stream.
-    ///
-    /// `timeout_repeating()` takes an [`Interval`](tokio::time::Interval) that
-    /// controls the time each element of the stream has to complete before
-    /// timing out.
-    ///
-    /// If the wrapped stream yields a value before the deadline is reached, the
-    /// value is returned. Otherwise, an error is returned. The caller may decide
-    /// to continue consuming the stream and will eventually get the next source
-    /// stream value once it becomes available. Unlike `timeout()`, if no value
-    /// becomes available before the deadline is reached, additional errors are
-    /// returned at the specified interval. See [`timeout`](StreamExt::timeout)
-    /// for an alternative where the timeouts do not repeat.
-    ///
-    /// # Notes
-    ///
-    /// This function consumes the stream passed into it and returns a
-    /// wrapped version of it.
-    ///
-    /// Polling the returned stream will continue to poll the inner stream even
-    /// if one or more items time out.
-    ///
-    /// # Examples
-    ///
-    /// Suppose we have a stream `int_stream` that yields 3 numbers (1, 2, 3):
-    ///
-    /// ```
-    /// # #[tokio::main]
-    /// # async fn main() {
-    /// use tokio_stream::{self as stream, StreamExt};
-    /// use std::time::Duration;
-    /// # let int_stream = stream::iter(1..=3);
-    ///
-    /// let int_stream = int_stream.timeout_repeating(tokio::time::interval(Duration::from_secs(1)));
-    /// tokio::pin!(int_stream);
-    ///
-    /// // When no items time out, we get the 3 elements in succession:
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(1)));
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(2)));
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(3)));
-    /// assert_eq!(int_stream.try_next().await, Ok(None));
-    ///
-    /// // If the second item times out, we get an error and continue polling the stream:
-    /// # let mut int_stream = stream::iter(vec![Ok(1), Err(()), Ok(2), Ok(3)]);
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(1)));
-    /// assert!(int_stream.try_next().await.is_err());
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(2)));
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(3)));
-    /// assert_eq!(int_stream.try_next().await, Ok(None));
-    ///
-    /// // If we want to stop consuming the source stream the first time an
-    /// // element times out, we can use the `take_while` operator:
-    /// # let int_stream = stream::iter(vec![Ok(1), Err(()), Ok(2), Ok(3)]);
-    /// let mut int_stream = int_stream.take_while(Result::is_ok);
-    ///
-    /// assert_eq!(int_stream.try_next().await, Ok(Some(1)));
-    /// assert_eq!(int_stream.try_next().await, Ok(None));
-    /// # }
-    /// ```
-    ///
-    /// Timeout errors will be continuously produced at the specified interval
-    /// until the wrapped stream yields a value.
-    ///
-    /// ```
-    /// # #[tokio::main(flavor = "current_thread", start_paused = true)]
-    /// # async fn main() {
-    /// use tokio_stream::{StreamExt, wrappers::IntervalStream};
-    /// use std::time::Duration;
-    /// let interval_stream = IntervalStream::new(tokio::time::interval(Duration::from_millis(23)));
-    /// let timeout_stream = interval_stream.timeout_repeating(tokio::time::interval(Duration::from_millis(9)));
-    /// tokio::pin!(timeout_stream);
-    ///
-    /// // Multiple timeouts will be received between values in the source stream.
-    /// assert!(timeout_stream.try_next().await.is_ok());
-    /// assert!(timeout_stream.try_next().await.is_err(), "expected one timeout");
-    /// assert!(timeout_stream.try_next().await.is_err(), "expected a second timeout");
-    /// // Will eventually receive another value from the source stream...
-    /// assert!(timeout_stream.try_next().await.is_ok(), "expected non-timeout");
-    /// # }
-    /// ```
-    #[cfg(feature = "time")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
-    fn timeout_repeating(self, interval: Interval) -> TimeoutRepeating<Self>
-    where
-        Self: Sized,
-    {
-        TimeoutRepeating::new(self, interval)
-    }
-
     /// Slows down a stream by enforcing a delay between items.
     ///
-    /// The underlying timer behind this utility has a granularity of one millisecond.
-    ///
     /// # Example
     ///
     /// Create a throttled stream.
@@ -1113,7 +999,7 @@ pub trait StreamExt: Stream {
     /// }
     /// # }
     /// ```
-    #[cfg(feature = "time")]
+    #[cfg(all(feature = "time"))]
     #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
     fn throttle(self, duration: Duration) -> Throttle<Self>
     where

tokio-stream/src/stream_ext/chunks_timeout.rs

@@ -1,6 +1,6 @@
 use crate::stream_ext::Fuse;
 use crate::Stream;
-use tokio::time::{sleep, Sleep};
+use tokio::time::{sleep, Instant, Sleep};
 
 use core::future::Future;
 use core::pin::Pin;
@@ -16,7 +16,7 @@ pin_project! {
         #[pin]
         stream: Fuse<S>,
         #[pin]
-        deadline: Option<Sleep>,
+        deadline: Sleep,
         duration: Duration,
         items: Vec<S::Item>,
         cap: usize, // https://github.com/rust-lang/futures-rs/issues/1475
@@ -27,7 +27,7 @@ impl<S: Stream> ChunksTimeout<S> {
     pub(super) fn new(stream: S, max_size: usize, duration: Duration) -> Self {
         ChunksTimeout {
             stream: Fuse::new(stream),
-            deadline: None,
+            deadline: sleep(duration),
             duration,
             items: Vec::with_capacity(max_size),
             cap: max_size,
@@ -45,7 +45,7 @@ impl<S: Stream> Stream for ChunksTimeout<S> {
                 Poll::Pending => break,
                 Poll::Ready(Some(item)) => {
                     if me.items.is_empty() {
-                        me.deadline.set(Some(sleep(*me.duration)));
+                        me.deadline.as_mut().reset(Instant::now() + *me.duration);
                         me.items.reserve_exact(*me.cap);
                     }
                     me.items.push(item);
@@ -67,9 +67,7 @@ impl<S: Stream> Stream for ChunksTimeout<S> {
         }
 
         if !me.items.is_empty() {
-            if let Some(deadline) = me.deadline.as_pin_mut() {
-                ready!(deadline.poll(cx));
-            }
+            ready!(me.deadline.poll(cx));
             return Poll::Ready(Some(std::mem::take(me.items)));
         }
 

tokio-stream/src/stream_ext/collect.rs

@@ -195,7 +195,11 @@ where
         } else {
             let res = mem::replace(collection, Ok(U::initialize(sealed::Internal, 0, Some(0))));
 
-            Err(res.map(drop).unwrap_err())
+            if let Err(err) = res {
+                Err(err)
+            } else {
+                unreachable!();
+            }
         }
     }
 }

tokio-stream/src/stream_ext/take.rs

@@ -64,11 +64,11 @@ where
 
         let (lower, upper) = self.stream.size_hint();
 
-        let lower = cmp::min(lower, self.remaining);
+        let lower = cmp::min(lower, self.remaining as usize);
 
         let upper = match upper {
-            Some(x) if x < self.remaining => Some(x),
-            _ => Some(self.remaining),
+            Some(x) if x < self.remaining as usize => Some(x),
+            _ => Some(self.remaining as usize),
         };
 
         (lower, upper)

tokio-stream/src/stream_ext/then.rs

@@ -72,7 +72,7 @@ where
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let future_len = usize::from(self.future.is_some());
+        let future_len = if self.future.is_some() { 1 } else { 0 };
         let (lower, upper) = self.stream.size_hint();
 
         let lower = lower.saturating_add(future_len);

tokio-stream/src/stream_ext/throttle.rs

@@ -4,6 +4,7 @@ use crate::Stream;
 use tokio::time::{Duration, Instant, Sleep};
 
 use std::future::Future;
+use std::marker::Unpin;
 use std::pin::Pin;
 use std::task::{self, Poll};
 
@@ -40,7 +41,8 @@ pin_project! {
     }
 }
 
-impl<T> Throttle<T> {
+// XXX: are these safe if `T: !Unpin`?
+impl<T: Unpin> Throttle<T> {
     /// Acquires a reference to the underlying stream that this combinator is
     /// pulling from.
     pub fn get_ref(&self) -> &T {

tokio-stream/src/stream_ext/timeout.rs

@@ -23,8 +23,8 @@ pin_project! {
     }
 }
 
-/// Error returned by `Timeout` and `TimeoutRepeating`.
-#[derive(Debug, PartialEq, Eq)]
+/// Error returned by `Timeout`.
+#[derive(Debug, PartialEq)]
 pub struct Elapsed(());
 
 impl<S: Stream> Timeout<S> {

tokio-stream/src/stream_ext/timeout_repeating.rs

@@ -1,56 +0,0 @@
-use crate::stream_ext::Fuse;
-use crate::{Elapsed, Stream};
-use tokio::time::Interval;
-
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Stream returned by the [`timeout_repeating`](super::StreamExt::timeout_repeating) method.
-    #[must_use = "streams do nothing unless polled"]
-    #[derive(Debug)]
-    pub struct TimeoutRepeating<S> {
-        #[pin]
-        stream: Fuse<S>,
-        #[pin]
-        interval: Interval,
-    }
-}
-
-impl<S: Stream> TimeoutRepeating<S> {
-    pub(super) fn new(stream: S, interval: Interval) -> Self {
-        TimeoutRepeating {
-            stream: Fuse::new(stream),
-            interval,
-        }
-    }
-}
-
-impl<S: Stream> Stream for TimeoutRepeating<S> {
-    type Item = Result<S::Item, Elapsed>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let mut me = self.project();
-
-        match me.stream.poll_next(cx) {
-            Poll::Ready(v) => {
-                if v.is_some() {
-                    me.interval.reset();
-                }
-                return Poll::Ready(v.map(Ok));
-            }
-            Poll::Pending => {}
-        };
-
-        ready!(me.interval.poll_tick(cx));
-        Poll::Ready(Some(Err(Elapsed::new())))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (lower, _) = self.stream.size_hint();
-
-        // The timeout stream may insert an error an infinite number of times.
-        (lower, None)
-    }
-}

tokio-stream/src/stream_map.rs

@@ -42,18 +42,10 @@ use std::task::{Context, Poll};
 /// to be merged, it may be advisable to use tasks sending values on a shared
 /// [`mpsc`] channel.
 ///
-/// # Notes
-///
-/// `StreamMap` removes finished streams automatically, without alerting the user.
-/// In some scenarios, the caller would want to know on closed streams.
-/// To do this, use [`StreamNotifyClose`] as a wrapper to your stream.
-/// It will return None when the stream is closed.
-///
 /// [`StreamExt::merge`]: crate::StreamExt::merge
 /// [`mpsc`]: https://docs.rs/tokio/1.0/tokio/sync/mpsc/index.html
 /// [`pin!`]: https://docs.rs/tokio/1.0/tokio/macro.pin.html
 /// [`Box::pin`]: std::boxed::Box::pin
-/// [`StreamNotifyClose`]: crate::StreamNotifyClose
 ///
 /// # Examples
 ///
@@ -178,28 +170,6 @@ use std::task::{Context, Poll};
 ///     }
 /// }
 /// ```
-///
-/// Using `StreamNotifyClose` to handle closed streams with `StreamMap`.
-///
-/// ```
-/// use tokio_stream::{StreamExt, StreamMap, StreamNotifyClose};
-///
-/// #[tokio::main]
-/// async fn main() {
-///     let mut map = StreamMap::new();
-///     let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-///     let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-///     map.insert(0, stream);
-///     map.insert(1, stream2);
-///     while let Some((key, val)) = map.next().await {
-///         match val {
-///             Some(val) => println!("got {val:?} from stream {key:?}"),
-///             None => println!("stream {key:?} closed"),
-///         }
-///     }
-/// }
-/// ```
-
 #[derive(Debug)]
 pub struct StreamMap<K, V> {
     /// Streams stored in the map
@@ -598,7 +568,7 @@ where
     }
 }
 
-impl<K, V> FromIterator<(K, V)> for StreamMap<K, V>
+impl<K, V> std::iter::FromIterator<(K, V)> for StreamMap<K, V>
 where
     K: Hash + Eq,
 {

tokio-stream/src/wrappers/broadcast.rs

@@ -18,7 +18,7 @@ pub struct BroadcastStream<T> {
 }
 
 /// An error returned from the inner stream of a [`BroadcastStream`].
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum BroadcastStreamRecvError {
     /// The receiver lagged too far behind. Attempting to receive again will
     /// return the oldest message still retained by the channel.

tokio-stream/src/wrappers/watch.rs

@@ -10,9 +10,8 @@ use tokio::sync::watch::error::RecvError;
 
 /// A wrapper around [`tokio::sync::watch::Receiver`] that implements [`Stream`].
 ///
-/// This stream will start by yielding the current value when the WatchStream is polled,
-/// regardless of whether it was the initial value or sent afterwards,
-/// unless you use [`WatchStream<T>::from_changes`].
+/// This stream will always start by yielding the current value when the WatchStream is polled,
+/// regardless of whether it was the initial value or sent afterwards.
 ///
 /// # Examples
 ///
@@ -41,28 +40,6 @@ use tokio::sync::watch::error::RecvError;
 /// let (tx, rx) = watch::channel("hello");
 /// let mut rx = WatchStream::new(rx);
 ///
-/// // existing rx output with "hello" is ignored here
-///
-/// tx.send("goodbye").unwrap();
-/// assert_eq!(rx.next().await, Some("goodbye"));
-/// # }
-/// ```
-///
-/// Example with [`WatchStream<T>::from_changes`]:
-///
-/// ```
-/// # #[tokio::main]
-/// # async fn main() {
-/// use futures::future::FutureExt;
-/// use tokio::sync::watch;
-/// use tokio_stream::{StreamExt, wrappers::WatchStream};
-///
-/// let (tx, rx) = watch::channel("hello");
-/// let mut rx = WatchStream::from_changes(rx);
-///
-/// // no output from rx is available at this point - let's check this:
-/// assert!(rx.next().now_or_never().is_none());
-///
 /// tx.send("goodbye").unwrap();
 /// assert_eq!(rx.next().await, Some("goodbye"));
 /// # }
@@ -89,13 +66,6 @@ impl<T: 'static + Clone + Send + Sync> WatchStream<T> {
             inner: ReusableBoxFuture::new(async move { (Ok(()), rx) }),
         }
     }
-
-    /// Create a new `WatchStream` that waits for the value to be changed.
-    pub fn from_changes(rx: Receiver<T>) -> Self {
-        Self {
-            inner: ReusableBoxFuture::new(make_future(rx)),
-        }
-    }
 }
 
 impl<T: Clone + 'static + Send + Sync> Stream for WatchStream<T> {

tokio-stream/tests/stream_close.rs

@@ -1,11 +0,0 @@
-use tokio_stream::{StreamExt, StreamNotifyClose};
-
-#[tokio::test]
-async fn basic_usage() {
-    let mut stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
-
-    assert_eq!(stream.next().await, Some(Some(0)));
-    assert_eq!(stream.next().await, Some(Some(1)));
-    assert_eq!(stream.next().await, Some(None));
-    assert_eq!(stream.next().await, None);
-}

tokio-stream/tests/stream_stream_map.rs

@@ -325,6 +325,63 @@ fn one_ready_many_none() {
     }
 }
 
+#[cfg(not(target_os = "wasi"))]
+proptest::proptest! {
+    #[test]
+    fn fuzz_pending_complete_mix(kinds: Vec<bool>) {
+        use std::task::{Context, Poll};
+
+        struct DidPoll<T> {
+            did_poll: bool,
+            inner: T,
+        }
+
+        impl<T: Stream + Unpin> Stream for DidPoll<T> {
+            type Item = T::Item;
+
+            fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>)
+                -> Poll<Option<T::Item>>
+            {
+                self.did_poll = true;
+                Pin::new(&mut self.inner).poll_next(cx)
+            }
+        }
+
+        for _ in 0..10 {
+            let mut map = task::spawn(StreamMap::new());
+            let mut expect = 0;
+
+            for (i, &is_empty) in kinds.iter().enumerate() {
+                let inner = if is_empty {
+                    pin_box(stream::empty::<()>())
+                } else {
+                    expect += 1;
+                    pin_box(stream::pending::<()>())
+                };
+
+                let stream = DidPoll {
+                    did_poll: false,
+                    inner,
+                };
+
+                map.insert(i, stream);
+            }
+
+            if expect == 0 {
+                assert_ready_none!(map.poll_next());
+            } else {
+                assert_pending!(map.poll_next());
+
+                assert_eq!(expect, map.values().count());
+
+                for stream in map.values() {
+                    assert!(stream.did_poll);
+                }
+            }
+        }
+    }
+}
+
 fn pin_box<T: Stream<Item = U> + 'static, U>(s: T) -> Pin<Box<dyn Stream<Item = U>>> {
     Box::pin(s)
 }

tokio-stream/tests/watch.rs

@@ -3,11 +3,9 @@
 use tokio::sync::watch;
 use tokio_stream::wrappers::WatchStream;
 use tokio_stream::StreamExt;
-use tokio_test::assert_pending;
-use tokio_test::task::spawn;
 
 #[tokio::test]
-async fn watch_stream_message_not_twice() {
+async fn message_not_twice() {
     let (tx, rx) = watch::channel("hello");
 
     let mut counter = 0;
@@ -29,29 +27,3 @@ async fn watch_stream_message_not_twice() {
     drop(tx);
     task.await.unwrap();
 }
-
-#[tokio::test]
-async fn watch_stream_from_rx() {
-    let (tx, rx) = watch::channel("hello");
-
-    let mut stream = WatchStream::from(rx);
-
-    assert_eq!(stream.next().await.unwrap(), "hello");
-
-    tx.send("bye").unwrap();
-
-    assert_eq!(stream.next().await.unwrap(), "bye");
-}
-
-#[tokio::test]
-async fn watch_stream_from_changes() {
-    let (tx, rx) = watch::channel("hello");
-
-    let mut stream = WatchStream::from_changes(rx);
-
-    assert_pending!(spawn(&mut stream).poll_next());
-
-    tx.send("bye").unwrap();
-
-    assert_eq!(stream.next().await.unwrap(), "bye");
-}

tokio-test/CHANGELOG.md

@@ -1,17 +1,3 @@
-# 0.4.3 (August 23, 2023)
-
-- deps: fix minimum required version of `async-stream` ([#5347])
-- deps: fix minimum required version of `tokio-stream` ([#4376])
-- docs: improve `tokio_test::task` docs ([#5132])
-- io: fetch actions from mock handle before write ([#5814])
-- io: fix wait operation on mock ([#5554])
-
-[#4376]: https://github.com/tokio-rs/tokio/pull/4376
-[#5132]: https://github.com/tokio-rs/tokio/pull/5132
-[#5347]: https://github.com/tokio-rs/tokio/pull/5347
-[#5554]: https://github.com/tokio-rs/tokio/pull/5554
-[#5814]: https://github.com/tokio-rs/tokio/pull/5814
-
 # 0.4.2 (May 14, 2021)
 
 - test: add `assert_elapsed!` macro ([#3728])

tokio-test/Cargo.toml

@@ -4,9 +4,9 @@ name = "tokio-test"
 # - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-test-0.4.x" git tag.
-version = "0.4.3"
-edition = "2021"
-rust-version = "1.56"
+version = "0.4.2"
+edition = "2018"
+rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -14,12 +14,12 @@ homepage = "https://tokio.rs"
 description = """
 Testing utilities for Tokio- and futures-based code
 """
-categories = ["asynchronous", "development-tools::testing"]
+categories = ["asynchronous", "testing"]
 
 [dependencies]
 tokio = { version = "1.2.0", path = "../tokio", features = ["rt", "sync", "time", "test-util"] }
 tokio-stream = { version = "0.1.1", path = "../tokio-stream" }
-async-stream = "0.3.3"
+async-stream = "0.3"
 
 bytes = "1.0.0"
 futures-core = "0.3.0"

tokio-test/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-test/src/io.rs

@@ -310,8 +310,6 @@ impl Inner {
 
                         if now < until {
                             break;
-                        } else {
-                            self.waiting = None;
                         }
                     } else {
                         self.waiting = Some(Instant::now() + *dur);
@@ -409,20 +407,6 @@ impl AsyncWrite for Mock {
             // If a sleep is set, it has already fired
             self.inner.sleep = None;
 
-            if self.inner.actions.is_empty() {
-                match self.inner.poll_action(cx) {
-                    Poll::Pending => {
-                        // do not propagate pending
-                    }
-                    Poll::Ready(Some(action)) => {
-                        self.inner.actions.push_back(action);
-                    }
-                    Poll::Ready(None) => {
-                        panic!("unexpected write");
-                    }
-                }
-            }
-
             match self.inner.write(buf) {
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                     if let Some(rem) = self.inner.remaining_wait() {

tokio-test/src/lib.rs

@@ -12,7 +12,6 @@
 //! Tokio and Futures based testing utilities
 
 pub mod io;
-pub mod stream_mock;
 
 mod macros;
 pub mod task;

tokio-test/src/stream_mock.rs

@@ -1,168 +0,0 @@
-#![cfg(not(loom))]
-
-//! A mock stream implementing [`Stream`].
-//!
-//! # Overview
-//! This crate provides a `StreamMock` that can be used to test code that interacts with streams.
-//! It allows you to mock the behavior of a stream and control the items it yields and the waiting
-//! intervals between items.
-//!
-//! # Usage
-//! To use the `StreamMock`, you need to create a builder using[`StreamMockBuilder`]. The builder
-//! allows you to enqueue actions such as returning items or waiting for a certain duration.
-//!
-//! # Example
-//! ```rust
-//!
-//! use futures_util::StreamExt;
-//! use std::time::Duration;
-//! use tokio_test::stream_mock::StreamMockBuilder;
-//!
-//! async fn test_stream_mock_wait() {
-//!     let mut stream_mock = StreamMockBuilder::new()
-//!         .next(1)
-//!         .wait(Duration::from_millis(300))
-//!         .next(2)
-//!         .build();
-//!
-//!     assert_eq!(stream_mock.next().await, Some(1));
-//!     let start = std::time::Instant::now();
-//!     assert_eq!(stream_mock.next().await, Some(2));
-//!     let elapsed = start.elapsed();
-//!     assert!(elapsed >= Duration::from_millis(300));
-//!     assert_eq!(stream_mock.next().await, None);
-//! }
-//! ```
-
-use std::collections::VecDeque;
-use std::pin::Pin;
-use std::task::Poll;
-use std::time::Duration;
-
-use futures_core::{ready, Stream};
-use std::future::Future;
-use tokio::time::{sleep_until, Instant, Sleep};
-
-#[derive(Debug, Clone)]
-enum Action<T: Unpin> {
-    Next(T),
-    Wait(Duration),
-}
-
-/// A builder for [`StreamMock`]
-#[derive(Debug, Clone)]
-pub struct StreamMockBuilder<T: Unpin> {
-    actions: VecDeque<Action<T>>,
-}
-
-impl<T: Unpin> StreamMockBuilder<T> {
-    /// Create a new empty [`StreamMockBuilder`]
-    pub fn new() -> Self {
-        StreamMockBuilder::default()
-    }
-
-    /// Queue an item to be returned by the stream
-    pub fn next(mut self, value: T) -> Self {
-        self.actions.push_back(Action::Next(value));
-        self
-    }
-
-    // Queue an item to be consumed by the sink,
-    // commented out until Sink is implemented.
-    //
-    // pub fn consume(mut self, value: T) -> Self {
-    //    self.actions.push_back(Action::Consume(value));
-    //    self
-    // }
-
-    /// Queue the stream to wait for a duration
-    pub fn wait(mut self, duration: Duration) -> Self {
-        self.actions.push_back(Action::Wait(duration));
-        self
-    }
-
-    /// Build the [`StreamMock`]
-    pub fn build(self) -> StreamMock<T> {
-        StreamMock {
-            actions: self.actions,
-            sleep: None,
-        }
-    }
-}
-
-impl<T: Unpin> Default for StreamMockBuilder<T> {
-    fn default() -> Self {
-        StreamMockBuilder {
-            actions: VecDeque::new(),
-        }
-    }
-}
-
-/// A mock stream implementing [`Stream`]
-///
-/// See [`StreamMockBuilder`] for more information.
-#[derive(Debug)]
-pub struct StreamMock<T: Unpin> {
-    actions: VecDeque<Action<T>>,
-    sleep: Option<Pin<Box<Sleep>>>,
-}
-
-impl<T: Unpin> StreamMock<T> {
-    fn next_action(&mut self) -> Option<Action<T>> {
-        self.actions.pop_front()
-    }
-}
-
-impl<T: Unpin> Stream for StreamMock<T> {
-    type Item = T;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        // Try polling the sleep future first
-        if let Some(ref mut sleep) = self.sleep {
-            ready!(Pin::new(sleep).poll(cx));
-            // Since we're ready, discard the sleep future
-            self.sleep.take();
-        }
-
-        match self.next_action() {
-            Some(action) => match action {
-                Action::Next(item) => Poll::Ready(Some(item)),
-                Action::Wait(duration) => {
-                    // Set up a sleep future and schedule this future to be polled again for it.
-                    self.sleep = Some(Box::pin(sleep_until(Instant::now() + duration)));
-                    cx.waker().wake_by_ref();
-
-                    Poll::Pending
-                }
-            },
-            None => Poll::Ready(None),
-        }
-    }
-}
-
-impl<T: Unpin> Drop for StreamMock<T> {
-    fn drop(&mut self) {
-        // Avoid double panicking to make debugging easier.
-        if std::thread::panicking() {
-            return;
-        }
-
-        let undropped_count = self
-            .actions
-            .iter()
-            .filter(|action| match action {
-                Action::Next(_) => true,
-                Action::Wait(_) => false,
-            })
-            .count();
-
-        assert!(
-            undropped_count == 0,
-            "StreamMock was dropped before all actions were consumed, {} actions were not consumed",
-            undropped_count
-        );
-    }
-}

tokio-test/src/task.rs

@@ -1,29 +1,4 @@
-//! Futures task based helpers to easily test futures and manually written futures.
-//!
-//! The [`Spawn`] type is used as a mock task harness that allows you to poll futures
-//! without needing to setup pinning or context. Any future can be polled but if the
-//! future requires the tokio async context you will need to ensure that you poll the
-//! [`Spawn`] within a tokio context, this means that as long as you are inside the
-//! runtime it will work and you can poll it via [`Spawn`].
-//!
-//! [`Spawn`] also supports [`Stream`] to call `poll_next` without pinning
-//! or context.
-//!
-//! In addition to circumventing the need for pinning and context, [`Spawn`] also tracks
-//! the amount of times the future/task was woken. This can be useful to track if some
-//! leaf future notified the root task correctly.
-//!
-//! # Example
-//!
-//! ```
-//! use tokio_test::task;
-//!
-//! let fut = async {};
-//!
-//! let mut task = task::spawn(fut);
-//!
-//! assert!(task.poll().is_ready(), "Task was not ready!");
-//! ```
+//! Futures task based helpers
 
 #![allow(clippy::mutex_atomic)]
 
@@ -36,11 +11,7 @@ use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
 use tokio_stream::Stream;
 
-/// Spawn a future into a [`Spawn`] which wraps the future in a mocked executor.
-///
-/// This can be used to spawn a [`Future`] or a [`Stream`].
-///
-/// For more information, check the module docs.
+/// TODO: dox
 pub fn spawn<T>(task: T) -> Spawn<T> {
     Spawn {
         task: MockTask::new(),
@@ -48,14 +19,16 @@ pub fn spawn<T>(task: T) -> Spawn<T> {
     }
 }
 
-/// Future spawned on a mock task that can be used to poll the future or stream
-/// without needing pinning or context types.
+/// Future spawned on a mock task
 #[derive(Debug)]
 pub struct Spawn<T> {
     task: MockTask,
     future: Pin<Box<T>>,
 }
 
+/// Mock task
+///
+/// A mock task is able to intercept and track wake notifications.
 #[derive(Debug, Clone)]
 struct MockTask {
     waker: Arc<ThreadWaker>,
@@ -118,8 +91,7 @@ impl<T: Unpin> ops::DerefMut for Spawn<T> {
 }
 
 impl<T: Future> Spawn<T> {
-    /// If `T` is a [`Future`] then poll it. This will handle pinning and the context
-    /// type for the future.
+    /// Polls a future
     pub fn poll(&mut self) -> Poll<T::Output> {
         let fut = self.future.as_mut();
         self.task.enter(|cx| fut.poll(cx))
@@ -127,8 +99,7 @@ impl<T: Future> Spawn<T> {
 }
 
 impl<T: Stream> Spawn<T> {
-    /// If `T` is a [`Stream`] then poll_next it. This will handle pinning and the context
-    /// type for the stream.
+    /// Polls a stream
     pub fn poll_next(&mut self) -> Poll<Option<T::Item>> {
         let stream = self.future.as_mut();
         self.task.enter(|cx| stream.poll_next(cx))

tokio-test/tests/io.rs

@@ -2,7 +2,6 @@
 
 use std::io;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::time::{Duration, Instant};
 use tokio_test::io::Builder;
 
 #[tokio::test]
@@ -51,29 +50,6 @@ async fn write() {
     mock.write_all(b"world!").await.expect("write 2");
 }
 
-#[tokio::test]
-async fn write_with_handle() {
-    let (mut mock, mut handle) = Builder::new().build_with_handle();
-    handle.write(b"hello ");
-    handle.write(b"world!");
-
-    mock.write_all(b"hello ").await.expect("write 1");
-    mock.write_all(b"world!").await.expect("write 2");
-}
-
-#[tokio::test]
-async fn read_with_handle() {
-    let (mut mock, mut handle) = Builder::new().build_with_handle();
-    handle.read(b"hello ");
-    handle.read(b"world!");
-
-    let mut buf = vec![0; 6];
-    mock.read_exact(&mut buf).await.expect("read 1");
-    assert_eq!(&buf[..], b"hello ");
-    mock.read_exact(&mut buf).await.expect("read 2");
-    assert_eq!(&buf[..], b"world!");
-}
-
 #[tokio::test]
 async fn write_error() {
     let error = io::Error::new(io::ErrorKind::Other, "cruel");
@@ -108,65 +84,3 @@ async fn mock_panics_write_data_left() {
     use tokio_test::io::Builder;
     Builder::new().write(b"write").build();
 }
-
-#[tokio::test(start_paused = true)]
-async fn wait() {
-    const FIRST_WAIT: Duration = Duration::from_secs(1);
-
-    let mut mock = Builder::new()
-        .wait(FIRST_WAIT)
-        .read(b"hello ")
-        .read(b"world!")
-        .build();
-
-    let mut buf = [0; 256];
-
-    let start = Instant::now(); // record the time the read call takes
-                                //
-    let n = mock.read(&mut buf).await.expect("read 1");
-    assert_eq!(&buf[..n], b"hello ");
-    println!("time elapsed after first read {:?}", start.elapsed());
-
-    let n = mock.read(&mut buf).await.expect("read 2");
-    assert_eq!(&buf[..n], b"world!");
-    println!("time elapsed after second read {:?}", start.elapsed());
-
-    // make sure the .wait() instruction worked
-    assert!(
-        start.elapsed() >= FIRST_WAIT,
-        "consuming the whole mock only took {}ms",
-        start.elapsed().as_millis()
-    );
-}
-
-#[tokio::test(start_paused = true)]
-async fn multiple_wait() {
-    const FIRST_WAIT: Duration = Duration::from_secs(1);
-    const SECOND_WAIT: Duration = Duration::from_secs(1);
-
-    let mut mock = Builder::new()
-        .wait(FIRST_WAIT)
-        .read(b"hello ")
-        .wait(SECOND_WAIT)
-        .read(b"world!")
-        .build();
-
-    let mut buf = [0; 256];
-
-    let start = Instant::now(); // record the time it takes to consume the mock
-
-    let n = mock.read(&mut buf).await.expect("read 1");
-    assert_eq!(&buf[..n], b"hello ");
-    println!("time elapsed after first read {:?}", start.elapsed());
-
-    let n = mock.read(&mut buf).await.expect("read 2");
-    assert_eq!(&buf[..n], b"world!");
-    println!("time elapsed after second read {:?}", start.elapsed());
-
-    // make sure the .wait() instruction worked
-    assert!(
-        start.elapsed() >= FIRST_WAIT + SECOND_WAIT,
-        "consuming the whole mock only took {}ms",
-        start.elapsed().as_millis()
-    );
-}

tokio-test/tests/stream_mock.rs

@@ -1,50 +0,0 @@
-use futures_util::StreamExt;
-use std::time::Duration;
-use tokio_test::stream_mock::StreamMockBuilder;
-
-#[tokio::test]
-async fn test_stream_mock_empty() {
-    let mut stream_mock = StreamMockBuilder::<u32>::new().build();
-
-    assert_eq!(stream_mock.next().await, None);
-    assert_eq!(stream_mock.next().await, None);
-}
-
-#[tokio::test]
-async fn test_stream_mock_items() {
-    let mut stream_mock = StreamMockBuilder::new().next(1).next(2).build();
-
-    assert_eq!(stream_mock.next().await, Some(1));
-    assert_eq!(stream_mock.next().await, Some(2));
-    assert_eq!(stream_mock.next().await, None);
-}
-
-#[tokio::test]
-async fn test_stream_mock_wait() {
-    let mut stream_mock = StreamMockBuilder::new()
-        .next(1)
-        .wait(Duration::from_millis(300))
-        .next(2)
-        .build();
-
-    assert_eq!(stream_mock.next().await, Some(1));
-    let start = std::time::Instant::now();
-    assert_eq!(stream_mock.next().await, Some(2));
-    let elapsed = start.elapsed();
-    assert!(elapsed >= Duration::from_millis(300));
-    assert_eq!(stream_mock.next().await, None);
-}
-
-#[tokio::test]
-#[should_panic(expected = "StreamMock was dropped before all actions were consumed")]
-async fn test_stream_mock_drop_without_consuming_all() {
-    let stream_mock = StreamMockBuilder::new().next(1).next(2).build();
-    drop(stream_mock);
-}
-
-#[tokio::test]
-#[should_panic(expected = "test panic was not masked")]
-async fn test_stream_mock_drop_during_panic_doesnt_mask_panic() {
-    let _stream_mock = StreamMockBuilder::new().next(1).next(2).build();
-    panic!("test panic was not masked");
-}

tokio-util/CHANGELOG.md

@@ -1,129 +1,3 @@
-# 0.7.9 (September 20th, 2023)
-
-### Added
-
-- io: add passthrough `AsyncRead`/`AsyncWrite` to `InspectWriter`/`InspectReader` ([#5739])
-- task: add spawn blocking methods to `JoinMap` ([#5797])
-- io: pass through traits for `StreamReader` and `SinkWriter` ([#5941])
-- io: add `SyncIoBridge::into_inner` ([#5971])
-
-### Fixed
-
-- sync: handle possibly dangling reference safely ([#5812])
-- util: fix broken intra-doc link ([#5849])
-- compat: fix clippy warnings ([#5891])
-
-### Documented
-
-- codec: Specify the line ending of `LinesCodec` ([#5982])
-
-[#5739]: https://github.com/tokio-rs/tokio/pull/5739
-[#5797]: https://github.com/tokio-rs/tokio/pull/5797
-[#5941]: https://github.com/tokio-rs/tokio/pull/5941
-[#5971]: https://github.com/tokio-rs/tokio/pull/5971
-[#5812]: https://github.com/tokio-rs/tokio/pull/5812
-[#5849]: https://github.com/tokio-rs/tokio/pull/5849
-[#5891]: https://github.com/tokio-rs/tokio/pull/5891
-[#5982]: https://github.com/tokio-rs/tokio/pull/5982
-
-# 0.7.8 (April 25th, 2023)
-
-This release bumps the MSRV of tokio-util to 1.56.
-
-### Added
-
-- time: add `DelayQueue::peek` ([#5569])
-
-### Changed
-
-This release contains one performance improvement:
-
-- sync: try to lock the parent first in `CancellationToken` ([#5561])
-
-### Fixed
-
-- time: fix panic in `DelayQueue` ([#5630])
-
-### Documented
-
-- sync: improve `CancellationToken` doc on child tokens ([#5632])
-
-[#5561]: https://github.com/tokio-rs/tokio/pull/5561
-[#5569]: https://github.com/tokio-rs/tokio/pull/5569
-[#5630]: https://github.com/tokio-rs/tokio/pull/5630
-[#5632]: https://github.com/tokio-rs/tokio/pull/5632
-
-# 0.7.7 (February 12, 2023)
-
-This release reverts the removal of the `Encoder` bound on the `FramedParts`
-constructor from [#5280] since it turned out to be a breaking change. ([#5450])
-
-[#5450]: https://github.com/tokio-rs/tokio/pull/5450
-
-# 0.7.6 (February 10, 2023)
-
-This release fixes a compilation failure in 0.7.5 when it is used together with
-Tokio version 1.21 and unstable features are enabled. ([#5445])
-
-[#5445]: https://github.com/tokio-rs/tokio/pull/5445
-
-# 0.7.5 (February 9, 2023)
-
-This release fixes an accidental breaking change where `UnwindSafe` was
-accidentally removed from `CancellationToken`.
-
-### Added
-- codec: add `Framed::backpressure_boundary` ([#5124])
-- io: add `InspectReader` and `InspectWriter` ([#5033])
-- io: add `tokio_util::io::{CopyToBytes, SinkWriter}` ([#5070], [#5436])
-- io: impl `std::io::BufRead` on `SyncIoBridge` ([#5265])
-- sync: add `PollSemaphore::poll_acquire_many` ([#5137])
-- sync: add owned future for `CancellationToken` ([#5153])
-- time: add `DelayQueue::try_remove` ([#5052])
-
-### Fixed
-- codec: fix `LengthDelimitedCodec` buffer over-reservation ([#4997])
-- sync: impl `UnwindSafe` on `CancellationToken` ([#5438])
-- util: remove `Encoder` bound on `FramedParts` constructor ([#5280])
-
-### Documented
-- io: add lines example for `StreamReader` ([#5145])
-
-[#4997]: https://github.com/tokio-rs/tokio/pull/4997
-[#5033]: https://github.com/tokio-rs/tokio/pull/5033
-[#5052]: https://github.com/tokio-rs/tokio/pull/5052
-[#5070]: https://github.com/tokio-rs/tokio/pull/5070
-[#5124]: https://github.com/tokio-rs/tokio/pull/5124
-[#5137]: https://github.com/tokio-rs/tokio/pull/5137
-[#5145]: https://github.com/tokio-rs/tokio/pull/5145
-[#5153]: https://github.com/tokio-rs/tokio/pull/5153
-[#5265]: https://github.com/tokio-rs/tokio/pull/5265
-[#5280]: https://github.com/tokio-rs/tokio/pull/5280
-[#5436]: https://github.com/tokio-rs/tokio/pull/5436
-[#5438]: https://github.com/tokio-rs/tokio/pull/5438
-
-# 0.7.4 (September 8, 2022)
-
-### Added
-
-- io: add `SyncIoBridge::shutdown()` ([#4938])
-- task: improve `LocalPoolHandle` ([#4680])
-
-### Fixed
-
-- util: add `track_caller` to public APIs ([#4785])
-
-### Unstable
-
-- task: fix compilation errors in `JoinMap` with Tokio v1.21.0 ([#4755])
-- task: remove the unstable, deprecated `JoinMap::join_one` ([#4920])
-
-[#4680]: https://github.com/tokio-rs/tokio/pull/4680
-[#4755]: https://github.com/tokio-rs/tokio/pull/4755
-[#4785]: https://github.com/tokio-rs/tokio/pull/4785
-[#4920]: https://github.com/tokio-rs/tokio/pull/4920
-[#4938]: https://github.com/tokio-rs/tokio/pull/4938
-
 # 0.7.3 (June 4, 2022)
 
 ### Changed

tokio-util/Cargo.toml

@@ -4,9 +4,9 @@ name = "tokio-util"
 # - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-util-0.7.x" git tag.
-version = "0.7.9"
-edition = "2021"
-rust-version = "1.56"
+version = "0.7.3"
+edition = "2018"
+rust-version = "1.49"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -34,13 +34,13 @@ rt = ["tokio/rt", "tokio/sync", "futures-util", "hashbrown"]
 __docs_rs = ["futures-util"]
 
 [dependencies]
-tokio = { version = "1.28.0", path = "../tokio", features = ["sync"] }
+tokio = { version = "1.19.0", path = "../tokio", features = ["sync"] }
 bytes = "1.0.0"
 futures-core = "0.3.0"
 futures-sink = "0.3.0"
 futures-io = { version = "0.3.0", optional = true }
 futures-util = { version = "0.3.0", optional = true }
-pin-project-lite = "0.2.11"
+pin-project-lite = "0.2.0"
 slab = { version = "0.4.4", optional = true } # Backs `DelayQueue`
 tracing = { version = "0.1.25", default-features = false, features = ["std"], optional = true }
 
@@ -56,7 +56,6 @@ async-stream = "0.3.0"
 futures = "0.3.0"
 futures-test = "0.3.5"
 parking_lot = "0.12.0"
-tempfile = "3.1.0"
 
 [package.metadata.docs.rs]
 all-features = true

tokio-util/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tokio Contributors
+Copyright (c) 2022 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-util/src/codec/framed.rs

@@ -253,16 +253,6 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.state.write.buffer
     }
 
-    /// Returns backpressure boundary
-    pub fn backpressure_boundary(&self) -> usize {
-        self.inner.state.write.backpressure_boundary
-    }
-
-    /// Updates backpressure boundary
-    pub fn set_backpressure_boundary(&mut self, boundary: usize) {
-        self.inner.state.write.backpressure_boundary = boundary;
-    }
-
     /// Consumes the `Framed`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream

tokio-util/src/codec/framed_impl.rs

@@ -25,6 +25,7 @@ pin_project! {
 }
 
 const INITIAL_CAPACITY: usize = 8 * 1024;
+const BACKPRESSURE_BOUNDARY: usize = INITIAL_CAPACITY;
 
 #[derive(Debug)]
 pub(crate) struct ReadFrame {
@@ -36,7 +37,6 @@ pub(crate) struct ReadFrame {
 
 pub(crate) struct WriteFrame {
     pub(crate) buffer: BytesMut,
-    pub(crate) backpressure_boundary: usize,
 }
 
 #[derive(Default)]
@@ -60,7 +60,6 @@ impl Default for WriteFrame {
     fn default() -> Self {
         Self {
             buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
-            backpressure_boundary: INITIAL_CAPACITY,
         }
     }
 }
@@ -88,10 +87,7 @@ impl From<BytesMut> for WriteFrame {
             buffer.reserve(INITIAL_CAPACITY - size);
         }
 
-        Self {
-            buffer,
-            backpressure_boundary: INITIAL_CAPACITY,
-        }
+        Self { buffer }
     }
 }
 
@@ -260,7 +256,7 @@ where
     type Error = U::Error;
 
     fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.state.borrow().buffer.len() >= self.state.borrow().backpressure_boundary {
+        if self.state.borrow().buffer.len() >= BACKPRESSURE_BOUNDARY {
             self.as_mut().poll_flush(cx)
         } else {
             Poll::Ready(Ok(()))
@@ -281,7 +277,7 @@ where
         let mut pinned = self.project();
 
         while !pinned.state.borrow_mut().buffer.is_empty() {
-            let WriteFrame { buffer, .. } = pinned.state.borrow_mut();
+            let WriteFrame { buffer } = pinned.state.borrow_mut();
             trace!(remaining = buffer.len(), "writing;");
 
             let n = ready!(poll_write_buf(pinned.inner.as_mut(), cx, buffer))?;

tokio-util/src/codec/framed_write.rs

@@ -123,16 +123,6 @@ impl<T, E> FramedWrite<T, E> {
     pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
         &mut self.inner.state.buffer
     }
-
-    /// Returns backpressure boundary
-    pub fn backpressure_boundary(&self) -> usize {
-        self.inner.state.backpressure_boundary
-    }
-
-    /// Updates backpressure boundary
-    pub fn set_backpressure_boundary(&mut self, boundary: usize) {
-        self.inner.state.backpressure_boundary = boundary;
-    }
 }
 
 // This impl just defers to the underlying FramedImpl

tokio-util/src/codec/length_delimited.rs

@@ -522,11 +522,15 @@ impl LengthDelimitedCodec {
             }
         };
 
-        src.advance(self.builder.get_num_skip());
+        let num_skip = self.builder.get_num_skip();
+
+        if num_skip > 0 {
+            src.advance(num_skip);
+        }
 
         // Ensure that the buffer has enough space to read the incoming
         // payload
-        src.reserve(n.saturating_sub(src.len()));
+        src.reserve(n);
 
         Ok(Some(n))
     }
@@ -564,7 +568,7 @@ impl Decoder for LengthDelimitedCodec {
                 self.state = DecodeState::Head;
 
                 // Make sure the buffer has enough space to read the next head
-                src.reserve(self.builder.num_head_bytes().saturating_sub(src.len()));
+                src.reserve(self.builder.num_head_bytes());
 
                 Ok(Some(data))
             }

tokio-util/src/codec/lines_codec.rs

@@ -6,8 +6,6 @@ use std::{cmp, fmt, io, str, usize};
 
 /// A simple [`Decoder`] and [`Encoder`] implementation that splits up data into lines.
 ///
-/// This uses the `\n` character as the line ending on all platforms.
-///
 /// [`Decoder`]: crate::codec::Decoder
 /// [`Encoder`]: crate::codec::Encoder
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]

tokio-util/src/compat.rs

@@ -227,14 +227,12 @@ impl<T: tokio::io::AsyncSeek> futures_io::AsyncSeek for Compat<T> {
         pos: io::SeekFrom,
     ) -> Poll<io::Result<u64>> {
         if self.seek_pos != Some(pos) {
-            // Ensure previous seeks have finished before starting a new one
-            ready!(self.as_mut().project().inner.poll_complete(cx))?;
             self.as_mut().project().inner.start_seek(pos)?;
             *self.as_mut().project().seek_pos = Some(pos);
         }
         let res = ready!(self.as_mut().project().inner.poll_complete(cx));
         *self.as_mut().project().seek_pos = None;
-        Poll::Ready(res)
+        Poll::Ready(res.map(|p| p as u64))
     }
 }
 
@@ -257,7 +255,7 @@ impl<T: futures_io::AsyncSeek> tokio::io::AsyncSeek for Compat<T> {
         };
         let res = ready!(self.as_mut().project().inner.poll_seek(cx, pos));
         *self.as_mut().project().seek_pos = None;
-        Poll::Ready(res)
+        Poll::Ready(res.map(|p| p as u64))
     }
 }
 

tokio-util/src/io/copy_to_bytes.rs

@@ -1,76 +0,0 @@
-use bytes::Bytes;
-use futures_core::stream::Stream;
-use futures_sink::Sink;
-use pin_project_lite::pin_project;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-pin_project! {
-    /// A helper that wraps a [`Sink`]`<`[`Bytes`]`>` and converts it into a
-    /// [`Sink`]`<&'a [u8]>` by copying each byte slice into an owned [`Bytes`].
-    ///
-    /// See the documentation for [`SinkWriter`] for an example.
-    ///
-    /// [`Bytes`]: bytes::Bytes
-    /// [`SinkWriter`]: crate::io::SinkWriter
-    /// [`Sink`]: futures_sink::Sink
-    #[derive(Debug)]
-    pub struct CopyToBytes<S> {
-        #[pin]
-        inner: S,
-    }
-}
-
-impl<S> CopyToBytes<S> {
-    /// Creates a new [`CopyToBytes`].
-    pub fn new(inner: S) -> Self {
-        Self { inner }
-    }
-
-    /// Gets a reference to the underlying sink.
-    pub fn get_ref(&self) -> &S {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying sink.
-    pub fn get_mut(&mut self) -> &mut S {
-        &mut self.inner
-    }
-
-    /// Consumes this [`CopyToBytes`], returning the underlying sink.
-    pub fn into_inner(self) -> S {
-        self.inner
-    }
-}
-
-impl<'a, S> Sink<&'a [u8]> for CopyToBytes<S>
-where
-    S: Sink<Bytes>,
-{
-    type Error = S::Error;
-
-    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_ready(cx)
-    }
-
-    fn start_send(self: Pin<&mut Self>, item: &'a [u8]) -> Result<(), Self::Error> {
-        self.project()
-            .inner
-            .start_send(Bytes::copy_from_slice(item))
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_flush(cx)
-    }
-
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_close(cx)
-    }
-}
-
-impl<S: Stream> Stream for CopyToBytes<S> {
-    type Item = S::Item;
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.project().inner.poll_next(cx)
-    }
-}

tokio-util/src/io/inspect.rs

@@ -1,180 +0,0 @@
-use futures_core::ready;
-use pin_project_lite::pin_project;
-use std::io::{IoSlice, Result};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-
-pin_project! {
-    /// An adapter that lets you inspect the data that's being read.
-    ///
-    /// This is useful for things like hashing data as it's read in.
-    pub struct InspectReader<R, F> {
-        #[pin]
-        reader: R,
-        f: F,
-    }
-}
-
-impl<R, F> InspectReader<R, F> {
-    /// Create a new InspectReader, wrapping `reader` and calling `f` for the
-    /// new data supplied by each read call.
-    ///
-    /// The closure will only be called with an empty slice if the inner reader
-    /// returns without reading data into the buffer. This happens at EOF, or if
-    /// `poll_read` is called with a zero-size buffer.
-    pub fn new(reader: R, f: F) -> InspectReader<R, F>
-    where
-        R: AsyncRead,
-        F: FnMut(&[u8]),
-    {
-        InspectReader { reader, f }
-    }
-
-    /// Consumes the `InspectReader`, returning the wrapped reader
-    pub fn into_inner(self) -> R {
-        self.reader
-    }
-}
-
-impl<R: AsyncRead, F: FnMut(&[u8])> AsyncRead for InspectReader<R, F> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<Result<()>> {
-        let me = self.project();
-        let filled_length = buf.filled().len();
-        ready!(me.reader.poll_read(cx, buf))?;
-        (me.f)(&buf.filled()[filled_length..]);
-        Poll::Ready(Ok(()))
-    }
-}
-
-impl<R: AsyncWrite, F> AsyncWrite for InspectReader<R, F> {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<std::result::Result<usize, std::io::Error>> {
-        self.project().reader.poll_write(cx, buf)
-    }
-
-    fn poll_flush(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<std::result::Result<(), std::io::Error>> {
-        self.project().reader.poll_flush(cx)
-    }
-
-    fn poll_shutdown(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<std::result::Result<(), std::io::Error>> {
-        self.project().reader.poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize>> {
-        self.project().reader.poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.reader.is_write_vectored()
-    }
-}
-
-pin_project! {
-    /// An adapter that lets you inspect the data that's being written.
-    ///
-    /// This is useful for things like hashing data as it's written out.
-    pub struct InspectWriter<W, F> {
-        #[pin]
-        writer: W,
-        f: F,
-    }
-}
-
-impl<W, F> InspectWriter<W, F> {
-    /// Create a new InspectWriter, wrapping `write` and calling `f` for the
-    /// data successfully written by each write call.
-    ///
-    /// The closure `f` will never be called with an empty slice. A vectored
-    /// write can result in multiple calls to `f` - at most one call to `f` per
-    /// buffer supplied to `poll_write_vectored`.
-    pub fn new(writer: W, f: F) -> InspectWriter<W, F>
-    where
-        W: AsyncWrite,
-        F: FnMut(&[u8]),
-    {
-        InspectWriter { writer, f }
-    }
-
-    /// Consumes the `InspectWriter`, returning the wrapped writer
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<W: AsyncWrite, F: FnMut(&[u8])> AsyncWrite for InspectWriter<W, F> {
-    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> {
-        let me = self.project();
-        let res = me.writer.poll_write(cx, buf);
-        if let Poll::Ready(Ok(count)) = res {
-            if count != 0 {
-                (me.f)(&buf[..count]);
-            }
-        }
-        res
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-        let me = self.project();
-        me.writer.poll_flush(cx)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-        let me = self.project();
-        me.writer.poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize>> {
-        let me = self.project();
-        let res = me.writer.poll_write_vectored(cx, bufs);
-        if let Poll::Ready(Ok(mut count)) = res {
-            for buf in bufs {
-                if count == 0 {
-                    break;
-                }
-                let size = count.min(buf.len());
-                if size != 0 {
-                    (me.f)(&buf[..size]);
-                    count -= size;
-                }
-            }
-        }
-        res
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.writer.is_write_vectored()
-    }
-}
-
-impl<W: AsyncRead, F> AsyncRead for InspectWriter<W, F> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        self.project().writer.poll_read(cx, buf)
-    }
-}

tokio-util/src/io/mod.rs

@@ -10,22 +10,15 @@
 //! [`Body`]: https://docs.rs/hyper/0.13/hyper/struct.Body.html
 //! [`AsyncRead`]: tokio::io::AsyncRead
 
-mod copy_to_bytes;
-mod inspect;
 mod read_buf;
 mod reader_stream;
-mod sink_writer;
 mod stream_reader;
-
 cfg_io_util! {
     mod sync_bridge;
     pub use self::sync_bridge::SyncIoBridge;
 }
 
-pub use self::copy_to_bytes::CopyToBytes;
-pub use self::inspect::{InspectReader, InspectWriter};
 pub use self::read_buf::read_buf;
 pub use self::reader_stream::ReaderStream;
-pub use self::sink_writer::SinkWriter;
 pub use self::stream_reader::StreamReader;
 pub use crate::util::{poll_read_buf, poll_write_buf};

tokio-util/src/io/sink_writer.rs

@@ -1,135 +0,0 @@
-use futures_core::ready;
-use futures_sink::Sink;
-
-use futures_core::stream::Stream;
-use pin_project_lite::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::{AsyncRead, AsyncWrite};
-
-pin_project! {
-    /// Convert a [`Sink`] of byte chunks into an [`AsyncWrite`].
-    ///
-    /// Whenever you write to this [`SinkWriter`], the supplied bytes are
-    /// forwarded to the inner [`Sink`]. When `shutdown` is called on this
-    /// [`SinkWriter`], the inner sink is closed.
-    ///
-    /// This adapter takes a `Sink<&[u8]>` and provides an [`AsyncWrite`] impl
-    /// for it. Because of the lifetime, this trait is relatively rarely
-    /// implemented. The main ways to get a `Sink<&[u8]>` that you can use with
-    /// this type are:
-    ///
-    ///  * With the codec module by implementing the [`Encoder`]`<&[u8]>` trait.
-    ///  * By wrapping a `Sink<Bytes>` in a [`CopyToBytes`].
-    ///  * Manually implementing `Sink<&[u8]>` directly.
-    ///
-    /// The opposite conversion of implementing `Sink<_>` for an [`AsyncWrite`]
-    /// is done using the [`codec`] module.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    /// use futures_util::SinkExt;
-    /// use std::io::{Error, ErrorKind};
-    /// use tokio::io::AsyncWriteExt;
-    /// use tokio_util::io::{SinkWriter, CopyToBytes};
-    /// use tokio_util::sync::PollSender;
-    ///
-    /// # #[tokio::main(flavor = "current_thread")]
-    /// # async fn main() -> Result<(), Error> {
-    /// // We use an mpsc channel as an example of a `Sink<Bytes>`.
-    /// let (tx, mut rx) = tokio::sync::mpsc::channel::<Bytes>(1);
-    /// let sink = PollSender::new(tx).sink_map_err(|_| Error::from(ErrorKind::BrokenPipe));
-    ///
-    /// // Wrap it in `CopyToBytes` to get a `Sink<&[u8]>`.
-    /// let mut writer = SinkWriter::new(CopyToBytes::new(sink));
-    ///
-    /// // Write data to our interface...
-    /// let data: [u8; 4] = [1, 2, 3, 4];
-    /// let _ = writer.write(&data).await?;
-    ///
-    /// // ... and receive it.
-    /// assert_eq!(data.as_slice(), &*rx.recv().await.unwrap());
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`AsyncWrite`]: tokio::io::AsyncWrite
-    /// [`CopyToBytes`]: crate::io::CopyToBytes
-    /// [`Encoder`]: crate::codec::Encoder
-    /// [`Sink`]: futures_sink::Sink
-    /// [`codec`]: crate::codec
-    #[derive(Debug)]
-    pub struct SinkWriter<S> {
-        #[pin]
-        inner: S,
-    }
-}
-
-impl<S> SinkWriter<S> {
-    /// Creates a new [`SinkWriter`].
-    pub fn new(sink: S) -> Self {
-        Self { inner: sink }
-    }
-
-    /// Gets a reference to the underlying sink.
-    pub fn get_ref(&self) -> &S {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying sink.
-    pub fn get_mut(&mut self) -> &mut S {
-        &mut self.inner
-    }
-
-    /// Consumes this [`SinkWriter`], returning the underlying sink.
-    pub fn into_inner(self) -> S {
-        self.inner
-    }
-}
-impl<S, E> AsyncWrite for SinkWriter<S>
-where
-    for<'a> S: Sink<&'a [u8], Error = E>,
-    E: Into<io::Error>,
-{
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<Result<usize, io::Error>> {
-        let mut this = self.project();
-
-        ready!(this.inner.as_mut().poll_ready(cx).map_err(Into::into))?;
-        match this.inner.as_mut().start_send(buf) {
-            Ok(()) => Poll::Ready(Ok(buf.len())),
-            Err(e) => Poll::Ready(Err(e.into())),
-        }
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        self.project().inner.poll_flush(cx).map_err(Into::into)
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        self.project().inner.poll_close(cx).map_err(Into::into)
-    }
-}
-
-impl<S: Stream> Stream for SinkWriter<S> {
-    type Item = S::Item;
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.project().inner.poll_next(cx)
-    }
-}
-
-impl<S: AsyncRead> AsyncRead for SinkWriter<S> {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        self.project().inner.poll_read(cx, buf)
-    }
-}

tokio-util/src/io/stream_reader.rs

@@ -1,163 +1,64 @@
 use bytes::Buf;
 use futures_core::stream::Stream;
-use futures_sink::Sink;
+use pin_project_lite::pin_project;
 use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncBufRead, AsyncRead, ReadBuf};
 
-/// Convert a [`Stream`] of byte chunks into an [`AsyncRead`].
-///
-/// This type performs the inverse operation of [`ReaderStream`].
-///
-/// This type also implements the [`AsyncBufRead`] trait, so you can use it
-/// to read a `Stream` of byte chunks line-by-line. See the examples below.
-///
-/// # Example
-///
-/// ```
-/// use bytes::Bytes;
-/// use tokio::io::{AsyncReadExt, Result};
-/// use tokio_util::io::StreamReader;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream from an iterator.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
-///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
-///     Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),
-/// ]);
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Read five bytes from the stream.
-/// let mut buf = [0; 5];
-/// read.read_exact(&mut buf).await?;
-/// assert_eq!(buf, [0, 1, 2, 3, 4]);
-///
-/// // Read the rest of the current chunk.
-/// assert_eq!(read.read(&mut buf).await?, 3);
-/// assert_eq!(&buf[..3], [5, 6, 7]);
-///
-/// // Read the next chunk.
-/// assert_eq!(read.read(&mut buf).await?, 4);
-/// assert_eq!(&buf[..4], [8, 9, 10, 11]);
-///
-/// // We have now reached the end.
-/// assert_eq!(read.read(&mut buf).await?, 0);
-///
-/// # Ok(())
-/// # }
-/// ```
-///
-/// If the stream produces errors which are not [`std::io::Error`],
-/// the errors can be converted using [`StreamExt`] to map each
-/// element.
-///
-/// ```
-/// use bytes::Bytes;
-/// use tokio::io::AsyncReadExt;
-/// use tokio_util::io::StreamReader;
-/// use tokio_stream::StreamExt;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream from an iterator, including an error.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
-///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
-///     Result::Err("Something bad happened!")
-/// ]);
-///
-/// // Use StreamExt to map the stream and error to a std::io::Error
-/// let stream = stream.map(|result| result.map_err(|err| {
-///     std::io::Error::new(std::io::ErrorKind::Other, err)
-/// }));
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Read five bytes from the stream.
-/// let mut buf = [0; 5];
-/// read.read_exact(&mut buf).await?;
-/// assert_eq!(buf, [0, 1, 2, 3, 4]);
-///
-/// // Read the rest of the current chunk.
-/// assert_eq!(read.read(&mut buf).await?, 3);
-/// assert_eq!(&buf[..3], [5, 6, 7]);
-///
-/// // Reading the next chunk will produce an error
-/// let error = read.read(&mut buf).await.unwrap_err();
-/// assert_eq!(error.kind(), std::io::ErrorKind::Other);
-/// assert_eq!(error.into_inner().unwrap().to_string(), "Something bad happened!");
-///
-/// // We have now reached the end.
-/// assert_eq!(read.read(&mut buf).await?, 0);
-///
-/// # Ok(())
-/// # }
-/// ```
-///
-/// Using the [`AsyncBufRead`] impl, you can read a `Stream` of byte chunks
-/// line-by-line. Note that you will usually also need to convert the error
-/// type when doing this. See the second example for an explanation of how
-/// to do this.
-///
-/// ```
-/// use tokio::io::{Result, AsyncBufReadExt};
-/// use tokio_util::io::StreamReader;
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> std::io::Result<()> {
-///
-/// // Create a stream of byte chunks.
-/// let stream = tokio_stream::iter(vec![
-///     Result::Ok(b"The first line.\n".as_slice()),
-///     Result::Ok(b"The second line.".as_slice()),
-///     Result::Ok(b"\nThe third".as_slice()),
-///     Result::Ok(b" line.\nThe fourth line.\nThe fifth line.\n".as_slice()),
-/// ]);
-///
-/// // Convert it to an AsyncRead.
-/// let mut read = StreamReader::new(stream);
-///
-/// // Loop through the lines from the `StreamReader`.
-/// let mut line = String::new();
-/// let mut lines = Vec::new();
-/// loop {
-///     line.clear();
-///     let len = read.read_line(&mut line).await?;
-///     if len == 0 { break; }
-///     lines.push(line.clone());
-/// }
-///
-/// // Verify that we got the lines we expected.
-/// assert_eq!(
-///     lines,
-///     vec![
-///         "The first line.\n",
-///         "The second line.\n",
-///         "The third line.\n",
-///         "The fourth line.\n",
-///         "The fifth line.\n",
-///     ]
-/// );
-/// # Ok(())
-/// # }
-/// ```
-///
-/// [`AsyncRead`]: tokio::io::AsyncRead
-/// [`AsyncBufRead`]: tokio::io::AsyncBufRead
-/// [`Stream`]: futures_core::Stream
-/// [`ReaderStream`]: crate::io::ReaderStream
-/// [`StreamExt`]: https://docs.rs/tokio-stream/latest/tokio_stream/trait.StreamExt.html
-#[derive(Debug)]
-pub struct StreamReader<S, B> {
-    // This field is pinned.
-    inner: S,
-    // This field is not pinned.
-    chunk: Option<B>,
+pin_project! {
+    /// Convert a [`Stream`] of byte chunks into an [`AsyncRead`].
+    ///
+    /// This type performs the inverse operation of [`ReaderStream`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    /// use tokio::io::{AsyncReadExt, Result};
+    /// use tokio_util::io::StreamReader;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    ///
+    /// // Create a stream from an iterator.
+    /// let stream = tokio_stream::iter(vec![
+    ///     Result::Ok(Bytes::from_static(&[0, 1, 2, 3])),
+    ///     Result::Ok(Bytes::from_static(&[4, 5, 6, 7])),
+    ///     Result::Ok(Bytes::from_static(&[8, 9, 10, 11])),
+    /// ]);
+    ///
+    /// // Convert it to an AsyncRead.
+    /// let mut read = StreamReader::new(stream);
+    ///
+    /// // Read five bytes from the stream.
+    /// let mut buf = [0; 5];
+    /// read.read_exact(&mut buf).await?;
+    /// assert_eq!(buf, [0, 1, 2, 3, 4]);
+    ///
+    /// // Read the rest of the current chunk.
+    /// assert_eq!(read.read(&mut buf).await?, 3);
+    /// assert_eq!(&buf[..3], [5, 6, 7]);
+    ///
+    /// // Read the next chunk.
+    /// assert_eq!(read.read(&mut buf).await?, 4);
+    /// assert_eq!(&buf[..4], [8, 9, 10, 11]);
+    ///
+    /// // We have now reached the end.
+    /// assert_eq!(read.read(&mut buf).await?, 0);
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`AsyncRead`]: tokio::io::AsyncRead
+    /// [`Stream`]: futures_core::Stream
+    /// [`ReaderStream`]: crate::io::ReaderStream
+    #[derive(Debug)]
+    pub struct StreamReader<S, B> {
+        #[pin]
+        inner: S,
+        chunk: Option<B>,
+    }
 }
 
 impl<S, B, E> StreamReader<S, B>
@@ -300,47 +201,3 @@ where
         }
     }
 }
-
-// The code below is a manual expansion of the code that pin-project-lite would
-// generate. This is done because pin-project-lite fails by hitting the recusion
-// limit on this struct. (Every line of documentation is handled recursively by
-// the macro.)
-
-impl<S: Unpin, B> Unpin for StreamReader<S, B> {}
-
-struct StreamReaderProject<'a, S, B> {
-    inner: Pin<&'a mut S>,
-    chunk: &'a mut Option<B>,
-}
-
-impl<S, B> StreamReader<S, B> {
-    #[inline]
-    fn project(self: Pin<&mut Self>) -> StreamReaderProject<'_, S, B> {
-        // SAFETY: We define that only `inner` should be pinned when `Self` is
-        // and have an appropriate `impl Unpin` for this.
-        let me = unsafe { Pin::into_inner_unchecked(self) };
-        StreamReaderProject {
-            inner: unsafe { Pin::new_unchecked(&mut me.inner) },
-            chunk: &mut me.chunk,
-        }
-    }
-}
-
-impl<S: Sink<T, Error = E>, E, T> Sink<T> for StreamReader<S, E> {
-    type Error = E;
-    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_ready(cx)
-    }
-
-    fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
-        self.project().inner.start_send(item)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_flush(cx)
-    }
-
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().inner.poll_close(cx)
-    }
-}

tokio-util/src/io/sync_bridge.rs

@@ -1,7 +1,5 @@
-use std::io::{BufRead, Read, Write};
-use tokio::io::{
-    AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt,
-};
+use std::io::{Read, Write};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
 /// Use a [`tokio::io::AsyncRead`] synchronously as a [`std::io::Read`] or
 /// a [`tokio::io::AsyncWrite`] as a [`std::io::Write`].
@@ -11,28 +9,6 @@ pub struct SyncIoBridge<T> {
     rt: tokio::runtime::Handle,
 }
 
-impl<T: AsyncBufRead + Unpin> BufRead for SyncIoBridge<T> {
-    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
-        let src = &mut self.src;
-        self.rt.block_on(AsyncBufReadExt::fill_buf(src))
-    }
-
-    fn consume(&mut self, amt: usize) {
-        let src = &mut self.src;
-        AsyncBufReadExt::consume(src, amt)
-    }
-
-    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> std::io::Result<usize> {
-        let src = &mut self.src;
-        self.rt
-            .block_on(AsyncBufReadExt::read_until(src, byte, buf))
-    }
-    fn read_line(&mut self, buf: &mut String) -> std::io::Result<usize> {
-        let src = &mut self.src;
-        self.rt.block_on(AsyncBufReadExt::read_line(src, buf))
-    }
-}
-
 impl<T: AsyncRead + Unpin> Read for SyncIoBridge<T> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let src = &mut self.src;
@@ -140,9 +116,4 @@ impl<T: Unpin> SyncIoBridge<T> {
     pub fn new_with_handle(src: T, rt: tokio::runtime::Handle) -> Self {
         Self { src, rt }
     }
-
-    /// Consume this bridge, returning the underlying stream.
-    pub fn into_inner(self) -> T {
-        self.src
-    }
 }

tokio-util/src/lib.rs

@@ -55,6 +55,151 @@ pub mod sync;
 
 pub mod either;
 
-pub use bytes;
+#[cfg(any(feature = "io", feature = "codec"))]
+mod util {
+    use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
-mod util;
+    use bytes::{Buf, BufMut};
+    use futures_core::ready;
+    use std::io::{self, IoSlice};
+    use std::mem::MaybeUninit;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+
+    /// Try to read data from an `AsyncRead` into an implementer of the [`BufMut`] trait.
+    ///
+    /// [`BufMut`]: bytes::Buf
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bytes::{Bytes, BytesMut};
+    /// use tokio_stream as stream;
+    /// use tokio::io::Result;
+    /// use tokio_util::io::{StreamReader, poll_read_buf};
+    /// use futures::future::poll_fn;
+    /// use std::pin::Pin;
+    /// # #[tokio::main]
+    /// # async fn main() -> std::io::Result<()> {
+    ///
+    /// // Create a reader from an iterator. This particular reader will always be
+    /// // ready.
+    /// let mut read = StreamReader::new(stream::iter(vec![Result::Ok(Bytes::from_static(&[0, 1, 2, 3]))]));
+    ///
+    /// let mut buf = BytesMut::new();
+    /// let mut reads = 0;
+    ///
+    /// loop {
+    ///     reads += 1;
+    ///     let n = poll_fn(|cx| poll_read_buf(Pin::new(&mut read), cx, &mut buf)).await?;
+    ///
+    ///     if n == 0 {
+    ///         break;
+    ///     }
+    /// }
+    ///
+    /// // one or more reads might be necessary.
+    /// assert!(reads >= 1);
+    /// assert_eq!(&buf[..], &[0, 1, 2, 3]);
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg_attr(not(feature = "io"), allow(unreachable_pub))]
+    pub fn poll_read_buf<T: AsyncRead, B: BufMut>(
+        io: Pin<&mut T>,
+        cx: &mut Context<'_>,
+        buf: &mut B,
+    ) -> Poll<io::Result<usize>> {
+        if !buf.has_remaining_mut() {
+            return Poll::Ready(Ok(0));
+        }
+
+        let n = {
+            let dst = buf.chunk_mut();
+
+            // Safety: `chunk_mut()` returns a `&mut UninitSlice`, and `UninitSlice` is a
+            // transparent wrapper around `[MaybeUninit<u8>]`.
+            let dst = unsafe { &mut *(dst as *mut _ as *mut [MaybeUninit<u8>]) };
+            let mut buf = ReadBuf::uninit(dst);
+            let ptr = buf.filled().as_ptr();
+            ready!(io.poll_read(cx, &mut buf)?);
+
+            // Ensure the pointer does not change from under us
+            assert_eq!(ptr, buf.filled().as_ptr());
+            buf.filled().len()
+        };
+
+        // Safety: This is guaranteed to be the number of initialized (and read)
+        // bytes due to the invariants provided by `ReadBuf::filled`.
+        unsafe {
+            buf.advance_mut(n);
+        }
+
+        Poll::Ready(Ok(n))
+    }
+
+    /// Try to write data from an implementer of the [`Buf`] trait to an
+    /// [`AsyncWrite`], advancing the buffer's internal cursor.
+    ///
+    /// This function will use [vectored writes] when the [`AsyncWrite`] supports
+    /// vectored writes.
+    ///
+    /// # Examples
+    ///
+    /// [`File`] implements [`AsyncWrite`] and [`Cursor<&[u8]>`] implements
+    /// [`Buf`]:
+    ///
+    /// ```no_run
+    /// use tokio_util::io::poll_write_buf;
+    /// use tokio::io;
+    /// use tokio::fs::File;
+    ///
+    /// use bytes::Buf;
+    /// use std::io::Cursor;
+    /// use std::pin::Pin;
+    /// use futures::future::poll_fn;
+    ///
+    /// #[tokio::main]
+    /// async fn main() -> io::Result<()> {
+    ///     let mut file = File::create("foo.txt").await?;
+    ///     let mut buf = Cursor::new(b"data to write");
+    ///
+    ///     // Loop until the entire contents of the buffer are written to
+    ///     // the file.
+    ///     while buf.has_remaining() {
+    ///         poll_fn(|cx| poll_write_buf(Pin::new(&mut file), cx, &mut buf)).await?;
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`Buf`]: bytes::Buf
+    /// [`AsyncWrite`]: tokio::io::AsyncWrite
+    /// [`File`]: tokio::fs::File
+    /// [vectored writes]: tokio::io::AsyncWrite::poll_write_vectored
+    #[cfg_attr(not(feature = "io"), allow(unreachable_pub))]
+    pub fn poll_write_buf<T: AsyncWrite, B: Buf>(
+        io: Pin<&mut T>,
+        cx: &mut Context<'_>,
+        buf: &mut B,
+    ) -> Poll<io::Result<usize>> {
+        const MAX_BUFS: usize = 64;
+
+        if !buf.has_remaining() {
+            return Poll::Ready(Ok(0));
+        }
+
+        let n = if io.is_write_vectored() {
+            let mut slices = [IoSlice::new(&[]); MAX_BUFS];
+            let cnt = buf.chunks_vectored(&mut slices);
+            ready!(io.poll_write_vectored(cx, &slices[..cnt]))?
+        } else {
+            ready!(io.poll_write(cx, buf.chunk()))?
+        };
+
+        buf.advance(n);
+
+        Poll::Ready(Ok(n))
+    }
+}

tokio-util/src/sync/cancellation_token.rs

@@ -4,7 +4,6 @@ pub(crate) mod guard;
 mod tree_node;
 
 use crate::loom::sync::Arc;
-use crate::util::MaybeDangling;
 use core::future::Future;
 use core::pin::Pin;
 use core::task::{Context, Poll};
@@ -56,9 +55,6 @@ pub struct CancellationToken {
     inner: Arc<tree_node::TreeNode>,
 }
 
-impl std::panic::UnwindSafe for CancellationToken {}
-impl std::panic::RefUnwindSafe for CancellationToken {}
-
 pin_project! {
     /// A Future that is resolved once the corresponding [`CancellationToken`]
     /// is cancelled.
@@ -70,35 +66,6 @@ pin_project! {
     }
 }
 
-pin_project! {
-    /// A Future that is resolved once the corresponding [`CancellationToken`]
-    /// is cancelled.
-    ///
-    /// This is the counterpart to [`WaitForCancellationFuture`] that takes
-    /// [`CancellationToken`] by value instead of using a reference.
-    #[must_use = "futures do nothing unless polled"]
-    pub struct WaitForCancellationFutureOwned {
-        // This field internally has a reference to the cancellation token, but camouflages
-        // the relationship with `'static`. To avoid Undefined Behavior, we must ensure
-        // that the reference is only used while the cancellation token is still alive. To
-        // do that, we ensure that the future is the first field, so that it is dropped
-        // before the cancellation token.
-        //
-        // We use `MaybeDanglingFuture` here because without it, the compiler could assert
-        // the reference inside `future` to be valid even after the destructor of that
-        // field runs. (Specifically, when the `WaitForCancellationFutureOwned` is passed
-        // as an argument to a function, the reference can be asserted to be valid for the
-        // rest of that function.) To avoid that, we use `MaybeDangling` which tells the
-        // compiler that the reference stored inside it might not be valid.
-        //
-        // See <https://users.rust-lang.org/t/unsafe-code-review-semi-owning-weak-rwlock-t-guard/95706>
-        // for more info.
-        #[pin]
-        future: MaybeDangling<tokio::sync::futures::Notified<'static>>,
-        cancellation_token: CancellationToken,
-    }
-}
-
 // ===== impl CancellationToken =====
 
 impl core::fmt::Debug for CancellationToken {
@@ -110,8 +77,6 @@ impl core::fmt::Debug for CancellationToken {
 }
 
 impl Clone for CancellationToken {
-    /// Creates a clone of the `CancellationToken` which will get cancelled
-    /// whenever the current token gets cancelled, and vice versa.
     fn clone(&self) -> Self {
         tree_node::increase_handle_refcount(&self.inner);
         CancellationToken {
@@ -141,8 +106,7 @@ impl CancellationToken {
     }
 
     /// Creates a `CancellationToken` which will get cancelled whenever the
-    /// current token gets cancelled. Unlike a cloned `CancellationToken`,
-    /// cancelling a child token does not cancel the parent token.
+    /// current token gets cancelled.
     ///
     /// If the current token is already cancelled, the child token will get
     /// returned in cancelled state.
@@ -219,21 +183,6 @@ impl CancellationToken {
         }
     }
 
-    /// Returns a `Future` that gets fulfilled when cancellation is requested.
-    ///
-    /// The future will complete immediately if the token is already cancelled
-    /// when this method is called.
-    ///
-    /// The function takes self by value and returns a future that owns the
-    /// token.
-    ///
-    /// # Cancel safety
-    ///
-    /// This method is cancel safe.
-    pub fn cancelled_owned(self) -> WaitForCancellationFutureOwned {
-        WaitForCancellationFutureOwned::new(self)
-    }
-
     /// Creates a `DropGuard` for this token.
     ///
     /// Returned guard will cancel this token (and all its children) on drop
@@ -273,69 +222,3 @@ impl<'a> Future for WaitForCancellationFuture<'a> {
         }
     }
 }
-
-// ===== impl WaitForCancellationFutureOwned =====
-
-impl core::fmt::Debug for WaitForCancellationFutureOwned {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("WaitForCancellationFutureOwned").finish()
-    }
-}
-
-impl WaitForCancellationFutureOwned {
-    fn new(cancellation_token: CancellationToken) -> Self {
-        WaitForCancellationFutureOwned {
-            // cancellation_token holds a heap allocation and is guaranteed to have a
-            // stable deref, thus it would be ok to move the cancellation_token while
-            // the future holds a reference to it.
-            //
-            // # Safety
-            //
-            // cancellation_token is dropped after future due to the field ordering.
-            future: MaybeDangling::new(unsafe { Self::new_future(&cancellation_token) }),
-            cancellation_token,
-        }
-    }
-
-    /// # Safety
-    /// The returned future must be destroyed before the cancellation token is
-    /// destroyed.
-    unsafe fn new_future(
-        cancellation_token: &CancellationToken,
-    ) -> tokio::sync::futures::Notified<'static> {
-        let inner_ptr = Arc::as_ptr(&cancellation_token.inner);
-        // SAFETY: The `Arc::as_ptr` method guarantees that `inner_ptr` remains
-        // valid until the strong count of the Arc drops to zero, and the caller
-        // guarantees that they will drop the future before that happens.
-        (*inner_ptr).notified()
-    }
-}
-
-impl Future for WaitForCancellationFutureOwned {
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        let mut this = self.project();
-
-        loop {
-            if this.cancellation_token.is_cancelled() {
-                return Poll::Ready(());
-            }
-
-            // No wakeups can be lost here because there is always a call to
-            // `is_cancelled` between the creation of the future and the call to
-            // `poll`, and the code that sets the cancelled flag does so before
-            // waking the `Notified`.
-            if this.future.as_mut().poll(cx).is_pending() {
-                return Poll::Pending;
-            }
-
-            // # Safety
-            //
-            // cancellation_token is dropped after future due to the field ordering.
-            this.future.set(MaybeDangling::new(unsafe {
-                Self::new_future(this.cancellation_token)
-            }));
-        }
-    }
-}

tokio-util/src/sync/cancellation_token/tree_node.rs

@@ -151,43 +151,47 @@ fn with_locked_node_and_parent<F, Ret>(node: &Arc<TreeNode>, func: F) -> Ret
 where
     F: FnOnce(MutexGuard<'_, Inner>, Option<MutexGuard<'_, Inner>>) -> Ret,
 {
-    use std::sync::TryLockError;
-
-    let mut locked_node = node.inner.lock().unwrap();
-
-    // Every time this fails, the number of ancestors of the node decreases,
-    // so the loop must succeed after a finite number of iterations.
-    loop {
-        // Look up the parent of the currently locked node.
-        let potential_parent = match locked_node.parent.as_ref() {
-            Some(potential_parent) => potential_parent.clone(),
+    let mut potential_parent = {
+        let locked_node = node.inner.lock().unwrap();
+        match locked_node.parent.clone() {
+            Some(parent) => parent,
+            // If we locked the node and its parent is `None`, we are in a valid state
+            // and can return.
             None => return func(locked_node, None),
-        };
-
-        // Lock the parent. This may require unlocking the child first.
-        let locked_parent = match potential_parent.inner.try_lock() {
-            Ok(locked_parent) => locked_parent,
-            Err(TryLockError::WouldBlock) => {
-                drop(locked_node);
-                // Deadlock safety:
-                //
-                // Due to invariant #2, the potential parent must come before
-                // the child in the creation order. Therefore, we can safely
-                // lock the child while holding the parent lock.
-                let locked_parent = potential_parent.inner.lock().unwrap();
-                locked_node = node.inner.lock().unwrap();
-                locked_parent
-            }
-            Err(TryLockError::Poisoned(err)) => Err(err).unwrap(),
-        };
-
-        // If we unlocked the child, then the parent may have changed. Check
-        // that we still have the right parent.
-        if let Some(actual_parent) = locked_node.parent.as_ref() {
-            if Arc::ptr_eq(actual_parent, &potential_parent) {
-                return func(locked_node, Some(locked_parent));
-            }
         }
+    };
+
+    loop {
+        // Deadlock safety:
+        //
+        // Due to invariant #2, we know that we have to lock the parent first, and then the child.
+        // This is true even if the potential_parent is no longer the current parent or even its
+        // sibling, as the invariant still holds.
+        let locked_parent = potential_parent.inner.lock().unwrap();
+        let locked_node = node.inner.lock().unwrap();
+
+        let actual_parent = match locked_node.parent.clone() {
+            Some(parent) => parent,
+            // If we locked the node and its parent is `None`, we are in a valid state
+            // and can return.
+            None => {
+                // Was the wrong parent, so unlock it before calling `func`
+                drop(locked_parent);
+                return func(locked_node, None);
+            }
+        };
+
+        // Loop until we managed to lock both the node and its parent
+        if Arc::ptr_eq(&actual_parent, &potential_parent) {
+            return func(locked_node, Some(locked_parent));
+        }
+
+        // Drop locked_parent before reassigning to potential_parent,
+        // as potential_parent is borrowed in it
+        drop(locked_node);
+        drop(locked_parent);
+
+        potential_parent = actual_parent;
     }
 }
 
@@ -239,7 +243,11 @@ fn remove_child(parent: &mut Inner, mut node: MutexGuard<'_, Inner>) {
 
     let len = parent.children.len();
     if 4 * len <= parent.children.capacity() {
-        parent.children.shrink_to(2 * len);
+        // equal to:
+        //    parent.children.shrink_to(2 * len);
+        // but shrink_to was not yet stabilized in our minimal compatible version
+        let old_children = std::mem::replace(&mut parent.children, Vec::with_capacity(2 * len));
+        parent.children.extend(old_children);
     }
 }