rt(threaded): basic self-tuning of injection queue

Proof of concept showing how we could implement some basic self-tuning
to check the interval queue (and other maintenance tasks potentially) at
variable interval rates.

.cargo/audit.toml

@@ -0,0 +1,8 @@
+# See https://github.com/rustsec/rustsec/blob/59e1d2ad0b9cbc6892c26de233d4925074b4b97b/cargo-audit/audit.toml.example for example.
+
+[advisories]
+ignore = [
+    # We depend on nix 0.22 only via mio-aio, a dev-dependency.
+    # https://github.com/tokio-rs/tokio/pull/4255#issuecomment-974786349
+    "RUSTSEC-2021-0119",
+]

.circleci/config.yml

@@ -0,0 +1,25 @@
+version: 2.1        
+jobs:
+  test-arm:
+    machine:
+      image: ubuntu-2004:202101-01
+    resource_class: arm.medium
+    environment:
+      # Change to pin rust version
+      RUST_STABLE: stable
+    steps:
+      - checkout
+      - run:
+          name: Install Rust
+          command: |
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o rustup.sh
+            chmod +x rustup.sh
+            ./rustup.sh -y --default-toolchain $RUST_STABLE
+            source "$HOME"/.cargo/env
+      # Only run Tokio tests
+      - run: cargo test --all-features -p tokio
+
+workflows:
+  ci:
+    jobs:
+      - test-arm

.cirrus.yml

@@ -0,0 +1,58 @@
+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
+env:
+  RUST_STABLE: stable
+  RUST_NIGHTLY: nightly-2022-10-25
+  RUSTFLAGS: -D warnings
+
+# Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the
+# same VM.  The binary will be built in 32-bit mode, but will execute on a
+# 64-bit kernel and in a 64-bit environment.  Our tests don't execute any of
+# the system's binaries, so the environment shouldn't matter.
+task:
+  name: FreeBSD 64-bit
+  setup_script:
+    - pkg install -y bash
+    - curl https://sh.rustup.rs -sSf --output rustup.sh
+    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
+    - . $HOME/.cargo/env
+    - |
+      echo "~~~~ rustc --version ~~~~"
+      rustc --version
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo test --all --all-features
+
+task:
+  name: FreeBSD docs
+  env:
+    RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
+    RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+  setup_script:
+    - pkg install -y bash
+    - curl https://sh.rustup.rs -sSf --output rustup.sh
+    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_NIGHTLY
+    - . $HOME/.cargo/env
+    - |
+      echo "~~~~ rustc --version ~~~~"
+      rustc --version
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo doc --lib --no-deps --all-features --document-private-items
+
+task:
+  name: FreeBSD 32-bit
+  setup_script:
+    - pkg install -y bash
+    - curl https://sh.rustup.rs -sSf --output rustup.sh
+    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
+    - . $HOME/.cargo/env
+    - rustup target add i686-unknown-freebsd
+    - |
+      echo "~~~~ rustc --version ~~~~"
+      rustc --version
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo test --all --all-features --target i686-unknown-freebsd

.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.56"

.github/buildomat/README.md

@@ -1,20 +0,0 @@
-# Buildomat illumos CI
-
-This directory contains CI configurations for the [illumos] operating system.
-Tokio's illumos CI jobs are run using [Buildomat], a CI system developed by
-Oxide Computer, which supports illumos. See [the Buildomat README] for more
-details.
-
-## illumos-Specific CI Failures
-
-If your pull request's CI build fails on illumos, and you aren't able to easily
-reproduce the failure on other operating systems, don't worry! The
-[tokio-rs/illumos] team is responsible for maintaining Tokio's illumos support,
-and can be called on to assist contributors with illumos-specific issues. Please
-feel free to tag @tokio-rs/illumos to ask for help resolving build failures on
-illumos.
-
-[illumos]: https://www.illumos.org/
-[Buildomat]: https://github.com/oxidecomputer/buildomat
-[the Buildomat README]: https://github.com/oxidecomputer/buildomat
-[tokio-rs/illumos]: https://github.com/orgs/tokio-rs/teams/illumos

.github/buildomat/config.toml

@@ -1,8 +0,0 @@
-# Repository-level Buildomat configuration.
-# See: https://github.com/oxidecomputer/buildomat#per-repository-configuration
-
-# Enable buildomat. This one should be self-explanatory.
-enable = true
-# Allow CI runs for PRs from users outside the `tokio-rs` organization. Our
-# buildomat jobs don't touch any secrets/keys, so this should be fine.
-org_only = false

.github/dependabot.yml

@@ -1,7 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 10

.github/labeler.yml

@@ -1,42 +1,8 @@
-R-loom-blocking:
-- changed-files:
-  - any-glob-to-any-file:
-    - tokio/src/runtime/blocking/*
-    - tokio/src/runtime/blocking/**/*
 
-R-loom-sync:
-- changed-files:
-  - any-glob-to-any-file:
-    - tokio/src/sync/*
-    - tokio/src/sync/**/*
-
-R-loom-time-driver:
-- changed-files:
-  - any-glob-to-any-file:
-    - tokio/src/runtime/time/*
-    - tokio/src/runtime/time/**/*
-    - tokio/src/runtime/time_alt/*
-    - tokio/src/runtime/time_alt/**/*
-
-R-loom-current-thread:
-- changed-files:
-  - any-glob-to-any-file:
-    - tokio/src/runtime/scheduler/*
-    - tokio/src/runtime/scheduler/current_thread/*
-    - tokio/src/runtime/task/*
-    - tokio/src/runtime/task/**
-
-R-loom-multi-thread:
-- changed-files:
-  - any-glob-to-any-file:
-    - 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-util:
-- changed-files:
-  - any-glob-to-any-file:
-    - tokio-util/src/*
-    - tokio-util/src/**/*
+R-loom:
+- tokio/src/sync/*
+- tokio/src/sync/**/*
+- tokio-util/src/sync/*
+- tokio-util/src/sync/**/*
+- tokio/src/runtime/*
+- tokio/src/runtime/**/*

.github/workflows/audit.yml

@@ -13,12 +13,18 @@ permissions:
   contents: read
 
 jobs:
-  cargo-deny:
+  security-audit:
     permissions:
-      checks: write
-      contents: read
-      issues: write
+      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@v7
-    - uses: EmbarkStudios/cargo-deny-action@v2
+      - uses: actions/checkout@v3
+
+      - name: Audit Check
+        # https://github.com/rustsec/audit-check/issues/2
+        uses: rustsec/audit-check@master
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/labeler.yml

@@ -4,10 +4,6 @@ on:
 
 # See .github/labeler.yml file
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
 permissions:
   contents: read
 
@@ -19,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository_owner == 'tokio-rs'
     steps:
-    - uses: actions/labeler@v7
+    - uses: actions/labeler@v3
       with:
         repo-token: "${{ secrets.GITHUB_TOKEN }}"
         sync-labels: true

.github/workflows/loom.yml

@@ -7,14 +7,8 @@ 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
@@ -23,93 +17,28 @@ permissions:
   contents: read
 
 jobs:
-  loom-blocking:
-    name: loom tokio::runtime::spawn_blocking
+  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-blocking') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        # Run the blocking pool loom tests against both `spawn_blocking`
-        # queue implementations.
-        include:
-          - sharded_blocking_queue: "0"
-          - sharded_blocking_queue: "1"
-    steps:
-      - uses: actions/checkout@v7
-      - 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_blocking
-        working-directory: tokio
-        env:
-          TOKIO_UNSTABLE_SHARDED_BLOCKING_QUEUE: ${{ matrix.sharded_blocking_queue }}
-
-  loom-sync:
-    name: loom tokio::sync
-    # 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@v7
-      - 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@v7
-      - 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
-        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@v7
-      - 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
+            max_preemptions: 2
+          - scope: loom_pool::group_a
+            max_preemptions: 1
+          - scope: loom_pool::group_b
+            max_preemptions: 2
+          - scope: loom_pool::group_c
+            max_preemptions: 1
+          - scope: loom_pool::group_d
+            max_preemptions: 1
+          - scope: time::driver
+            max_preemptions: 2
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v3
       - name: Install Rust ${{ env.rust_stable }}
         uses: dtolnay/rust-toolchain@master
         with:
@@ -119,20 +48,7 @@ jobs:
         run: cargo test --lib --release --features full -- --nocapture $SCOPE
         working-directory: tokio
         env:
+          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings -C debug-assertions
+          LOOM_MAX_PREEMPTIONS: ${{ matrix.max_preemptions }}
+          LOOM_MAX_BRANCHES: 10000
           SCOPE: ${{ matrix.scope }}
-
-  loom-util:
-    name: loom tokio-util
-    # 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-util') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - 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
-        working-directory: tokio-util

.github/workflows/pr-audit.yml

@@ -8,16 +8,21 @@ on:
     paths:
       - '**/Cargo.toml'
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
 permissions:
   contents: read
 
 jobs:
-  cargo-deny:
+  security-audit:
     runs-on: ubuntu-latest
+    if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
-    - uses: actions/checkout@v7
-    - uses: EmbarkStudios/cargo-deny-action@v2
+      - uses: actions/checkout@v3
+
+      - name: Install cargo-audit
+        run: cargo install cargo-audit
+
+      - name: Generate lockfile
+        run: cargo generate-lockfile
+
+      - name: Audit dependencies
+        run: cargo audit

.github/workflows/stress-test.yml

@@ -5,15 +5,11 @@ 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: 1.82
+  rust_stable: stable
 
 permissions:
   contents: read
@@ -27,19 +23,19 @@ jobs:
         stress-test:
           - simple_echo_tcp
     steps:
-      - uses: actions/checkout@v7
+      - 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: Install Valgrind
         uses: taiki-e/install-action@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 --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

.github/workflows/uring-kernel-version-test.yml

@@ -1,120 +0,0 @@
-name: Uring Kernel Version Test
-
-on:
-  workflow_call:
-    inputs:
-      kernel_version:
-        description: 'Version of the Linux kernel to build'
-        required: true
-        type: string
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    env:
-      KERNEL_VERSION: ${{ inputs.kernel_version }}
-    steps:
-      - uses: actions/checkout@v7
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            build-essential bison flex libssl-dev libelf-dev \
-            qemu-system-x86 busybox-static cpio xz-utils wget
-
-      - name: Cache Linux source
-        id: cache-kernel
-        uses: actions/cache@v6
-        with:
-          path: linux-${{ env.KERNEL_VERSION }}
-          key: kernel-${{ env.KERNEL_VERSION }}
-
-      - name: Download & build Linux kernel
-        if: steps.cache-kernel.outputs.cache-hit != 'true'
-        run: |
-          MAJOR=${KERNEL_VERSION%%.*}
-          wget https://cdn.kernel.org/pub/linux/kernel/v${MAJOR}.x/linux-${KERNEL_VERSION}.tar.xz
-          tar xf linux-${KERNEL_VERSION}.tar.xz
-          cd linux-${KERNEL_VERSION}
-          make defconfig
-          make -j$(nproc)
-
-      # We are running tests also on a Kernel version that does not support io_uring
-      # to check if the fallback mechanism works
-      - name: Generate test binaries with io_uring enabled
-        run: |
-          # Build both integration (tokio/tests/) and unit (e.g., tokio/src/fs/file/tests.rs) tests with io_uring enabled
-          rustup target add x86_64-unknown-linux-musl
-          RUSTFLAGS="--cfg tokio_unstable" \
-            cargo test -p tokio --features full,io-uring \
-            --target x86_64-unknown-linux-musl --test 'fs*' --lib --no-run
-
-      - name: Prepare initramfs + tests binaries
-        run: |
-          set -e
-          rm -rf initramfs
-          mkdir -p initramfs/{bin,bin/tests,sbin,proc,sys,tmp}
-
-          # Copy test binaries into initramfs
-          for bin in target/x86_64-unknown-linux-musl/debug/deps/{fs_*,tokio-*}; do
-            if [ -f "$bin" ] && [ -x "$bin" ]; then
-              cp "$bin" initramfs/bin/tests
-            fi
-          done
-
-          # Add BusyBox & symlinks
-          cp /usr/bin/busybox initramfs/bin/
-          for cmd in sh mount uname true sleep; do ln -sf busybox initramfs/bin/$cmd; done
-          ln -sf ../bin/busybox initramfs/sbin/poweroff
-
-          # Generate init script
-          cat > initramfs/init << 'EOF'
-          #!/bin/sh
-          set -e
-          mkdir -p /dev
-          # create device nodes, as some tests require them
-          mknod /dev/null c 1 3
-          mknod /dev/zero c 1 5
-          mknod /dev/tty c 5 0
-          mount -t proc proc /proc
-          mount -t sysfs sysfs /sys
-          mkdir -p /tmp && mount -t tmpfs -o mode=1777 tmpfs /tmp
-          for f in /bin/tests/*; do RUST_BACKTRACE=1 "$f" ; done
-          EOF
-          chmod +x initramfs/init
-
-          # Pack into a CPIO archive
-          (cd initramfs && find . -print0 \
-            | cpio --null -ov --format=newc | gzip -9 > ../initramfs.cpio.gz)
-
-      - name: Run tests in QEMU
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          set +e
-          qemu-system-x86_64 \
-            -kernel linux-${{ env.KERNEL_VERSION }}/arch/x86/boot/bzImage \
-            -initrd initramfs.cpio.gz \
-            -append "console=ttyS0 rootfstype=ramfs panic=1" \
-            -nographic -no-reboot -m 1024 -action panic=exit-failure 2>&1 | tee qemu-output.log
-          qemu_status=${PIPESTATUS[0]} tee_status=${PIPESTATUS[1]}
-          set -e
-
-          if [ "$qemu_status" -ne 0 ]; then
-            echo "QEMU exited with status $qemu_status"
-            exit "$qemu_status"
-          fi
-
-          if [ "$tee_status" -ne 0 ]; then
-            echo "tee exited with status $tee_status"
-            exit "$tee_status"
-          fi
-
-          if grep -q "test result: FAILED" qemu-output.log; then
-            echo "tests reported failures"
-            exit 1
-          else
-            echo "all tests passed"
-          fi

.gitignore

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

CONTRIBUTING.md

@@ -1,6 +1,7 @@
 # Contributing to Tokio
 
-Thanks for your help improving Tokio! We are so happy to have you!
+:balloon: Thanks for your help improving the project! We are so happy to have
+you!
 
 There are opportunities to contribute to Tokio at any level. It doesn't matter if
 you are just getting started with Rust or are the most weathered expert, we can
@@ -8,11 +9,15 @@ use your help.
 
 **No contribution is too small and all contributions are valued.**
 
-See the [contributing guidelines] to get started.
+This guide will help you get started. **Do not let this guide intimidate you**.
+It should be considered a map to help you navigate the process.
 
-[contributing guidelines]: docs/contributing/README.md
+The [dev channel][dev] is available for any concerns not covered in this guide, please join
+us!
 
-## Code of Conduct
+[dev]: https://discord.gg/tokio
+
+## Conduct
 
 The Tokio project adheres to the [Rust Code of Conduct][coc]. This describes
 the _minimum_ behavior expected from all contributors. Instances of violations of the
@@ -21,34 +26,656 @@ Code of Conduct can be reported by contacting the project team at
 
 [coc]: https://github.com/rust-lang/rust/blob/master/CODE_OF_CONDUCT.md
 
-## Need Help?
+## Contributing in Issues
 
-Reach out to us on the [Discord server] for any concern not covered in this guide.
+For any issue, there are fundamentally three ways an individual can contribute:
 
-[Discord server]: https://discord.gg/tokio
+1. By opening the issue for discussion: For instance, if you believe that you
+   have discovered a bug in Tokio, creating a new issue in [the tokio-rs/tokio
+   issue tracker][issue] is the way to report it.
+
+2. By helping to triage the issue: This can be done by providing
+   supporting details (a test case that demonstrates a bug), providing
+   suggestions on how to address the issue, or ensuring that the issue is tagged
+   correctly.
+
+3. By helping to resolve the issue: Typically this is done either in the form of
+   demonstrating that the issue reported is not a problem after all, or more
+   often, by opening a Pull Request that changes some bit of something in
+   Tokio in a concrete and reviewable manner.
+
+[issue]: https://github.com/tokio-rs/tokio/issues
+
+**Anybody can participate in any stage of contribution**. We urge you to
+participate in the discussion around bugs and participate in reviewing PRs.
+
+### Asking for General Help
+
+If you have reviewed existing documentation and still have questions or are
+having problems, you can [open a discussion] asking for help.
+
+In exchange for receiving help, we ask that you contribute back a documentation
+PR that helps others avoid the problems that you encountered.
+
+[open a discussion]: https://github.com/tokio-rs/tokio/discussions/new
+
+### Submitting a Bug Report
+
+When opening a new issue in the Tokio issue tracker, you will be presented
+with a basic template that should be filled in. If you believe that you have
+uncovered a bug, please fill out this form, following the template to the best
+of your ability. Do not worry if you cannot answer every detail, just fill in
+what you can.
+
+The two most important pieces of information we need in order to properly
+evaluate the report is a description of the behavior you are seeing and a simple
+test case we can use to recreate the problem on our own. If we cannot recreate
+the issue, it becomes impossible for us to fix.
+
+In order to rule out the possibility of bugs introduced by userland code, test
+cases should be limited, as much as possible, to using only Tokio APIs.
+
+See [How to create a Minimal, Complete, and Verifiable example][mcve].
+
+[mcve]: https://stackoverflow.com/help/mcve
+
+### Triaging a Bug Report
+
+Once an issue has been opened, it is not uncommon for there to be discussion
+around it. Some contributors may have differing opinions about the issue,
+including whether the behavior being seen is a bug or a feature. This discussion
+is part of the process and should be kept focused, helpful, and professional.
+
+Short, clipped responses—that provide neither additional context nor supporting
+detail—are not helpful or professional. To many, such responses are simply
+annoying and unfriendly.
+
+Contributors are encouraged to help one another make forward progress as much as
+possible, empowering one another to solve issues collaboratively. If you choose
+to comment on an issue that you feel either is not a problem that needs to be
+fixed, or if you encounter information in an issue that you feel is incorrect,
+explain why you feel that way with additional supporting context, and be willing
+to be convinced that you may be wrong. By doing so, we can often reach the
+correct outcome much faster.
+
+### Resolving a Bug Report
+
+In the majority of cases, issues are resolved by opening a Pull Request. The
+process for opening and reviewing a Pull Request is similar to that of opening
+and triaging issues, but carries with it a necessary review and approval
+workflow that ensures that the proposed changes meet the minimal quality and
+functional guidelines of the Tokio project.
+
+## Pull Requests
+
+Pull Requests are the way concrete changes are made to the code, documentation,
+and dependencies in the Tokio repository.
+
+Even tiny pull requests (e.g., one character pull request fixing a typo in API
+documentation) are greatly appreciated. Before making a large change, it is
+usually a good idea to first open an issue describing the change to solicit
+feedback and guidance. This will increase the likelihood of the PR getting
+merged.
+
+### Cargo Commands
+
+Due to the extensive use of features in Tokio, you will often need to add extra
+arguments to many common cargo commands. This section lists some commonly needed
+commands.
+
+Some commands just need the `--all-features` argument:
+
+```
+cargo build --all-features
+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
+
+<!--
+When updating this, also update:
+- .github/workflows/ci.yml
+- README.md
+- tokio/README.md
+- tokio/Cargo.toml
+- tokio-util/Cargo.toml
+- tokio-test/Cargo.toml
+- tokio-stream/Cargo.toml
+-->
+
+```
+cargo +1.65.0 clippy --all --tests --all-features
+```
+
+When building documentation normally, the markers that list the features
+required for various parts of Tokio are missing. To build the documentation
+correctly, use this command:
+
+```
+RUSTDOCFLAGS="--cfg docsrs" RUSTFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+```
+
+To build documentation including Tokio's unstable features, it is necessary to
+pass `--cfg tokio_unstable` to both RustDoc *and* rustc. To build the
+documentation for unstable features, use this command:
+
+```
+RUSTDOCFLAGS="--cfg docsrs --cfg tokio_unstable" RUSTFLAGS="--cfg docsrs --cfg tokio_unstable" cargo +nightly doc --all-features
+```
+
+The `cargo fmt` command does not work on the Tokio codebase. You can use the
+command below instead:
+
+```
+# Mac or Linux
+rustfmt --check --edition 2018 $(git ls-files '*.rs')
+
+# Powershell
+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.
+
+You can run loom tests with
+```
+cd tokio # tokio crate in workspace
+LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
+    cargo test --lib --release --features full -- --test-threads=1 --nocapture
+```
+
+You can run miri tests with
+```
+MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" \
+    cargo +nightly miri test --features full --lib
+```
+
+### Tests
+
+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
+```
+
+#### Integration tests
+
+Integration tests go in the same crate as the code they are testing. Each sub
+crate should have a `dev-dependency` on `tokio` itself. This makes all Tokio
+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
+use the API. Documentation tests are run with `cargo test --doc`. This ensures
+that the example is correct and provides additional test coverage.
+
+The trick to documentation tests is striking a balance between being succinct
+for a reader to understand and actually testing the API.
+
+Same as with integration tests, when writing a documentation test, the full
+`tokio` crate is available. This is especially useful for getting access to the
+runtime to run the example.
+
+The documentation tests will be visible from both the crate specific
+documentation **and** the `tokio` facade documentation via the re-export. The
+example should be written from the point of view of a user that is using the
+`tokio` crate. As such, the example should use the API via the facade and not by
+directly referencing the crate.
+
+The type level example for `tokio_timer::Timeout` provides a good example of a
+documentation test:
+
+```
+/// // import the `timeout` function, usually this is done
+/// // with `use tokio::prelude::*`
+/// use tokio::prelude::FutureExt;
+/// use futures::Stream;
+/// use futures::sync::mpsc;
+/// use std::time::Duration;
+///
+/// # fn main() {
+/// let (tx, rx) = mpsc::unbounded();
+/// # tx.unbounded_send(()).unwrap();
+/// # drop(tx);
+///
+/// let process = rx.for_each(|item| {
+///     // do something with `item`
+/// # drop(item);
+/// # Ok(())
+/// });
+///
+/// # tokio::runtime::current_thread::block_on_all(
+/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds.
+/// process.timeout(Duration::from_millis(10))
+/// # ).unwrap();
+/// # }
+```
+
+Given that this is a *type* level documentation test and the primary way users
+of `tokio` will create an instance of `Timeout` is by using
+`FutureExt::timeout`, this is how the documentation test is structured.
+
+Lines that start with `/// #` are removed when the documentation is generated.
+They are only there to get the test to run. The `block_on_all` function is the
+easiest way to execute a future from a test.
+
+If this were a documentation test for the `Timeout::new` function, then the
+example would explicitly use `Timeout::new`. For example:
+
+```
+/// use tokio::timer::Timeout;
+/// use futures::Future;
+/// use futures::sync::oneshot;
+/// use std::time::Duration;
+///
+/// # fn main() {
+/// let (tx, rx) = oneshot::channel();
+/// # tx.send(()).unwrap();
+///
+/// # tokio::runtime::current_thread::block_on_all(
+/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds.
+/// Timeout::new(rx, Duration::from_millis(10))
+/// # ).unwrap();
+/// # }
+```
+
+### Commits
+
+It is a recommended best practice to keep your changes as logically grouped as
+possible within individual commits. There is no limit to the number of commits
+any single Pull Request may have, and many contributors find it easier to review
+changes that are split across multiple commits.
+
+That said, if you have a number of commits that are "checkpoints" and don't
+represent a single logical change, please squash those together.
+
+Note that multiple commits often get squashed when they are landed (see the
+notes about [commit squashing](#commit-squashing)).
+
+#### Commit message guidelines
+
+A good commit message should describe what changed and why.
+
+1. The first line should:
+
+  * contain a short description of the change (preferably 50 characters or less,
+    and no more than 72 characters)
+  * be entirely in lowercase with the exception of proper nouns, acronyms, and
+    the words that refer to code, like function/variable names
+  * be prefixed with the name of the sub crate being changed (without the `tokio-`
+    prefix) and start with an imperative verb. If modifying `tokio` proper,
+    omit the crate prefix.
+
+  Examples:
+
+  * timer: introduce `Timeout` and deprecate `Deadline`
+  * export `Encoder`, `Decoder`, `Framed*` from tokio_codec
+
+2. Keep the second line blank.
+3. Wrap all other lines at 72 columns (except for long URLs).
+4. If your patch fixes an open issue, you can add a reference to it at the end
+   of the log. Use the `Fixes: #` prefix and the issue number. For other
+   references use `Refs: #`. `Refs` may include multiple issues, separated by a
+   comma.
+
+   Examples:
+
+   - `Fixes: #1337`
+   - `Refs: #1234`
+
+Sample complete commit message:
+
+```txt
+subcrate: explain the commit in one line
+
+Body of commit message is a few lines of text, explaining things
+in more detail, possibly giving some background about the issue
+being fixed, etc.
+
+The body of the commit message can be several paragraphs, and
+please do proper word-wrap and keep columns shorter than about
+72 characters or so. That way, `git log` will show things
+nicely even when it is indented.
+
+Fixes: #1337
+Refs: #453, #154
+```
+
+### Opening the Pull Request
+
+From within GitHub, opening a new Pull Request will present you with a
+[template] that should be filled out. Please try to do your best at filling out
+the details, but feel free to skip parts if you're not sure what to put.
+
+[template]: .github/PULL_REQUEST_TEMPLATE.md
+
+### Discuss and update
+
+You will probably get feedback or requests for changes to your Pull Request.
+This is a big part of the submission process so don't be discouraged! Some
+contributors may sign off on the Pull Request right away, others may have
+more detailed comments or feedback. This is a necessary part of the process
+in order to evaluate whether the changes are correct and necessary.
+
+**Any community member can review a PR and you might get conflicting feedback**.
+Keep an eye out for comments from code owners to provide guidance on conflicting
+feedback.
+
+**Once the PR is open, do not rebase the commits**. See [Commit Squashing](#commit-squashing) for
+more details.
+
+### Commit Squashing
+
+In most cases, **do not squash commits that you add to your Pull Request during
+the review process**. When the commits in your Pull Request land, they may be
+squashed into one commit per logical change. Metadata will be added to the
+commit message (including links to the Pull Request, links to relevant issues,
+and the names of the reviewers). The commit history of your Pull Request,
+however, will stay intact on the Pull Request page.
+
+## Reviewing Pull Requests
+
+**Any Tokio community member is welcome to review any pull request**.
+
+All Tokio contributors who choose to review and provide feedback on Pull
+Requests have a responsibility to both the project and the individual making the
+contribution. Reviews and feedback must be helpful, insightful, and geared
+towards improving the contribution as opposed to simply blocking it. If there
+are reasons why you feel the PR should not land, explain what those are. Do not
+expect to be able to block a Pull Request from advancing simply because you say
+"No" without giving an explanation. Be open to having your mind changed. Be open
+to working with the contributor to make the Pull Request better.
+
+Reviews that are dismissive or disrespectful of the contributor or any other
+reviewers are strictly counter to the Code of Conduct.
+
+When reviewing a Pull Request, the primary goals are for the codebase to improve
+and for the person submitting the request to succeed. **Even if a Pull Request
+does not land, the submitters should come away from the experience feeling like
+their effort was not wasted or unappreciated**. Every Pull Request from a new
+contributor is an opportunity to grow the community.
+
+### Review a bit at a time.
+
+Do not overwhelm new contributors.
+
+It is tempting to micro-optimize and make everything about relative performance,
+perfect grammar, or exact style matches. Do not succumb to that temptation.
+
+Focus first on the most significant aspects of the change:
+
+1. Does this change make sense for Tokio?
+2. Does this change make Tokio better, even if only incrementally?
+3. Are there clear bugs or larger scale issues that need attending to?
+4. Is the commit message readable and correct? If it contains a breaking change
+   is it clear enough?
+
+Note that only **incremental** improvement is needed to land a PR. This means
+that the PR does not need to be perfect, only better than the status quo. Follow
+up PRs may be opened to continue iterating.
+
+When changes are necessary, *request* them, do not *demand* them, and **do not
+assume that the submitter already knows how to add a test or run a benchmark**.
+
+Specific performance optimization techniques, coding styles and conventions
+change over time. The first impression you give to a new contributor never does.
+
+Nits (requests for small changes that are not essential) are fine, but try to
+avoid stalling the Pull Request. Most nits can typically be fixed by the Tokio
+Collaborator landing the Pull Request but they can also be an opportunity for
+the contributor to learn a bit more about the project.
+
+It is always good to clearly indicate nits when you comment: e.g.
+`Nit: change foo() to bar(). But this is not blocking.`
+
+If your comments were addressed but were not folded automatically after new
+commits or if they proved to be mistaken, please, [hide them][hiding-a-comment]
+with the appropriate reason to keep the conversation flow concise and relevant.
+
+### Be aware of the person behind the code
+
+Be aware that *how* you communicate requests and reviews in your feedback can
+have a significant impact on the success of the Pull Request. Yes, we may land
+a particular change that makes Tokio better, but the individual might just not
+want to have anything to do with Tokio ever again. The goal is not just having
+good code.
+
+### Abandoned or Stalled Pull Requests
+
+If a Pull Request appears to be abandoned or stalled, it is polite to first
+check with the contributor to see if they intend to continue the work before
+checking if they would mind if you took it over (especially if it just has nits
+left). When doing so, it is courteous to give the original contributor credit
+for the work they started (either by preserving their name and email address in
+the commit log, or by using an `Author: ` meta-data tag in the commit.
+
+_Adapted from the [Node.js contributing guide][node]_.
+
+[node]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
+[hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment
+[documentation test]: https://doc.rust-lang.org/rustdoc/documentation-tests.html
+
+## Keeping track of issues and PRs
+
+The Tokio GitHub repository has a lot of issues and PRs to keep track of. This
+section explains the meaning of various labels, as well as our [GitHub
+project][project]. The section is primarily targeted at maintainers.  Most
+contributors aren't able to set these labels.
+
+### Area
+
+The area label describes the crates relevant to this issue or PR.
+
+ - **A-tokio** This issue concerns the main Tokio crate.
+ - **A-tokio-util** This issue concerns the `tokio-util` crate.
+ - **A-tokio-tls** This issue concerns the `tokio-tls` crate. Only used for
+   older issues, as the crate has been moved to another repository.
+ - **A-tokio-test** The issue concerns the `tokio-test` crate.
+ - **A-tokio-macros** This issue concerns the `tokio-macros` crate. Should only
+   be used for the procedural macros, and not `join!` or `select!`.
+ - **A-ci** This issue concerns our GitHub Actions setup.
+
+### Category
+
+ - **C-bug** This is a bug-report. Bug-fix PRs use `C-enhancement` instead.
+ - **C-enhancement** This is a PR that adds a new features.
+ - **C-maintenance** This is an issue or PR about stuff such as documentation,
+   GitHub Actions or code quality.
+ - **C-feature-request** This is a feature request. Implementations of feature
+   requests use `C-enhancement` instead.
+ - **C-feature-accepted** If you submit a PR for this feature request, we wont
+   close it with the reason "we don't want this". Issues with this label should
+   also have the `C-feature-request` label.
+ - **C-musing** Stuff like tracking issues or roadmaps. "musings about a better
+   world"
+ - **C-proposal** A proposal of some kind, and a request for comments.
+ - **C-question** A user question. Large overlap with GitHub discussions.
+ - **C-request** A non-feature request, e.g. "please add deprecation notices to
+   `-alpha.*` versions of crates"
+
+### Calls for participation
+
+ - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
+   or `C-feature-accepted`.
+ - **E-easy** This is easy, ranging from quick documentation fixes to stuff you
+   can do after reading the tutorial on our website.
+ - **E-medium** This is not `E-easy` or `E-hard`.
+ - **E-hard** This either involves very tricky code, is something we don't know
+   how to solve, or is difficult for some other reason.
+ - **E-needs-mvce** This bug is missing a minimal complete and verifiable
+   example.
+
+The "E-" prefix is the same as used in the Rust compiler repository. Some
+issues are missing a difficulty rating, but feel free to ask on our Discord
+server if you want to know how difficult an issue likely is.
+
+### Module
+
+The module label provides a more fine grained categorization than **Area**.
+
+ - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
+ - **M-codec** The `tokio_util::codec` module.
+ - **M-compat** The `tokio_util::compat` module.
+ - **M-coop** Things relevant to coop.
+ - **M-fs** The `tokio::fs` module.
+ - **M-io** The `tokio::io` module.
+ - **M-macros** Issues about any kind of macro.
+ - **M-net** The `tokio::net` module.
+ - **M-process** The `tokio::process` module.
+ - **M-runtime** The `tokio::runtime` module.
+ - **M-signal** The `tokio::signal` module.
+ - **M-sync** The `tokio::sync` module.
+ - **M-task** The `tokio::task` module.
+ - **M-time** The `tokio::time` module.
+ - **M-tracing** Tracing support in Tokio.
+
+### Topic
+
+Some extra information.
+
+ - **T-docs** This is about documentation.
+ - **T-performance** This is about performance.
+ - **T-v0.1.x** This is about old Tokio.
+
+Any label not listed here is not in active use.
+
+[project]: https://github.com/orgs/tokio-rs/projects/1
 
 ## LTS guarantees
 
-In Tokio ≥1.0.0, each LTS release comes with the guarantee of at least one year of
-backported fixes.
+Tokio ≥1.0.0 comes with LTS guarantees:
+
+ * A minimum of 5 years of maintenance.
+ * A minimum of 3 years before a hypothetical 2.0 release.
 
 The goal of these guarantees is to provide stability to the ecosystem.
 
 ## Minimum Supported Rust Version (MSRV)
 
-* All Tokio ≥1.0.0 releases will support at least a 6-month old Rust
-  compiler release.
-* The MSRV will only be increased on 1.x releases.
+ * All Tokio ≥1.0.0 releases will support at least a 6-month old Rust
+   compiler release.
+ * The MSRV will only be increased on 1.x releases.
 
 ## Versioning Policy
 
 With Tokio ≥1.0.0:
 
-* Patch (1.\_.x) releases _should only_ contain bug fixes or documentation
-  changes. Besides this, these releases should not substantially change
-  runtime behavior.
-* Minor (1.x) releases may contain new functionality, MSRV increases (see
-  above), minor dependency updates, deprecations, and larger internal
-  implementation changes.
+ * Patch (1.\_.x) releases _should only_ contain bug fixes or documentation
+   changes. Besides this, these releases should not substantially change
+   runtime behavior.
+ * Minor (1.x) releases may contain new functionality, MSRV increases (see
+   above), minor dependency updates, deprecations, and larger internal
+   implementation changes.
 
 This is as defined by [Semantic Versioning 2.0](https://semver.org/).
+
+## Releasing
+
+Since the Tokio project consists of a number of crates, many of which depend on
+each other, releasing new versions to crates.io can involve some complexities.
+When releasing a new version of a crate, follow these steps:
+
+1. **Ensure that the release crate has no path dependencies.** When the HEAD
+   version of a Tokio crate requires unreleased changes in another Tokio crate,
+   the crates.io dependency on the second crate will be replaced with a path
+   dependency. Crates with path dependencies cannot be published, so before
+   publishing the dependent crate, any path dependencies must also be published.
+   This should be done through a form of depth-first tree traversal:
+
+   1. Starting with the first path dependency in the crate to be released,
+      inspect the `Cargo.toml` for the dependency. If the dependency has any
+      path dependencies of its own, repeat this step with the first such
+      dependency.
+   2. Begin the release process for the path dependency.
+   3. Once the path dependency has been published to crates.io, update the
+      dependent crate to depend on the crates.io version.
+   4. When all path dependencies have been published, the dependent crate may
+      be published.
+
+   To verify that a crate is ready to publish, run:
+
+   ```bash
+   bin/publish --dry-run <CRATE NAME> <CRATE VERSION>
+   ```
+
+2. **Update Cargo metadata.** After releasing any path dependencies, update the
+   `version` field in `Cargo.toml` to the new version, and the `documentation`
+   field to the docs.rs URL of the new version.
+3. **Update other documentation links.** Update the "Documentation" link in the
+   crate's `README.md` to point to the docs.rs URL of the new version.
+4. **Update the changelog for the crate.** Each crate in the Tokio repository
+   has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
+   crate since the last release should be added to the changelog. Change
+   descriptions may be taken from the Git history, but should be edited to
+   ensure a consistent format, based on [Keep A Changelog][keep-a-changelog].
+   Other entries in that crate's changelog may also be used for reference.
+5. **Perform a final audit for breaking changes.** Compare the HEAD version of
+   crate with the Git tag for the most recent release version. If there are any
+   breaking API changes, determine if those changes can be made without breaking
+   existing APIs. If so, resolve those issues. Otherwise, if it is necessary to
+   make a breaking release, update the version numbers to reflect this.
+6. **Open a pull request with your changes.** Once that pull request has been
+   approved by a maintainer and the pull request has been merged, continue to
+   the next step.
+7. **Release the crate.** Run the following command:
+
+   ```bash
+   bin/publish <NAME OF CRATE> <VERSION>
+   ```
+
+   Your editor and prompt you to edit a message for the tag. Copy the changelog
+   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",
@@ -14,26 +14,3 @@ members = [
   "tests-build",
   "tests-integration",
 ]
-
-[patch.crates-io]
-tokio = { path = "tokio" }
-tokio-macros = { path = "tokio-macros" }
-tokio-stream = { path = "tokio-stream" }
-tokio-test = { path = "tokio-test" }
-tokio-util = { path = "tokio-util" }
-
-[workspace.metadata.spellcheck]
-config = "spellcheck.toml"
-
-[workspace.lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = [
-  'cfg(fuzzing)',
-  'cfg(loom)',
-  'cfg(mio_unsupported_force_poll_poll)',
-  'cfg(tokio_allow_from_blocking_fd)',
-  'cfg(tokio_internal_mt_counters)',
-  'cfg(tokio_no_parking_lot)',
-  'cfg(tokio_no_tuning_tests)',
-  'cfg(tokio_unstable)',
-  'cfg(target_os, values("cygwin"))',
-] }

LICENSE

@@ -1,21 +1,25 @@
-MIT License
+Copyright (c) 2023 Tokio Contributors
 
-Copyright (c) Tokio Contributors
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -39,7 +39,7 @@ level, it provides a few major components:
 
 * A multithreaded, work-stealing based task [scheduler].
 * A reactor backed by the operating system's event queue (epoll, kqueue,
-  IOCP, etc.).
+  IOCP, etc...).
 * Asynchronous [TCP and UDP][net] sockets.
 
 These components provide the runtime components necessary for building
@@ -52,11 +52,11 @@ an asynchronous application.
 
 A basic TCP echo server with Tokio.
 
-Make sure you enable the full features of the tokio crate on Cargo.toml:
+Make sure you activated the full features of the tokio crate on Cargo.toml:
 
 ```toml
 [dependencies]
-tokio = { version = "1.53.1", features = ["full"] }
+tokio = { version = "1.28.1", features = ["full"] }
 ```
 Then, on your main.rs:
 
@@ -78,7 +78,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             loop {
                 let n = match socket.read(&mut buf).await {
                     // socket closed
-                    Ok(0) => return,
+                    Ok(n) if n == 0 => return,
                     Ok(n) => n,
                     Err(e) => {
                         eprintln!("failed to read from socket; err = {:?}", e);
@@ -103,7 +103,7 @@ More examples can be found [here][examples]. For a larger "real world" example,
 [examples]: https://github.com/tokio-rs/tokio/tree/master/examples
 [mini-redis]: https://github.com/tokio-rs/mini-redis/
 
-To see a list of the available feature flags that can be enabled, check our
+To see a list of the available features flags that can be enabled, check our
 [docs][feature-flag-docs].
 
 ## Getting Help
@@ -125,15 +125,13 @@ question. You can also ask your question on [the discussions page][discussions].
 you! We have a [contributing guide][guide] to help you get involved in the Tokio
 project.
 
-[guide]: https://github.com/tokio-rs/tokio/blob/master/docs/contributing/README.md
+[guide]: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
 
 ## Related Projects
 
 In addition to the crates in this repository, the Tokio project also maintains
 several other libraries, including:
 
-* [`axum`]: A web application framework that focuses on ergonomics and modularity.
-
 * [`hyper`]: A fast and correct HTTP/1.1 and HTTP/2 implementation for Rust.
 
 * [`tonic`]: A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility.
@@ -144,18 +142,21 @@ several other libraries, including:
 
 * [`tracing`] (formerly `tokio-trace`): A framework for application-level tracing and async-aware diagnostics.
 
-* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers `tokio`.
+* [`rdbc`]: A Rust database connectivity library for MySQL, Postgres and SQLite.
+
+* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
+  `tokio`.
 
 * [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
 
-* [`loom`]: A testing tool for concurrent Rust code.
+* [`loom`]: A testing tool for concurrent Rust code
 
-[`axum`]: https://github.com/tokio-rs/axum
 [`warp`]: https://github.com/seanmonstar/warp
 [`hyper`]: https://github.com/hyperium/hyper
 [`tonic`]: https://github.com/hyperium/tonic
 [`tower`]: https://github.com/tower-rs/tower
 [`loom`]: https://github.com/tokio-rs/loom
+[`rdbc`]: https://github.com/tokio-rs/rdbc
 [`tracing`]: https://github.com/tokio-rs/tracing
 [`mio`]: https://github.com/tokio-rs/mio
 [`bytes`]: https://github.com/tokio-rs/bytes
@@ -186,15 +187,12 @@ 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.71.
+released at least six months ago. The current MSRV is 1.56.0.
 
 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.48 to now  - Rust 1.71
- * 1.39 to 1.47 - Rust 1.70
- * 1.30 to 1.38 - Rust 1.63
- * 1.27 to 1.29 - Rust 1.56
+ * 1.27 to now - 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
@@ -206,8 +204,8 @@ works with the MSRV of that minor release.
 
 ## Release schedule
 
-Tokio doesn't follow a fixed release schedule, but we typically make one minor
-release each month. We make patch releases for bugfixes as necessary.
+Tokio doesn't follow a fixed release schedule, but we typically make one to two
+new minor releases each month. We make patch releases for bugfixes as necessary.
 
 ## Bug patching policy
 
@@ -217,32 +215,21 @@ 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.47.x` - LTS release until September 2026. (MSRV 1.70)
- * `1.51.x` - LTS release until March 2027. (MSRV 1.71)
+ * `1.18.x` - LTS release until June 2023. (MSRV 1.49)
+ * `1.20.x` - LTS release until September 2023. (MSRV 1.49)
+ * `1.25.x` - LTS release until March 2024. (MSRV 1.49)
 
 Each LTS release will continue to receive backported fixes for at least a year.
 If you wish to use a fixed minor release in your project, we recommend that you
 use an LTS release.
 
 To use a fixed minor version, you can specify the version with a tilde. For
-example, to specify that you wish to use the newest `1.47.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.47", 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.
- * `1.20.x` - LTS release until September 2023.
- * `1.25.x` - LTS release until March 2024.
- * `1.32.x` - LTS release until September 2024.
- * `1.36.x` - LTS release until March 2025.
- * `1.38.x` - LTS release until July 2025.
- * `1.43.x` - LTS release until March 2026.
-
 ## License
 
 This project is licensed under the [MIT license].
@@ -252,5 +239,5 @@ This project is licensed under the [MIT license].
 ### Contribution
 
 Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you shall be licensed as MIT, without any additional
+for inclusion in Tokio by you, shall be licensed as MIT, without any additional
 terms or conditions.

benches/Cargo.toml

@@ -2,21 +2,20 @@
 name = "benches"
 version = "0.0.0"
 publish = false
-edition = "2021"
-license = "MIT"
+edition = "2018"
 
 [features]
 test-util = ["tokio/test-util"]
 
 [dependencies]
 tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-criterion = "0.5.1"
-rand = "0.9"
-rand_chacha = "0.9"
+bencher = "0.1.5"
+rand = "0.8"
+rand_chacha = "0.3"
 
 [dev-dependencies]
 tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
+tokio-stream = { path = "../tokio-stream" }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.42"
@@ -26,11 +25,6 @@ name = "spawn"
 path = "spawn.rs"
 harness = false
 
-[[bench]]
-name = "sync_broadcast"
-path = "sync_broadcast.rs"
-harness = false
-
 [[bench]]
 name = "sync_mpsc"
 path = "sync_mpsc.rs"
@@ -90,21 +84,3 @@ harness = false
 name = "time_now"
 path = "time_now.rs"
 harness = false
-
-[[bench]]
-name = "time_timeout"
-path = "time_timeout.rs"
-harness = false
-
-[[bench]]
-name = "spawn_blocking"
-path = "spawn_blocking.rs"
-harness = false
-
-[[bench]]
-name = "remote_spawn"
-path = "remote_spawn.rs"
-harness = false
-
-[lints]
-workspace = true

benches/copy.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use bencher::{benchmark_group, benchmark_main, Bencher};
 
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
@@ -29,7 +29,7 @@ const WRITE_SERVICE_PERIOD: Duration = Duration::from_millis(20);
 // because another writer claimed the buffer space
 const PROBABILITY_FLUSH_WAIT: f64 = 0.1;
 
-/// A slow writer that aims to simulate HDD behavior under heavy load.
+/// 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
@@ -64,7 +64,7 @@ impl SlowHddWriter {
     ) -> 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 res.is_ready() {
+        if let Poll::Ready(_) = res {
             self.buffer_used = 0;
         }
         res
@@ -73,11 +73,11 @@ impl SlowHddWriter {
     fn write_bytes(
         mut self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
-        writable: usize,
+        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.random_bool(PROBABILITY_FLUSH_WAIT) {
+        if service_res.is_pending() && self.blocking_rng.gen_bool(PROBABILITY_FLUSH_WAIT) {
             return Poll::Pending;
         }
         let available = self.buffer_size - self.buffer_used;
@@ -86,7 +86,7 @@ impl SlowHddWriter {
             assert!(service_res.is_pending());
             Poll::Pending
         } else {
-            let written = available.min(writable);
+            let written = available.min(writeable);
             self.buffer_used += written;
             Poll::Ready(Ok(written))
         }
@@ -123,8 +123,8 @@ impl AsyncWrite for SlowHddWriter {
         cx: &mut std::task::Context<'_>,
         bufs: &[std::io::IoSlice<'_>],
     ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let writable = bufs.iter().fold(0, |acc, buf| acc + buf.len());
-        self.write_bytes(cx, writable)
+        let writeable = bufs.into_iter().fold(0, |acc, buf| acc + buf.len());
+        self.write_bytes(cx, writeable)
     }
 
     fn is_write_vectored(&self) -> bool {
@@ -145,7 +145,7 @@ 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_n(0, chunk_size).collect();
+        let data: Vec<u8> = std::iter::repeat(0).take(chunk_size).collect();
         Self {
             data,
             service_intervals,
@@ -174,77 +174,65 @@ fn rt() -> tokio::runtime::Runtime {
         .unwrap()
 }
 
-fn copy_mem_to_mem(c: &mut Criterion) {
+fn copy_mem_to_mem(b: &mut Bencher) {
     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();
-            };
+    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());
-        })
-    });
+        rt.block_on(task());
+    })
 }
 
-fn copy_mem_to_slow_hdd(c: &mut Criterion) {
+fn copy_mem_to_slow_hdd(b: &mut Bencher) {
     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();
-            };
+    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());
-        })
-    });
+        rt.block_on(task());
+    })
 }
 
-fn copy_chunk_to_mem(c: &mut Criterion) {
+fn copy_chunk_to_mem(b: &mut Bencher) {
     let rt = rt();
+    b.iter(|| {
+        let task = || async {
+            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
+            let mut dest = Vec::new();
+            copy(&mut source, &mut dest).await.unwrap();
+        };
 
-    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());
-        })
-    });
+        rt.block_on(task());
+    })
 }
 
-fn copy_chunk_to_slow_hdd(c: &mut Criterion) {
+fn copy_chunk_to_slow_hdd(b: &mut Bencher) {
     let rt = rt();
+    b.iter(|| {
+        let task = || async {
+            let mut source = ChunkReader::new(CHUNK_SIZE, READ_SERVICE_PERIOD).take(SOURCE_SIZE);
+            let mut dest = SlowHddWriter::new(WRITE_SERVICE_PERIOD, WRITE_BUFFER);
+            copy(&mut source, &mut dest).await.unwrap();
+        };
 
-    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());
-        })
-    });
+        rt.block_on(task());
+    })
 }
 
-criterion_group!(
+benchmark_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);
+benchmark_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/remote_spawn.rs

@@ -1,101 +0,0 @@
-//! Benchmark remote task spawning (push_remote_task) at different concurrency
-//! levels on the multi-threaded scheduler.
-//!
-//! This measures contention on the scheduler's inject queue mutex when multiple
-//! external (non-worker) threads spawn tasks into the tokio runtime simultaneously.
-//! Every rt.spawn() from an external thread unconditionally goes through
-//! push_remote_task, making this a direct measurement of inject queue contention.
-//!
-//! For each parallelism level N (1, 2, 4, 8, 16, 32, 64, capped at available parallelism):
-//! - Spawns N std::threads (external to the runtime)
-//! - Each thread spawns TOTAL_TASKS / N tasks into the runtime via rt.spawn()
-//! - All threads are synchronized with a barrier to maximize contention
-//! - Tasks are trivial no-ops to isolate the push overhead
-
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use std::sync::Barrier;
-use tokio::runtime::{self, Runtime};
-
-/// Total number of tasks spawned across all threads per iteration.
-/// Must be divisible by the largest parallelism level (64).
-const TOTAL_TASKS: usize = 12_800;
-const _: () = assert!(
-    TOTAL_TASKS.is_multiple_of(64),
-    "TOTAL_TASKS must be divisible by 64"
-);
-
-fn remote_spawn_contention(c: &mut Criterion) {
-    let parallelism_levels = parallelism_levels();
-    let mut group = c.benchmark_group("remote_spawn");
-
-    for num_threads in &parallelism_levels {
-        let num_threads = *num_threads;
-        group.bench_with_input(
-            BenchmarkId::new("threads", num_threads),
-            &num_threads,
-            |b, &num_threads| {
-                let rt = rt();
-                let tasks_per_thread = TOTAL_TASKS / num_threads;
-                let barrier = Barrier::new(num_threads);
-
-                b.iter_custom(|iters| {
-                    let mut total_duration = std::time::Duration::ZERO;
-                    for _ in 0..iters {
-                        let start = std::time::Instant::now();
-
-                        let all_handles = std::thread::scope(|s| {
-                            let handles: Vec<_> = (0..num_threads)
-                                .map(|_| {
-                                    let barrier = &barrier;
-                                    let rt = &rt;
-                                    s.spawn(move || {
-                                        let mut join_handles = Vec::with_capacity(tasks_per_thread);
-                                        barrier.wait();
-
-                                        for _ in 0..tasks_per_thread {
-                                            join_handles.push(rt.spawn(async {}));
-                                        }
-                                        join_handles
-                                    })
-                                })
-                                .collect();
-
-                            handles
-                                .into_iter()
-                                .flat_map(|h| h.join().unwrap())
-                                .collect::<Vec<_>>()
-                        });
-
-                        total_duration += start.elapsed();
-
-                        rt.block_on(async {
-                            for h in all_handles {
-                                h.await.unwrap();
-                            }
-                        });
-                    }
-                    total_duration
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn parallelism_levels() -> Vec<usize> {
-    let max_parallelism = std::thread::available_parallelism().map_or(1, |p| p.get());
-
-    [1, 2, 4, 8, 16, 32, 64]
-        .into_iter()
-        .filter(|&n| n <= max_parallelism)
-        .collect()
-}
-
-fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread().build().unwrap()
-}
-
-criterion_group!(remote_spawn_benches, remote_spawn_contention);
-
-criterion_main!(remote_spawn_benches);

benches/rt_current_thread.rs

@@ -4,50 +4,46 @@
 
 use tokio::runtime::{self, Runtime};
 
-use criterion::{criterion_group, criterion_main, Criterion};
+use bencher::{benchmark_group, benchmark_main, Bencher};
 
 const NUM_SPAWN: usize = 1_000;
 
-fn rt_curr_spawn_many_local(c: &mut Criterion) {
+fn spawn_many_local(b: &mut Bencher) {
     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 {}));
-                }
+    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();
-                }
-            });
-        })
+            for handle in handles.drain(..) {
+                handle.await.unwrap();
+            }
+        });
     });
 }
 
-fn rt_curr_spawn_many_remote_idle(c: &mut Criterion) {
+fn spawn_many_remote_idle(b: &mut Bencher) {
     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 {}));
-            }
+    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();
-                }
-            });
-        })
+        rt.block_on(async {
+            for handle in handles.drain(..) {
+                handle.await.unwrap();
+            }
+        });
     });
 }
 
-fn rt_curr_spawn_many_remote_busy(c: &mut Criterion) {
+fn spawn_many_remote_busy(b: &mut Bencher) {
     let rt = rt();
     let rt_handle = rt.handle();
     let mut handles = Vec::with_capacity(NUM_SPAWN);
@@ -60,18 +56,16 @@ fn rt_curr_spawn_many_remote_busy(c: &mut Criterion) {
         iter()
     });
 
-    c.bench_function("spawn_many_remote_busy", |b| {
-        b.iter(|| {
-            for _ in 0..NUM_SPAWN {
-                handles.push(rt_handle.spawn(async {}));
-            }
+    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();
-                }
-            });
-        })
+        rt.block_on(async {
+            for handle in handles.drain(..) {
+                handle.await.unwrap();
+            }
+        });
     });
 }
 
@@ -79,11 +73,11 @@ fn rt() -> Runtime {
     runtime::Builder::new_current_thread().build().unwrap()
 }
 
-criterion_group!(
-    rt_curr_scheduler,
-    rt_curr_spawn_many_local,
-    rt_curr_spawn_many_remote_idle,
-    rt_curr_spawn_many_remote_busy
+benchmark_group!(
+    scheduler,
+    spawn_many_local,
+    spawn_many_remote_idle,
+    spawn_many_remote_busy
 );
 
-criterion_main!(rt_curr_scheduler);
+benchmark_main!(scheduler);

benches/rt_multi_threaded.rs

@@ -5,173 +5,114 @@
 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};
 
 const NUM_WORKERS: usize = 4;
 const NUM_SPAWN: usize = 10_000;
-const STALL_DUR: Duration = Duration::from_micros(10);
 
-fn rt_multi_spawn_many_local(c: &mut Criterion) {
+fn spawn_many_local(b: &mut Bencher) {
     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();
-                        }
-                    });
-                }
-
-                rx.recv().unwrap();
-            });
-        })
-    });
-}
-
-fn rt_multi_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 rt_multi_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 rt_multi_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 rt_multi_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 {
-                rx.recv().unwrap();
-            }
-        })
+            let _ = rx.recv().unwrap();
+        });
     });
 }
 
-fn rt_multi_ping_pong(c: &mut Criterion) {
+fn spawn_many_remote_idle(b: &mut Bencher) {
+    let rt = rt();
+
+    let mut handles = Vec::with_capacity(NUM_SPAWN);
+
+    b.iter(|| {
+        for _ in 0..NUM_SPAWN {
+            handles.push(rt.spawn(async {}));
+        }
+
+        rt.block_on(async {
+            for handle in handles.drain(..) {
+                handle.await.unwrap();
+            }
+        });
+    });
+}
+
+fn spawn_many_remote_busy(b: &mut Bencher) {
+    let rt = rt();
+    let rt_handle = rt.handle();
+    let mut handles = Vec::with_capacity(NUM_SPAWN);
+
+    // Spawn some tasks to keep the runtimes busy
+    for _ in 0..(2 * NUM_WORKERS) {
+        rt.spawn(async {
+            loop {
+                tokio::task::yield_now().await;
+                std::thread::sleep(std::time::Duration::from_micros(10));
+            }
+        });
+    }
+
+    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 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 +120,46 @@ fn rt_multi_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 rt_multi_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,21 +170,18 @@ fn rt_multi_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();
+        });
     });
 }
 
@@ -255,22 +193,14 @@ fn rt() -> Runtime {
         .unwrap()
 }
 
-fn stall() {
-    let now = Instant::now();
-    while now.elapsed() < STALL_DUR {
-        std::thread::yield_now();
-    }
-}
-
-criterion_group!(
-    rt_multi_scheduler,
-    rt_multi_spawn_many_local,
-    rt_multi_spawn_many_remote_idle,
-    rt_multi_spawn_many_remote_busy1,
-    rt_multi_spawn_many_remote_busy2,
-    rt_multi_ping_pong,
-    rt_multi_yield_many,
-    rt_multi_chained_spawn,
+benchmark_group!(
+    scheduler,
+    spawn_many_local,
+    spawn_many_remote_idle,
+    spawn_many_remote_busy,
+    ping_pong,
+    yield_many,
+    chained_spawn,
 );
 
-criterion_main!(rt_multi_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,82 +13,67 @@ async fn work() -> usize {
     black_box(val)
 }
 
-fn single_rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
+fn basic_scheduler_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
-        .unwrap()
+        .unwrap();
+    bench.iter(|| {
+        runtime.block_on(async {
+            let h = tokio::spawn(work());
+            assert_eq!(h.await.unwrap(), 2);
+        });
+    });
 }
 
-fn multi_rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
+fn basic_scheduler_spawn10(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
+    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(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
-        .unwrap()
-}
-
-fn basic_scheduler_spawn(c: &mut Criterion) {
-    let runtime = single_rt();
-
-    c.bench_function("basic_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
+        .unwrap();
+    bench.iter(|| {
+        runtime.block_on(async {
+            let h = tokio::spawn(work());
+            assert_eq!(h.await.unwrap(), 2);
+        });
     });
 }
 
-fn basic_scheduler_spawn10(c: &mut Criterion) {
-    let runtime = single_rt();
-
-    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);
-                }
-            });
-        })
+fn threaded_scheduler_spawn10(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+    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) {
-    let runtime = multi_rt();
-
-    c.bench_function("threaded_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
-    });
-}
-
-fn threaded_scheduler_spawn10(c: &mut Criterion) {
-    let runtime = multi_rt();
-
-    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);
-                }
-            });
-        })
-    });
-}
-
-criterion_group!(
+bencher::benchmark_group!(
     spawn,
     basic_scheduler_spawn,
     basic_scheduler_spawn10,
@@ -93,4 +81,4 @@ criterion_group!(
     threaded_scheduler_spawn10,
 );
 
-criterion_main!(spawn);
+bencher::benchmark_main!(spawn);

benches/spawn_blocking.rs

@@ -1,71 +0,0 @@
-//! Benchmark spawn_blocking at different concurrency levels on the multi-threaded scheduler.
-//!
-//! For each parallelism level N (1, 2, 4, 8, 16, 32, 64, capped at available parallelism):
-//! - Spawns N regular async tasks
-//! - Each task spawns M batches of B spawn_blocking tasks (no-ops)
-//! - Each batch is awaited to completion before starting the next
-
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use tokio::runtime::{self, Runtime};
-use tokio::task::JoinSet;
-
-/// Number of batches per task
-const NUM_BATCHES: usize = 100;
-/// Number of spawn_blocking calls per batch
-const BATCH_SIZE: usize = 16;
-
-fn spawn_blocking_concurrency(c: &mut Criterion) {
-    let max_parallelism = std::thread::available_parallelism().map_or(1, |p| p.get());
-
-    let parallelism_levels: Vec<usize> = [1, 2, 4, 8, 16, 32, 64]
-        .into_iter()
-        .filter(|&n| n <= max_parallelism)
-        .collect();
-
-    let mut group = c.benchmark_group("spawn_blocking");
-
-    for num_tasks in parallelism_levels {
-        group.bench_with_input(
-            BenchmarkId::new("concurrency", num_tasks),
-            &num_tasks,
-            |b, &num_tasks| {
-                let rt = rt();
-
-                b.iter(|| {
-                    rt.block_on(async {
-                        let mut tasks = JoinSet::new();
-
-                        for _ in 0..num_tasks {
-                            tasks.spawn(async {
-                                for _ in 0..NUM_BATCHES {
-                                    let mut batch = JoinSet::new();
-
-                                    for _ in 0..BATCH_SIZE {
-                                        batch.spawn_blocking(|| black_box(0));
-                                    }
-
-                                    batch.join_all().await;
-                                }
-                            });
-                        }
-
-                        tasks.join_all().await;
-                    });
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap()
-}
-
-criterion_group!(spawn_blocking_benches, spawn_blocking_concurrency);
-
-criterion_main!(spawn_blocking_benches);

benches/sync_broadcast.rs

@@ -1,82 +0,0 @@
-use rand::{Rng, RngCore, SeedableRng};
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-use tokio::sync::{broadcast, Notify};
-
-use criterion::measurement::WallTime;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkGroup, 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.random::<f64>());
-    }
-    message
-        .as_bytes()
-        .iter()
-        .map(|&c| c as u32)
-        .fold(0, u32::wrapping_add)
-}
-
-fn contention_impl<const N_TASKS: usize>(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    let (tx, _rx) = broadcast::channel::<usize>(1000);
-    let wg = Arc::new((AtomicUsize::new(0), Notify::new()));
-
-    for n in 0..N_TASKS {
-        let wg = wg.clone();
-        let mut rx = tx.subscribe();
-        let mut rng = rand::rngs::StdRng::seed_from_u64(n as u64);
-        rt.spawn(async move {
-            while (rx.recv().await).is_ok() {
-                let r = do_work(&mut rng);
-                let _ = black_box(r);
-                if wg.0.fetch_sub(1, Ordering::Relaxed) == 1 {
-                    wg.1.notify_one();
-                }
-            }
-        });
-    }
-
-    const N_ITERS: usize = 100;
-
-    g.bench_function(N_TASKS.to_string(), |b| {
-        b.iter(|| {
-            rt.block_on({
-                let wg = wg.clone();
-                let tx = tx.clone();
-                async move {
-                    for i in 0..N_ITERS {
-                        assert_eq!(wg.0.fetch_add(N_TASKS, Ordering::Relaxed), 0);
-                        tx.send(i).unwrap();
-                        while wg.0.load(Ordering::Relaxed) > 0 {
-                            wg.1.notified().await;
-                        }
-                    }
-                }
-            })
-        })
-    });
-}
-
-fn bench_contention(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention");
-    contention_impl::<10>(&mut group);
-    contention_impl::<100>(&mut group);
-    contention_impl::<500>(&mut group);
-    contention_impl::<1000>(&mut group);
-    group.finish();
-}
-
-criterion_group!(contention, bench_contention);
-
-criterion_main!(contention);

benches/sync_mpsc.rs

@@ -1,32 +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(#[allow(dead_code)] [usize; 64]);
-impl Default for Medium {
-    fn default() -> Self {
-        Medium([0; 64])
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-struct Large(#[allow(dead_code)] [Medium; 64]);
-impl Default for Large {
-    fn default() -> Self {
-        Large([Medium::default(); 64])
-    }
-}
-
-#[cfg(target_pointer_width = "64")]
-const ARRAY_CAP: usize = 32;
-
-#[cfg(not(target_pointer_width = "64"))]
-const ARRAY_CAP: usize = 16;
-
-const LIST_CAP: usize = ARRAY_CAP + 1;
-const ROUNDTRIP_ITERS: usize = 1_000;
+type Medium = [usize; 64];
+type Large = [Medium; 64];
 
 fn rt() -> tokio::runtime::Runtime {
     tokio::runtime::Builder::new_multi_thread()
@@ -35,365 +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 create_data<T, const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>, prefix: &str) {
-    g.bench_function(format!("{prefix}_{SIZE}"), |b| {
-        b.iter(|| {
-            black_box(mpsc::channel::<T>(SIZE));
-        })
+fn create_100_medium(b: &mut Bencher) {
+    b.iter(|| {
+        black_box(&mpsc::channel::<Medium>(100));
     });
 }
 
-fn send_data<T: Default, const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>, prefix: &str) {
+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 roundtrip_try_send_recv_data<T: Default, const SIZE: usize>(
-    g: &mut BenchmarkGroup<WallTime>,
-    prefix: &str,
-) {
-    let (tx, mut rx) = mpsc::channel::<T>(SIZE);
+fn send_large(b: &mut Bencher) {
+    let rt = rt();
 
-    g.bench_function(format!("{prefix}_{SIZE}"), |b| {
-        b.iter(|| {
-            for _ in 0..ROUNDTRIP_ITERS {
-                tx.try_send(T::default()).unwrap();
-                black_box(rx.try_recv().unwrap());
+    b.iter(|| {
+        let (tx, mut rx) = mpsc::channel::<Large>(1000);
+
+        let _ = rt.block_on(tx.send([[0; 64]; 64]));
+
+        rt.block_on(rx.recv()).unwrap();
+    });
+}
+
+fn contention_bounded(b: &mut Bencher) {
+    let rt = rt();
+
+    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..1_000 * 5 {
+                let _ = rx.recv().await;
             }
         })
     });
 }
 
-fn contention_bounded(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_bounded_full(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::channel::<usize>(100);
 
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
+            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_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_unbounded(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("bounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+    b.iter(|| {
+        rt.block_on(async move {
+            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
 
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
+            for _ in 0..5 {
+                let tx = tx.clone();
+                tokio::spawn(async move {
+                    for i in 0..1000 {
+                        tx.send(i).unwrap();
+                    }
+                });
+            }
 
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
+            for _ in 0..1_000 * 5 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
+fn uncontented_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 i in 0..5000 {
+                tx.send(i).await.unwrap();
+            }
 
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
+            for _ in 0..5_000 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn contention_bounded_full_recv_many(g: &mut BenchmarkGroup<WallTime>) {
+fn uncontented_unbounded(b: &mut Bencher) {
     let rt = rt();
 
-    g.bench_function("bounded_full_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(100);
+    b.iter(|| {
+        rt.block_on(async move {
+            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
 
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
+            for i in 0..5000 {
+                tx.send(i).unwrap();
+            }
 
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
+            for _ in 0..5_000 {
+                let _ = rx.recv().await;
+            }
         })
     });
 }
 
-fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).unwrap();
-                        }
-                    });
-                }
-
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).unwrap();
-                        }
-                    });
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-                for i in 0..5000 {
-                    tx.send(i).await.unwrap();
-                }
-
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-                for i in 0..5000 {
-                    tx.send(i).await.unwrap();
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for i in 0..5000 {
-                    tx.send(i).unwrap();
-                }
-
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for i in 0..5000 {
-                    tx.send(i).unwrap();
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn bench_create_medium(c: &mut Criterion) {
-    let mut group = c.benchmark_group("create_medium");
-    create_medium::<1>(&mut group);
-    create_medium::<100>(&mut group);
-    create_medium::<100_000>(&mut group);
-    group.finish();
-}
-
-fn bench_create_small(c: &mut Criterion) {
-    let mut group = c.benchmark_group("create_small");
-    create_data::<Medium, 1>(&mut group, "medium");
-    create_data::<Medium, 10>(&mut group, "medium");
-    create_data::<Medium, ARRAY_CAP>(&mut group, "medium");
-    create_data::<Medium, LIST_CAP>(&mut group, "medium");
-    create_data::<Large, 1>(&mut group, "large");
-    create_data::<Large, 10>(&mut group, "large");
-    create_data::<Large, ARRAY_CAP>(&mut group, "large");
-    create_data::<Large, LIST_CAP>(&mut group, "large");
-    group.finish();
-}
-
-fn bench_send(c: &mut Criterion) {
-    let mut group = c.benchmark_group("send");
-    send_data::<Medium, 1>(&mut group, "medium");
-    send_data::<Medium, 10>(&mut group, "medium");
-    send_data::<Medium, 1000>(&mut group, "medium");
-    send_data::<Large, 1>(&mut group, "large");
-    send_data::<Large, 10>(&mut group, "large");
-    send_data::<Large, 1000>(&mut group, "large");
-    group.finish();
-}
-
-fn bench_roundtrip_try_send_recv(c: &mut Criterion) {
-    let mut group = c.benchmark_group("roundtrip_try_send_recv");
-    roundtrip_try_send_recv_data::<Medium, 1>(&mut group, "medium");
-    roundtrip_try_send_recv_data::<Medium, 10>(&mut group, "medium");
-    roundtrip_try_send_recv_data::<Medium, ARRAY_CAP>(&mut group, "medium");
-    roundtrip_try_send_recv_data::<Medium, LIST_CAP>(&mut group, "medium");
-    group.finish();
-}
-
-fn bench_contention(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention");
-    contention_bounded(&mut group);
-    contention_bounded_recv_many(&mut group);
-    contention_bounded_full(&mut group);
-    contention_bounded_full_recv_many(&mut group);
-    contention_unbounded(&mut group);
-    contention_unbounded_recv_many(&mut group);
-    group.finish();
-}
-
-fn bench_uncontented(c: &mut Criterion) {
-    let mut group = c.benchmark_group("uncontented");
-    uncontented_bounded(&mut group);
-    uncontented_bounded_recv_many(&mut group);
-    uncontented_unbounded(&mut group);
-    uncontented_unbounded_recv_many(&mut group);
-    group.finish();
-}
-
-criterion_group!(create, bench_create_medium);
-criterion_group!(create_small, bench_create_small);
-criterion_group!(send, bench_send);
-criterion_group!(roundtrip_try_send_recv, bench_roundtrip_try_send_recv);
-criterion_group!(contention, bench_contention);
-criterion_group!(uncontented, bench_uncontented);
-
-criterion_main!(
+bencher::benchmark_group!(
     create,
-    create_small,
-    send,
-    roundtrip_try_send_recv,
-    contention,
-    uncontented
+    create_1_medium,
+    create_100_medium,
+    create_100_000_medium
 );
+
+bencher::benchmark_group!(send, send_medium, send_large);
+
+bencher::benchmark_group!(
+    contention,
+    contention_bounded,
+    contention_bounded_full,
+    contention_unbounded,
+    uncontented_bounded,
+    uncontented_unbounded
+);
+
+bencher::benchmark_main!(create, send, contention);

benches/sync_mpsc_oneshot.rs

@@ -1,28 +1,27 @@
+use bencher::{benchmark_group, benchmark_main, Bencher};
 use tokio::{
     runtime::Runtime,
     sync::{mpsc, oneshot},
 };
 
-use criterion::{criterion_group, criterion_main, Criterion};
-
-fn request_reply_current_thread(c: &mut Criterion) {
+fn request_reply_current_thread(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
 
-    request_reply(c, rt);
+    request_reply(b, rt);
 }
 
-fn request_reply_multi_threaded(c: &mut Criterion) {
+fn request_reply_multi_threaded(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
         .unwrap();
 
-    request_reply(c, rt);
+    request_reply(b, rt);
 }
 
-fn request_reply(b: &mut Criterion, rt: Runtime) {
+fn request_reply(b: &mut Bencher, rt: Runtime) {
     let tx = rt.block_on(async move {
         let (tx, mut rx) = mpsc::channel::<oneshot::Sender<()>>(10);
         tokio::spawn(async move {
@@ -33,24 +32,22 @@ fn request_reply(b: &mut Criterion, rt: Runtime) {
         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;
-                }
-            })
+    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!(
+benchmark_group!(
     sync_mpsc_oneshot_group,
     request_reply_current_thread,
     request_reply_multi_threaded,
 );
 
-criterion_main!(sync_mpsc_oneshot_group);
+benchmark_main!(sync_mpsc_oneshot_group);

benches/sync_notify.rs

@@ -1,11 +1,9 @@
+use bencher::Bencher;
 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)
@@ -13,7 +11,7 @@ fn rt() -> tokio::runtime::Runtime {
         .unwrap()
 }
 
-fn notify_waiters<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
+fn notify_waiters<const N_WAITERS: usize>(b: &mut Bencher) {
     let rt = rt();
     let notify = Arc::new(Notify::new());
     let counter = Arc::new(AtomicUsize::new(0));
@@ -31,20 +29,18 @@ fn notify_waiters<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     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;
-                }
+    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>) {
+fn notify_one<const N_WAITERS: usize>(b: &mut Bencher) {
     let rt = rt();
     let notify = Arc::new(Notify::new());
     let counter = Arc::new(AtomicUsize::new(0));
@@ -62,43 +58,33 @@ fn notify_one<const N_WAITERS: usize>(g: &mut BenchmarkGroup<WallTime>) {
     }
 
     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;
-                }
+    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!(
+bencher::benchmark_group!(
     notify_waiters_simple,
-    bench_notify_one,
-    bench_notify_waiters
+    notify_waiters::<10>,
+    notify_waiters::<50>,
+    notify_waiters::<100>,
+    notify_waiters::<200>,
+    notify_waiters::<500>
 );
 
-criterion_main!(notify_waiters_simple);
+bencher::benchmark_group!(
+    notify_one_simple,
+    notify_one::<10>,
+    notify_one::<50>,
+    notify_one::<100>,
+    notify_one::<200>,
+    notify_one::<500>
+);
+
+bencher::benchmark_main!(notify_waiters_simple, notify_one_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,11 +1,9 @@
+use bencher::{black_box, Bencher};
 use rand::prelude::*;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use tokio::sync::{watch, Notify};
 
-use criterion::measurement::WallTime;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
 fn rt() -> tokio::runtime::Runtime {
     tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
@@ -17,7 +15,7 @@ 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.random::<f64>());
+        let _ = write!(&mut message, " {i}={}", rng.gen::<f64>());
     }
     message
         .as_bytes()
@@ -26,15 +24,16 @@ fn do_work(rng: &mut impl RngCore) -> u32 {
         .fold(0, u32::wrapping_add)
 }
 
-fn contention_resubscribe<const N_TASKS: usize>(g: &mut BenchmarkGroup<WallTime>) {
+fn contention_resubscribe(b: &mut Bencher) {
+    const NTASK: u64 = 1000;
+
     let rt = rt();
-    let (snd, _) = watch::channel(0i32);
-    let snd = Arc::new(snd);
+    let (snd, rcv) = watch::channel(0i32);
     let wg = Arc::new((AtomicU64::new(0), Notify::new()));
-    for n in 0..N_TASKS {
-        let mut rcv = snd.subscribe();
+    for n in 0..NTASK {
+        let mut rcv = rcv.clone();
         let wg = wg.clone();
-        let mut rng = rand::rngs::StdRng::seed_from_u64(n as u64);
+        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
@@ -47,39 +46,19 @@ fn contention_resubscribe<const N_TASKS: usize>(g: &mut BenchmarkGroup<WallTime>
         });
     }
 
-    const N_ITERS: usize = 100;
-    g.bench_function(N_TASKS.to_string(), |b| {
-        b.iter(|| {
-            rt.block_on({
-                let snd = snd.clone();
-                let wg = wg.clone();
-                async move {
-                    tokio::spawn(async move {
-                        for _ in 0..N_ITERS {
-                            assert_eq!(wg.0.fetch_add(N_TASKS as u64, Ordering::Relaxed), 0);
-                            let _ = snd.send(black_box(42));
-                            while wg.0.load(Ordering::Acquire) > 0 {
-                                wg.1.notified().await;
-                            }
-                        }
-                    })
-                    .await
-                    .unwrap();
+    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;
                 }
-            });
-        })
+            }
+        });
     });
 }
 
-fn bench_contention_resubscribe(c: &mut Criterion) {
-    let mut group = c.benchmark_group("contention_resubscribe");
-    contention_resubscribe::<10>(&mut group);
-    contention_resubscribe::<100>(&mut group);
-    contention_resubscribe::<500>(&mut group);
-    contention_resubscribe::<1000>(&mut group);
-    group.finish();
-}
+bencher::benchmark_group!(contention, contention_resubscribe);
 
-criterion_group!(contention, bench_contention_resubscribe);
-
-criterion_main!(contention);
+bencher::benchmark_main!(contention);

benches/time_now.rs

@@ -2,23 +2,24 @@
 //! 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;
 
-fn time_now_current_thread(c: &mut Criterion) {
+use bencher::{black_box, Bencher};
+
+fn time_now_current_thread(bench: &mut Bencher) {
     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());
-            })
+    bench.iter(|| {
+        rt.block_on(async {
+            black_box(tokio::time::Instant::now());
         })
-    });
+    })
 }
 
-criterion_group!(time_now, time_now_current_thread);
+bencher::benchmark_group!(time_now, time_now_current_thread,);
 
-criterion_main!(time_now);
+bencher::benchmark_main!(time_now);

benches/time_timeout.rs

@@ -1,109 +0,0 @@
-use std::time::{Duration, Instant};
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use tokio::{
-    runtime::Runtime,
-    time::{sleep, timeout},
-};
-
-// a very quick async task, but might timeout
-async fn quick_job() -> usize {
-    1
-}
-
-fn build_run_time(workers: usize) -> Runtime {
-    if workers == 1 {
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap()
-    } else {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .worker_threads(workers)
-            .build()
-            .unwrap()
-    }
-}
-
-fn single_thread_scheduler_timeout(c: &mut Criterion) {
-    do_timeout_test(c, 1, "single_thread_timeout");
-}
-
-fn multi_thread_scheduler_timeout(c: &mut Criterion) {
-    do_timeout_test(c, 8, "multi_thread_timeout-8");
-}
-
-fn do_timeout_test(c: &mut Criterion, workers: usize, name: &str) {
-    let runtime = build_run_time(workers);
-    c.bench_function(name, |b| {
-        b.iter_custom(|iters| {
-            let start = Instant::now();
-            runtime.block_on(async {
-                black_box(spawn_timeout_job(iters as usize, workers)).await;
-            });
-            start.elapsed()
-        })
-    });
-}
-
-async fn spawn_timeout_job(iters: usize, procs: usize) {
-    let mut handles = Vec::with_capacity(procs);
-    for _ in 0..procs {
-        handles.push(tokio::spawn(async move {
-            for _ in 0..iters / procs {
-                let h = timeout(Duration::from_secs(1), quick_job());
-                assert_eq!(black_box(h.await.unwrap()), 1);
-            }
-        }));
-    }
-    for handle in handles {
-        handle.await.unwrap();
-    }
-}
-
-fn single_thread_scheduler_sleep(c: &mut Criterion) {
-    do_sleep_test(c, 1, "single_thread_sleep");
-}
-
-fn multi_thread_scheduler_sleep(c: &mut Criterion) {
-    do_sleep_test(c, 8, "multi_thread_sleep-8");
-}
-
-fn do_sleep_test(c: &mut Criterion, workers: usize, name: &str) {
-    let runtime = build_run_time(workers);
-
-    c.bench_function(name, |b| {
-        b.iter_custom(|iters| {
-            let start = Instant::now();
-            runtime.block_on(async {
-                black_box(spawn_sleep_job(iters as usize, workers)).await;
-            });
-            start.elapsed()
-        })
-    });
-}
-
-async fn spawn_sleep_job(iters: usize, procs: usize) {
-    let mut handles = Vec::with_capacity(procs);
-    for _ in 0..procs {
-        handles.push(tokio::spawn(async move {
-            for _ in 0..iters / procs {
-                let _h = black_box(sleep(Duration::from_secs(1)));
-            }
-        }));
-    }
-    for handle in handles {
-        handle.await.unwrap();
-    }
-}
-
-criterion_group!(
-    timeout_benchmark,
-    single_thread_scheduler_timeout,
-    multi_thread_scheduler_timeout,
-    single_thread_scheduler_sleep,
-    multi_thread_scheduler_sleep
-);
-
-criterion_main!(timeout_benchmark);

bin/publish

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+set -e
+USAGE="Publish a new release of a tokio crate
+
+USAGE:
+    $(basename "$0") [OPTIONS] [CRATE] [VERSION]
+
+OPTIONS:
+    -v, --verbose   Use verbose Cargo output
+    -d, --dry-run   Perform a dry run (do not publish or tag the release)
+    -h, --help      Show this help text and exit"
+
+DRY_RUN=""
+VERBOSE=""
+
+err() {
+    echo -e "\e[31m\e[1merror:\e[0m $@" 1>&2;
+}
+
+status() {
+    WIDTH=12
+    printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
+}
+
+verify() {
+    status "Verifying" "if $CRATE v$VERSION can be released"
+    ACTUAL=$(cargo pkgid | sed -n 's/.*#\(.*\)/\1/p')
+
+    if [ "$ACTUAL" != "$VERSION" ]; then
+        err "expected to release version $VERSION, but Cargo.toml contained $ACTUAL"
+        exit 1
+    fi
+
+    if git tag -l | grep -Fxq "$TAG" ; then
+        err "git tag \`$TAG\` already exists"
+        exit 1
+    fi
+
+    PATH_DEPS=$(grep -F "path = \"" Cargo.toml | sed -e 's/^/  /')
+    if [ -n "$PATH_DEPS" ]; then
+        err "crate \`$CRATE\` contained path dependencies:\n$PATH_DEPS"
+        echo "path dependencies must be removed prior to release"
+        exit 1
+    fi
+}
+
+release() {
+    status "Releasing" "$CRATE v$VERSION"
+    cargo package $VERBOSE
+    cargo publish $VERBOSE $DRY_RUN
+
+    status "Tagging" "$TAG"
+    if [ -n "$DRY_RUN" ]; then
+        echo "# git tag $TAG && git push --tags"
+    else
+        git tag "$TAG" && git push --tags
+    fi
+}
+
+while [[ $# -gt 0 ]]
+do
+
+case "$1" in
+    -h|--help)
+    echo "$USAGE"
+    exit 0
+    ;;
+    -v|--verbose)
+    VERBOSE="--verbose"
+    set +x
+    shift
+    ;;
+    -d|--dry-run)
+    DRY_RUN="--dry-run"
+    shift
+    ;;
+    -*)
+    err "unknown flag \"$1\""
+    echo "$USAGE"
+    exit 1
+    ;;
+    *) # crate or version
+    if [ -z "$CRATE" ]; then
+        CRATE="$1"
+    elif [ -z "$VERSION" ]; then
+        VERSION="$1"
+    else
+        err "unknown positional argument \"$1\""
+        echo "$USAGE"
+        exit 1
+    fi
+    shift
+    ;;
+esac
+done
+# set -- "${POSITIONAL[@]}"
+
+if [ -z "$VERSION" ]; then
+    err "no version specified!"
+    HELP=1
+fi
+
+if [ -n "$CRATE" ]; then
+    TAG="$CRATE-$VERSION"
+else
+    err "no crate specified!"
+    HELP=1
+fi
+
+if [ -n "$HELP" ]; then
+    echo "$USAGE"
+    exit 1
+fi
+
+if [ -d "$CRATE" ]; then
+    (cd "$CRATE" && verify && release )
+else
+    err "no such crate \"$CRATE\""
+    exit 1
+fi
+

bin/update-doc

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+set -e
+USAGE="Update links to docs.rs in a tokio crate
+
+USAGE:
+    $(basename "$0") [OPTIONS] [CRATE] [VERSION]
+
+OPTIONS:
+    -d, --dry-run       Perform a dry run (do not modify any file)
+    -h, --help          Show this help text and exit"
+
+err() {
+    echo -e "\e[31m\e[1merror:\e[0m $@" 1>&2;
+}
+
+status() {
+    WIDTH=12
+    printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
+}
+
+c1grep() { grep "$@" || test $? = 1; }
+
+update_versions_in_doc() {
+    # Print what is being/would be done
+    if [ -n "$DRY_RUN" ]; then
+        local MSG="Would change:"
+    else
+        local MSG="Updating:"
+    fi
+    git grep -lr "docs.rs/$CRATE/" \
+        | xargs sed --quiet \
+            -E "s|docs.rs/$CRATE/[0-9.]+|docs.rs/$CRATE/$VERSION|gp" \
+        | sed -e "s/^/$MSG /"
+
+    # Apply changes if not in dry run
+    if [ -z "$DRY_RUN" ]; then
+        git grep -lr "docs.rs/$CRATE/" \
+            | xargs sed -i \
+                -E "s|docs.rs/$CRATE/[0-9.]+|docs.rs/$CRATE/$VERSION|g"
+    fi
+}
+
+update() {
+    update_versions_in_doc
+}
+
+show_outdated() {
+    OUTDATED=$(git grep -rn "docs.rs/$CRATE/" \
+        | c1grep -v "$VERSION" \
+        | sed -e 's/^/ - /')
+    if [[ -n "$OUTDATED" ]]; then
+        echo "Found the following links to docs.rs with an outdated version:"
+        echo "$OUTDATED"
+        echo
+    else
+        echo "Nothing to do."
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]
+do
+
+case "$1" in
+    -h|--help)
+    echo "$USAGE"
+    exit 0
+    ;;
+    -d|--dry-run)
+    DRY_RUN="--dry-run"
+    shift
+    ;;
+    -*)
+    err "unknown flag \"$1\""
+    echo "$USAGE"
+    exit 1
+    ;;
+    *) # crate or version
+    if [ -z "$CRATE" ]; then
+        CRATE="$1"
+    elif [ -z "$VERSION" ]; then
+        VERSION="$1"
+    else
+        err "unknown positional argument \"$1\""
+        echo "$USAGE"
+        exit 1
+    fi
+    shift
+    ;;
+esac
+done
+# set -- "${POSITIONAL[@]}"
+
+if [ -z "$VERSION" ]; then
+    err "no version specified!"
+    HELP=1
+fi
+
+if [ -n "$CRATE" ]; then
+    TAG="$CRATE-$VERSION"
+else
+    err "no crate specified!"
+    HELP=1
+fi
+
+if [ -n "$HELP" ]; then
+    echo "$USAGE"
+    exit 1
+fi
+
+if [ -d "$CRATE" ]; then
+    # Does not cd in order to update everywhere
+    show_outdated && update
+else
+    err "no such crate \"$CRATE\""
+    exit 1
+fi
+

deny.toml

@@ -1,21 +0,0 @@
-# https://embarkstudios.github.io/cargo-deny/cli/init.html
-
-[graph]
-all-features = true
-
-[licenses]
-allow = [
-    "MIT",
-    "Apache-2.0",
-]
-exceptions = [
-    { allow = ["Unicode-3.0"], crate = "unicode-ident" },
-]
-
-[bans]
-multiple-versions = "allow"
-wildcards = "deny"
-
-[sources]
-unknown-registry = "deny"
-unknown-git = "deny"

docs/contributing/README.md

@@ -1,48 +0,0 @@
-# Contributing
-
-This guide will help you get started. **Do not let this guide intimidate you**.
-It should be considered a map to help you navigate the process.
-
-## Quick start
-
-If you are unsure where to begin, use the following guides:
-
-- Want to report or triage a bug? Start with [Contributing in Issues](contributing-in-issues.md).
-- Looking for something to work on? Check the open [`issues`](https://github.com/tokio-rs/tokio/issues)
-(some might be in progress or still under discussion, so leave a comment before starting the work).
-- Planning to submit a PR? Read [Pull Requests](pull-requests.md) for the full workflow and required checks.
-- Want to understand what the labels on issues mean? See [Keeping track of issues and PRs](keeping-track-of-issues-and-prs.md).
-- Interested in code review? See [Reviewing Pull Requests](reviewing-pull-requests.md).
-
-## Table of Contents
-
-- [Contributing in Issues](contributing-in-issues.md)
-    - [Asking for General Help](contributing-in-issues.md#asking-for-general-help)
-    - [Submitting a Bug Report](contributing-in-issues.md#submitting-a-bug-report)
-    - [Triaging a Bug Report](contributing-in-issues.md#triaging-a-bug-report)
-    - [Resolving a Bug Report](contributing-in-issues.md#resolving-a-bug-report)
-- [Pull Requests](pull-requests.md)
-    - [Step-by-Step Contribution Workflow](pull-requests.md#step-by-step-contribution-workflow)
-    - [Cargo Commands](pull-requests.md#cargo-commands)
-    - [Performing spellcheck on Tokio codebase](pull-requests.md#performing-spellcheck-on-tokio-codebase)
-    - [Tests](pull-requests.md#tests)
-        - [Integration tests](pull-requests.md#integration-tests)
-        - [Fuzz tests](pull-requests.md#fuzz-tests)
-        - [Documentation tests](pull-requests.md#documentation-tests)
-    - [Benchmarks](pull-requests.md#benchmarks)
-    - [Commits](pull-requests.md#commits)
-        - [Commit message guidelines](pull-requests.md#commit-message-guidelines)
-    - [Opening the Pull Request](pull-requests.md#opening-the-pull-request)
-    - [Discuss and update](pull-requests.md#discuss-and-update)
-    - [Commit Squashing](pull-requests.md#commit-squashing)
-- [Reviewing Pull Requests](reviewing-pull-requests.md)
-    - [Review a bit at a time](reviewing-pull-requests.md#review-a-bit-at-a-time)
-    - [Be aware of the person behind the code](reviewing-pull-requests.md#be-aware-of-the-person-behind-the-code)
-    - [Abandoned or Stalled Pull Requests](reviewing-pull-requests.md#abandoned-or-stalled-pull-requests)
-- [How to specify crates dependencies versions](how-to-specify-crates-dependencies-versions.md)
-- [Keeping track of issues and PRs](keeping-track-of-issues-and-prs.md)
-    - [Area](keeping-track-of-issues-and-prs.md#area)
-    - [Category](keeping-track-of-issues-and-prs.md#category)
-    - [Calls for participation](keeping-track-of-issues-and-prs.md#calls-for-participation)
-    - [Module](keeping-track-of-issues-and-prs.md#module)
-    - [Topic](keeping-track-of-issues-and-prs.md#topic)

docs/contributing/contributing-in-issues.md

@@ -1,79 +0,0 @@
-## Contributing in Issues
-
-For any issue, there are fundamentally three ways an individual can contribute:
-
-1. By opening the issue for discussion: For instance, if you believe that you
-   have discovered a bug in Tokio, creating a new issue in [the tokio-rs/tokio
-   issue tracker][issue] is the way to report it.
-
-2. By helping to triage the issue: This can be done by providing
-   supporting details (a test case that demonstrates a bug), providing
-   suggestions on how to address the issue, or ensuring that the issue is tagged
-   correctly.
-
-3. By helping to resolve the issue: Typically this is done either in the form of
-   demonstrating that the issue reported is not a problem after all, or more
-   often, by opening a Pull Request that changes some bit of something in
-   Tokio in a concrete and reviewable manner.
-
-[issue]: https://github.com/tokio-rs/tokio/issues
-
-**Anybody can participate in any stage of contribution**. We urge you to
-participate in the discussion around bugs and participate in reviewing PRs.
-
-### Asking for General Help
-
-If you have reviewed existing documentation and still have questions or are
-having problems, you can [open a discussion] asking for help.
-
-In exchange for receiving help, we ask that you contribute back a documentation
-PR that helps others avoid the problems that you encountered.
-
-[open a discussion]: https://github.com/tokio-rs/tokio/discussions/new/choose
-
-### Submitting a Bug Report
-
-When opening a new issue in the Tokio issue tracker, you will be presented
-with a basic template that should be filled in. If you believe that you have
-uncovered a bug, please fill out this form, following the template to the best
-of your ability. Do not worry if you cannot answer every detail, just fill in
-what you can.
-
-The two most important pieces of information we need in order to properly
-evaluate the report is a description of the behavior you are seeing and a simple
-test case we can use to recreate the problem on our own. If we cannot recreate
-the issue, it becomes impossible for us to fix.
-
-In order to rule out the possibility of bugs introduced by userland code, test
-cases should be limited, as much as possible, to using only Tokio APIs.
-
-See [How to create a Minimal, Complete, and Verifiable example][mcve].
-
-[mcve]: https://stackoverflow.com/help/mcve
-
-### Triaging a Bug Report
-
-Once an issue has been opened, it is not uncommon for there to be discussion
-around it. Some contributors may have differing opinions about the issue,
-including whether the behavior being seen is a bug or a feature. This discussion
-is part of the process and should be kept focused, helpful, and professional.
-
-Short, clipped responses—that provide neither additional context nor supporting
-detail—are not helpful or professional. To many, such responses are simply
-annoying and unfriendly.
-
-Contributors are encouraged to help one another make forward progress as much as
-possible, empowering one another to solve issues collaboratively. If you choose
-to comment on an issue that you feel either is not a problem that needs to be
-fixed, or if you encounter information in an issue that you feel is incorrect,
-explain why you feel that way with additional supporting context, and be willing
-to be convinced that you may be wrong. By doing so, we can often reach the
-correct outcome much faster.
-
-### Resolving a Bug Report
-
-In the majority of cases, issues are resolved by opening a Pull Request. The
-process for opening and reviewing a Pull Request is similar to that of opening
-and triaging issues, but carries with it a necessary review and approval
-workflow that ensures that the proposed changes meet the minimal quality and
-functional guidelines of the Tokio project.

docs/contributing/how-to-specify-crates-dependencies-versions.md

@@ -1,32 +0,0 @@
-# How to specify crates dependencies versions
-
-Each crate (e.g., `tokio-util`, `tokio-stream`, etc.) should specify dependencies
-according to the following rules:
-
-1. The listed version should be the oldest version that the crate works with
-(e.g., if `tokio-util` works with `tokio` version `1.44` but not `1.43`, then
-`tokio-util` should specify version `1.44` for its `tokio` dependency).
-We don't require users to use the latest version unnecessarily.
-2. When a crate starts using a newer feature in a dependency, the version
-should be bumped to the version that introduced it.
-3. If a crate depends on an unreleased feature in a dependency, it may use
-`path =` dependency to specify this. Since path dependencies must be removed
-during the release of the crate, this ensures that it can't be released until
-the dependency has a new version.
-
-Consider the following example from `tokio-stream`:
-
-```toml
-[dependencies]
-futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.11"
-tokio = { version = "1.38.0", path = "../tokio", features = ["sync"] }
-```
-
-In this case, local development of `tokio-stream` uses the local version
-of `tokio` via the `path` dependency. This means that it's currently not
-possible to release `tokio-stream`, and `tokio` should be released first.
-Once a new version of `tokio` is released (in this example the `1.38.0`),
-the path dependency should be removed.
-As mentioned before, this version should only be bumped when adding a new
-feature in the crate that relies on a newer version.

docs/contributing/keeping-track-of-issues-and-prs.md

@@ -1,91 +0,0 @@
-## Keeping track of issues and PRs
-
-The Tokio GitHub repository has a lot of issues and PRs to keep track of. This
-section explains the meaning of various labels, as well as our [GitHub
-project][project]. The section is primarily targeted at maintainers.  Most
-contributors aren't able to set these labels.
-
-### Area
-
-The area label describes the crates relevant to this issue or PR.
-
-- **A-ci** This issue concerns our GitHub Actions setup.
-- **A-tokio** This issue concerns the main Tokio crate.
-- **A-readme** This issue is related to documentation such as README.md.
-- **A-benches** This issue concerns the benchmarks.
-- **A-examples** This issue concerns the examples.
-- **A-tokio-test** The issue concerns the `tokio-test` crate.
-- **A-tokio-util** This issue concerns the `tokio-util` crate.
-- **A-tokio-macros** This issue concerns the `tokio-macros` crate. Should only
-  be used for the procedural macros, and not `join!` or `select!`.
-- **A-tokio-stream** This issue concerns the `tokio-stream` crate.
-
-### Category
-
-- **C-bug** This is a bug-report. Bug-fix PRs use `C-enhancement` instead.
-- **C-enhancement** This is a PR that adds a new features.
-- **C-maintenance** This is an issue or PR about stuff such as documentation,
-  GitHub Actions or code quality.
-- **C-feature-request** This is a feature request. Implementations of feature
-  requests use `C-enhancement` instead.
-- **C-feature-accepted** If you submit a PR for this feature request, we won't
-  close it with the reason "we don't want this". Issues with this label should
-  also have the `C-feature-request` label.
-- **C-musing** Stuff like tracking issues or roadmaps. "musings about a better
-  world"
-- **C-proposal** A proposal of some kind, and a request for comments.
-- **C-question** A user question. Large overlap with GitHub discussions.
-- **C-request** A non-feature request, e.g. "please add deprecation notices to
-  `-alpha.*` versions of crates"
-
-### Calls for participation
-
-- **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
-  or `C-feature-accepted`.
-- **E-easy** This is easy, ranging from quick documentation fixes to stuff you
-  can do after reading the tutorial on our website.
-- **E-medium** This is not `E-easy` or `E-hard`.
-- **E-hard** This either involves very tricky code, is something we don't know
-  how to solve, or is challenging for some other reason.
-- **E-needs-mvce** This bug is missing a minimal complete and verifiable
-  example.
-
-The "E-" prefix is the same as used in the Rust compiler repository. Some
-issues are missing a difficulty rating, but feel free to ask on our Discord
-server if you want to know how challenging an issue likely is.
-
-### Module
-
-The module label provides a more fine grained categorization than **Area**.
-
-- **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
-- **M-codec** The `tokio_util::codec` module.
-- **M-compat** The `tokio_util::compat` module.
-- **M-coop** Things relevant to coop.
-- **M-fs** The `tokio::fs` module.
-- **M-io** The `tokio::io` module.
-- **M-macros** Issues about any kind of macro.
-- **M-metrics** Things relevant to `tokio::runtime::metrics`.
-- **M-net** The `tokio::net` module.
-- **M-process** The `tokio::process` module.
-- **M-runtime** The `tokio::runtime` module.
-- **M-signal** The `tokio::signal` module.
-- **M-sync** The `tokio::sync` module.
-- **M-task** The `tokio::task` module.
-- **M-time** The `tokio::time` module.
-- **M-tracing** Tracing support in Tokio.
-- **M-taskdump** Things relevant to taskdump.
-
-### Topic
-
-Some extra information.
-
-- **T-docs** This is about documentation.
-- **T-io-uring** This is about io-uring (Linux).
-- **T-performance** This is about performance.
-- **T-v0.1.x** This is about old Tokio.
-- **T-wasm** This is about Web Assembly.
-
-Any label not listed here is not in active use.
-
-[project]: https://github.com/orgs/tokio-rs/projects/1

docs/contributing/pull-requests.md

@@ -1,409 +0,0 @@
-## Pull Requests
-
-Pull Requests are the way concrete changes are made to the code, documentation,
-and dependencies in the Tokio repository.
-
-Even tiny pull requests (e.g., one-character pull request fixing a typo in API
-documentation) are greatly appreciated.
-
-> [!NOTE]
-> Before making a large change, it is usually a good idea to first open an
-> issue describing the change to solicit feedback and guidance.
-> This will increase the likelihood of the PR getting merged.
-
-### Step-by-Step Contribution Workflow
-
-Once you've found an issue you'd like to work on, follow these steps before opening a Pull Request. This workflow provides a chronological overview of the contribution process and points to the relevant documentation where additional detail is available.
-
-#### 1. Fork and Clone the Repository
-
-Fork the repository to your GitHub account and clone your fork locally.
-
-If you've previously cloned the repository, ensure your local copy is up to date before creating a new branch.
-
-```bash
-git checkout master
-git pull upstream master
-```
-
----
-
-#### 2. Create a Feature Branch
-
-Never commit directly to your local `master` branch. Instead, create a descriptive feature branch for each change you work on.
-
-```bash
-git checkout -b my-feature
-```
-
-Using a dedicated branch keeps your default branch clean and makes it easier to update your Pull Request during code review.
-
----
-
-#### 3. Implement Your Changes
-
-Make the code or documentation changes needed. Check your work with `git diff` to confirm the changes look correct before moving on.
-
-If your changes introduce new functionality or modify existing behavior, consider whether additional tests or documentation should also be added.
-
----
-
-#### 4. Verify Your Changes
-
-Before opening a Pull Request, run the project's verification steps. Refer to the sections below for details on when each command should be used.
-
----
-
-#### 5. Commit and Push Your Changes
-
-Commit your changes following the [project's commit message guidelines](#commit-message-guidelines).
-
-```bash
-git add .
-git commit -m "module: describe your change"
-git push origin my-feature
-```
-
----
-
-#### 6. Open a Pull Request
-
-Open a Pull Request from your feature branch to the main repository. See [Opening the Pull Request](#opening-the-pull-request) for what to include and how the review process works.
-
-### Cargo Commands
-
-Due to the extensive use of features in Tokio, you will often need to add extra
-arguments to many common cargo commands. This section lists some commonly needed
-commands.
-
-Some commands just need the `--all-features` argument:
-
-```
-cargo build --all-features
-cargo check --all-features
-cargo test --all-features
-```
-
-> [!NOTE]
-> There are some features that are not available in some systems (e.g., `io-uring`
-> which is Linux only). In that case you cannot use the `--all-features` and you
-> should specify only the features that are supported (e.g., `--features=full`).
-
-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
-
-<!--
-When updating this, also update:
-- .github/workflows/ci.yml
-- README.md
-- tokio/README.md
-- tokio/Cargo.toml
-- tokio-util/Cargo.toml
-- tokio-test/Cargo.toml
-- tokio-stream/Cargo.toml
--->
-
-```
-cargo +1.88 clippy --all --tests --all-features
-```
-
-When building documentation, a simple `cargo doc` is not sufficient. To produce
-documentation equivalent to what will be produced in docs.rs's builds of Tokio's
-docs, please use:
-
-```
-RUSTDOCFLAGS="--cfg docsrs --cfg tokio_unstable" RUSTFLAGS="--cfg docsrs --cfg tokio_unstable" cargo +nightly doc --all-features [--open]
-```
-
-This turns on indicators to display the Cargo features required for
-conditionally compiled APIs in Tokio, and it enables documentation of unstable
-Tokio features. Notice that it is necessary to pass cfg flags to both RustDoc
-*and* rustc.
-
-There is a more concise way to build docs.rs-equivalent docs by using [`cargo
-docs-rs`], which reads the above documentation flags out of Tokio's Cargo.toml
-as docs.rs itself does.
-
-[`cargo docs-rs`]: https://github.com/dtolnay/cargo-docs-rs
-
-```
-cargo install --locked cargo-docs-rs
-cargo +nightly docs-rs [--open]
-```
-
-The `cargo fmt` command does not work on the Tokio codebase. You can use the
-command below instead:
-
-```
-# Mac or Linux
-rustfmt --check --edition 2021 $(git ls-files '*.rs')
-
-# Powershell
-Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2021 $_.FullName }
-```
-The `--check` argument prints the things that need to be fixed. If you remove
-it, `rustfmt` will update your files locally instead.
-
-You can run loom tests with
-```
-cd tokio # tokio crate in workspace
-LOOM_MAX_PREEMPTIONS=1 LOOM_MAX_BRANCHES=10000 RUSTFLAGS="--cfg loom -C debug_assertions" \
-    cargo test --lib --release --features full -- --test-threads=1 --nocapture
-```
-Additionally, you can also add `--cfg tokio_unstable` to the `RUSTFLAGS` environment variable to
-run loom tests that test unstable features.
-
-You can run miri tests with
-```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-strict-provenance" \
-    cargo +nightly miri test --features full --lib --tests
-```
-
-### Performing spellcheck on Tokio codebase
-
-You can perform a spell-check on the Tokio codebase. For details of how to use the spellcheck tool, feel free to visit
-https://github.com/drahnr/cargo-spellcheck
-```
-# First install the spell-check plugin
-cargo install --locked cargo-spellcheck
-
-# Then run the cargo spell check command
-cargo spellcheck check
-```
-
-If the command rejects a word, you should backtick the rejected word if it's code related. If not, the
-rejected word should be put into `spellcheck.dic` file.
-
-Note that when you add a word into the file, you should also update the first line which tells the spellcheck tool
-the total number of words included in the file
-
-### Tests
-
-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
-```
-
-#### Integration tests
-
-Integration tests go in the same crate as the code they are testing. Each sub
-crate should have a `dev-dependency` on `tokio` itself. This makes all Tokio
-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 --locked 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
-use the API. Documentation tests are run with `cargo test --doc`. This ensures
-that the example is correct and provides additional test coverage.
-
-The trick to documentation tests is striking a balance between being succinct
-for a reader to understand and actually testing the API.
-
-Same as with integration tests, when writing a documentation test, the full
-`tokio` crate is available. This is especially useful for getting access to the
-runtime to run the example.
-
-The documentation tests will be visible from both the crate-specific
-documentation **and** the `tokio` facade documentation via the re-export. The
-example should be written from the point of view of a user that is using the
-`tokio` crate. As such, the example should use the API via the facade and not by
-directly referencing the crate.
-
-The type level example for `tokio::time::timeout` provides a good example of a
-documentation test:
-
-```
-/// Create a new `Timeout` set to expire in 10 milliseconds.
-///
-/// ```rust
-/// use tokio::time::timeout;
-/// use tokio::sync::oneshot;
-///
-/// use std::time::Duration;
-///
-/// # async fn dox() {
-/// let (tx, rx) = oneshot::channel();
-/// # tx.send(()).unwrap();
-///
-/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds.
-/// if let Err(_) = timeout(Duration::from_millis(10), rx).await {
-///     println!("did not receive value within 10 ms");
-/// }
-/// # }
-/// ```
-```
-
-Lines that start with `/// #` are removed when the documentation is generated.
-
-### Benchmarks
-
-You can run benchmarks locally for the changes you've made to the tokio codebase.
-Tokio currently uses [Criterion](https://github.com/bheisler/criterion.rs) as its benchmarking tool. To run a benchmark
-against the changes you have made, for example, you can run;
-
-```bash
-cd benches
-
-# Run all benchmarks.
-cargo bench
-
-# Run all tests in the `benches/fs.rs` file
-cargo bench --bench fs
-
-# Run the `async_read_buf` benchmark in `benches/fs.rs` specifically.
-cargo bench async_read_buf
-
-# After running benches, you can check the statistics under `tokio/target/criterion/`
-```
-
-You can also refer to [Criterion] docs for additional options and details.
-
-[Criterion]: https://docs.rs/criterion/latest/criterion/
-
-### Commits
-
-It is a recommended best practice to keep your changes as logically grouped as
-possible within individual commits. There is no limit to the number of commits
-any single Pull Request may have, and many contributors find it easier to review
-changes that are split across multiple commits.
-
-That said, if you have a number of commits that are "checkpoints" and don't
-represent a single logical change, please squash those together.
-
-Note that multiple commits often get squashed when they are landed (see the
-notes about [commit squashing](#commit-squashing)).
-
-#### Commit message guidelines
-
-A good commit message should describe what changed and why.
-
-1. The first line should:
-
-* contain a short description of the change (preferably 50 characters or less,
-  and no more than 72 characters)
-* be entirely in lowercase with the exception of proper nouns, acronyms, and
-  the words that refer to code, like function/variable names
-* start with an imperative verb
-* not have a period at the end
-* be prefixed with the name of the module being changed; usually this is the
-  same as the M-* label on the PR
-
-Examples:
-
-* time: introduce `Timeout` and deprecate `Deadline`
-* codec: export `Encoder`, `Decoder`, `Framed*`
-* ci: fix the FreeBSD ci configuration
-
-2. Keep the second line blank.
-3. Wrap all other lines at 72 columns (except for long URLs).
-4. If your patch fixes an open issue, you can add a reference to it at the end
-   of the log. Use the `Fixes: #` prefix and the issue number. For other
-   references use `Refs: #`. `Refs` may include multiple issues, separated by a
-   comma.
-
-   Examples:
-
-    - `Fixes: #1337`
-    - `Refs: #1234`
-
-Sample complete commit message:
-
-```txt
-module: explain the commit in one line
-
-Body of commit message is a few lines of text, explaining things
-in more detail, possibly giving some background about the issue
-being fixed, etc.
-
-The body of the commit message can be several paragraphs, and
-please do proper word-wrap and keep columns shorter than about
-72 characters or so. That way, `git log` will show things
-nicely even when it is indented.
-
-Fixes: #1337
-Refs: #453, #154
-```
-
-### Opening the Pull Request
-
-From within GitHub, opening a new Pull Request will present you with a
-[template] that should be filled out. Please try to do your best at filling out
-the details, but feel free to skip parts if you're not sure what to put.
-
-[template]: ../../.github/PULL_REQUEST_TEMPLATE.md
-
-### Discuss and update
-
-You will probably get feedback or requests for changes to your Pull Request.
-This is a big part of the submission process so don't be discouraged! Some
-contributors may sign off on the Pull Request right away, others may have
-more detailed comments or feedback. This is a necessary part of the process
-in order to evaluate whether the changes are correct and necessary.
-
-**Any community member can review a PR and you might get conflicting feedback**.
-Keep an eye out for comments from code owners to provide guidance on conflicting
-feedback.
-
-**Once the PR is open, do not rebase the commits**. See [Commit Squashing](#commit-squashing) for
-more details.
-
-### Commit Squashing
-
-In most cases, **do not squash commits that you add to your Pull Request during
-the review process**. When the commits in your Pull Request land, they may be
-squashed into one commit per logical change. Metadata will be added to the
-commit message (including links to the Pull Request, links to relevant issues,
-and the names of the reviewers). The commit history of your Pull Request,
-however, will stay intact on the Pull Request page.
-
-[integration-tests]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
-[unit-tests]: https://doc.rust-lang.org/rust-by-example/testing/unit_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

docs/contributing/reviewing-pull-requests.md

@@ -1,80 +0,0 @@
-## Reviewing Pull Requests
-
-**Any Tokio community member is welcome to review any pull request**.
-
-All Tokio contributors who choose to review and provide feedback on Pull
-Requests have a responsibility to both the project and the individual making the
-contribution. Reviews and feedback must be helpful, insightful, and geared
-towards improving the contribution as opposed to simply blocking it. If there
-are reasons why you feel the PR should not land, explain what those are. Do not
-expect to be able to block a Pull Request from advancing simply because you say
-"No" without giving an explanation. Be open to having your mind changed. Be open
-to working with the contributor to make the Pull Request better.
-
-Reviews that are dismissive or disrespectful of the contributor or any other
-reviewers are strictly counter to the Code of Conduct.
-
-When reviewing a Pull Request, the primary goals are for the codebase to improve
-and for the person submitting the request to succeed. **Even if a Pull Request
-does not land, the submitters should come away from the experience feeling like
-their effort was not wasted or unappreciated**. Every Pull Request from a new
-contributor is an opportunity to grow the community.
-
-### Review a bit at a time
-
-Do not overwhelm new contributors.
-
-It is tempting to micro-optimize and make everything about relative performance,
-perfect grammar, or exact style matches. Do not succumb to that temptation.
-
-Focus first on the most significant aspects of the change:
-
-1. Does this change make sense for Tokio?
-2. Does this change make Tokio better, even if only incrementally?
-3. Are there clear bugs or larger scale issues that need attending to?
-4. Is the commit message readable and correct? If it contains a breaking change
-   is it clear enough?
-
-Note that only **incremental** improvement is needed to land a PR. This means
-that the PR does not need to be perfect, only better than the status quo. Follow
-up PRs may be opened to continue iterating.
-
-When changes are necessary, *request* them, do not *demand* them, and **do not
-assume that the submitter already knows how to add a test or run a benchmark**.
-
-Specific performance optimization techniques, coding styles and conventions
-change over time. The first impression you give to a new contributor never does.
-
-Nits (requests for small changes that are not essential) are fine, but try to
-avoid stalling the Pull Request. Most nits can typically be fixed by the Tokio
-Collaborator landing the Pull Request but they can also be an opportunity for
-the contributor to learn a bit more about the project.
-
-It is always good to clearly indicate nits when you comment: e.g.
-`Nit: change foo() to bar(). But this is not blocking.`
-
-If your comments were addressed but were not folded automatically after new
-commits or if they proved to be mistaken, please, [hide them][hiding-a-comment]
-with the appropriate reason to keep the conversation flow concise and relevant.
-
-### Be aware of the person behind the code
-
-Be aware that *how* you communicate requests and reviews in your feedback can
-have a significant impact on the success of the Pull Request. Yes, we may land
-a particular change that makes Tokio better, but the individual might just not
-want to have anything to do with Tokio ever again. The goal is not just having
-good code.
-
-### Abandoned or Stalled Pull Requests
-
-If a Pull Request appears to be abandoned or stalled, it is polite to first
-check with the contributor to see if they intend to continue the work before
-checking if they would mind if you took it over (especially if it just has nits
-left). When doing so, it is courteous to give the original contributor credit
-for the work they started (either by preserving their name and email address in
-the commit log, or by using an `Author: ` meta-data tag in the commit.
-
-_Adapted from the [Node.js contributing guide][node]_.
-
-[node]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
-[hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment

examples/Cargo.toml

@@ -2,8 +2,7 @@
 name = "examples"
 version = "0.0.0"
 publish = false
-edition = "2021"
-license = "MIT"
+edition = "2018"
 
 # If you copy one of the examples into a new project, you should be using
 # [dependencies] instead, and delete the **path**.
@@ -16,47 +15,34 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3.1", default-features = false, features = ["fmt", "ansi", "env-filter", "tracing-log"] }
 bytes = "1.0.0"
 futures = { version = "0.3.0", features = ["thread-pool"]}
-http = "1"
+http = "0.2"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 httparse = "1.0"
 httpdate = "1.0"
 once_cell = "1.5.2"
-
-[target.'cfg(target_os = "linux")'.dev-dependencies]
-libc = "0.2"
-
-[target.'cfg(all(tokio_unstable, target_os = "linux"))'.dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full", "tracing", "taskdump"] }
+rand = "0.8.3"
 
 [target.'cfg(windows)'.dev-dependencies.windows-sys]
-version = "0.61"
+version = "0.48"
 
 [[example]]
 name = "chat"
 path = "chat.rs"
 
 [[example]]
-name = "connect-tcp"
-path = "connect-tcp.rs"
-
-[[example]]
-name = "connect-udp"
-path = "connect-udp.rs"
-
-[[example]]
-name = "echo-tcp"
-path = "echo-tcp.rs"
-
-[[example]]
-name = "graceful-shutdown"
-path = "graceful-shutdown.rs"
+name = "connect"
+path = "connect.rs"
 
 [[example]]
 name = "echo-udp"
 path = "echo-udp.rs"
 
+[[example]]
+name = "echo"
+path = "echo.rs"
+
 [[example]]
 name = "hello_world"
 path = "hello_world.rs"
@@ -108,10 +94,3 @@ path = "named-pipe-multi-client.rs"
 [[example]]
 name = "dump"
 path = "dump.rs"
-
-[[example]]
-name = "prewarm-fd-table"
-path = "prewarm-fd-table.rs"
-
-[lints]
-workspace = true

examples/README.md

@@ -10,7 +10,7 @@ cargo run --example $name
 ```
 
 A good starting point for the examples would be [`hello_world`](hello_world.rs)
-and [`echo-tcp`](echo-tcp.rs). Additionally [the tokio website][tokioweb] contains
+and [`echo`](echo.rs). Additionally [the tokio website][tokioweb] contains
 additional guides for some of the examples.
 
 For a larger "real world" example, see the [`mini-redis`][redis] repository.

examples/chat.rs

@@ -39,8 +39,6 @@ use std::io;
 use std::net::SocketAddr;
 use std::sync::Arc;
 
-const DEFAULT_ADDR: &str = "127.0.0.1:6142";
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
@@ -72,14 +70,14 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let addr = env::args()
         .nth(1)
-        .unwrap_or_else(|| DEFAULT_ADDR.to_string());
+        .unwrap_or_else(|| "127.0.0.1:6142".to_string());
 
     // Bind a TCP listener to the socket address.
     //
     // Note that this is the Tokio TcpListener, which is fully async.
     let listener = TcpListener::bind(&addr).await?;
 
-    tracing::info!("server running on {addr}");
+    tracing::info!("server running on {}", addr);
 
     loop {
         // Asynchronously wait for an inbound TcpStream.
@@ -90,9 +88,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
         // Spawn our handler to be run asynchronously.
         tokio::spawn(async move {
-            tracing::debug!("accepted connection from {addr}");
+            tracing::debug!("accepted connection");
             if let Err(e) = process(state, stream, addr).await {
-                tracing::warn!("Connection from {addr} failed: {e:?}");
+                tracing::info!("an error occurred; error = {:?}", e);
             }
         });
     }
@@ -140,24 +138,12 @@ impl Shared {
 
     /// Send a `LineCodec` encoded message to every peer, except
     /// for the sender.
-    ///
-    /// This function also cleans up disconnected peers automatically.
     async fn broadcast(&mut self, sender: SocketAddr, message: &str) {
-        let mut failed_peers = Vec::new();
-        let message = message.to_string(); // Clone once for all sends
-
-        for (addr, tx) in self.peers.iter() {
-            if *addr != sender && tx.send(message.clone()).is_err() {
-                // Receiver has been dropped, mark for removal
-                failed_peers.push(*addr);
+        for peer in self.peers.iter_mut() {
+            if *peer.0 != sender {
+                let _ = peer.1.send(message.into());
             }
         }
-
-        // Clean up disconnected peers
-        for addr in failed_peers {
-            self.peers.remove(&addr);
-            tracing::debug!("Removed disconnected peer: {addr}");
-        }
     }
 }
 
@@ -192,10 +178,13 @@ async fn process(
     lines.send("Please enter your username:").await?;
 
     // Read the first line from the `LineCodec` stream to get the username.
-    let Some(Ok(username)) = lines.next().await else {
+    let username = match lines.next().await {
+        Some(Ok(line)) => line,
         // We didn't get a line so we return early here.
-        tracing::error!("Failed to get username from {addr}. Client disconnected.");
-        return Ok(());
+        _ => {
+            tracing::error!("Failed to get username from {}. Client disconnected.", addr);
+            return Ok(());
+        }
     };
 
     // Register our peer with state which internally sets up some channels.
@@ -204,8 +193,8 @@ async fn process(
     // A client has connected, let's let everyone know.
     {
         let mut state = state.lock().await;
-        let msg = format!("{username} has joined the chat");
-        tracing::info!("{msg}");
+        let msg = format!("{} has joined the chat", username);
+        tracing::info!("{}", msg);
         state.broadcast(addr, &msg).await;
     }
 
@@ -214,26 +203,24 @@ async fn process(
         tokio::select! {
             // A message was received from a peer. Send it to the current user.
             Some(msg) = peer.rx.recv() => {
-                if let Err(e) = peer.lines.send(&msg).await {
-                    tracing::error!("Failed to send message to {username}: {e:?}");
-                    break;
-                }
+                peer.lines.send(&msg).await?;
             }
             result = peer.lines.next() => match result {
                 // A message was received from the current user, we should
                 // broadcast this message to the other users.
                 Some(Ok(msg)) => {
                     let mut state = state.lock().await;
-                    let msg = format!("{username}: {msg}");
+                    let msg = format!("{}: {}", username, msg);
 
                     state.broadcast(addr, &msg).await;
                 }
                 // An error occurred.
                 Some(Err(e)) => {
                     tracing::error!(
-                        "an error occurred while processing messages for {username}; error = {e:?}"
+                        "an error occurred while processing messages for {}; error = {:?}",
+                        username,
+                        e
                     );
-                    break;
                 }
                 // The stream has been exhausted.
                 None => break,
@@ -247,8 +234,8 @@ async fn process(
         let mut state = state.lock().await;
         state.peers.remove(&addr);
 
-        let msg = format!("{username} has left the chat");
-        tracing::info!("{msg}");
+        let msg = format!("{} has left the chat", username);
+        tracing::info!("{}", msg);
         state.broadcast(addr, &msg).await;
     }
 

examples/connect-tcp.rs

@@ -1,73 +0,0 @@
-//! An example of hooking up stdin/stdout to a TCP stream.
-//!
-//! This example will connect to a socket address specified in the argument list
-//! and then forward all data read on stdin to the server, printing out all data
-//! received on stdout. Each line entered on stdin will be translated to a TCP
-//! packet which is then sent to the remote address.
-//!
-//! Note that this is not currently optimized for performance, especially
-//! around buffer management. Rather it's intended to show an example of
-//! working with a client.
-//!
-//! This example can be quite useful when interacting with the other examples in
-//! this repository! Many of them recommend running this as a simple "hook up
-//! stdin/stdout to a server" to get up and running.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::{stdin, stdout};
-use tokio::net::TcpStream;
-use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
-
-use bytes::Bytes;
-use futures::{future, Sink, SinkExt, Stream, StreamExt};
-use std::env;
-use std::error::Error;
-use std::net::SocketAddr;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Parse what address we're going to connect to
-    let args = env::args().skip(1).collect::<Vec<_>>();
-    let addr = args
-        .first()
-        .ok_or("this program requires at least one argument")?;
-    let addr = addr.parse::<SocketAddr>()?;
-
-    let stdin = FramedRead::new(stdin(), BytesCodec::new());
-    let stdin = stdin.map(|i| i.map(|bytes| bytes.freeze()));
-    let stdout = FramedWrite::new(stdout(), BytesCodec::new());
-
-    connect(&addr, stdin, stdout).await?;
-
-    Ok(())
-}
-
-pub async fn connect(
-    addr: &SocketAddr,
-    mut stdin: impl Stream<Item = Result<Bytes, std::io::Error>> + Unpin,
-    mut stdout: impl Sink<Bytes, Error = std::io::Error> + Unpin,
-) -> Result<(), Box<dyn Error>> {
-    let mut stream = TcpStream::connect(addr).await?;
-    let (r, w) = stream.split();
-    let mut sink = FramedWrite::new(w, BytesCodec::new());
-    // filter map Result<BytesMut, Error> stream into just a Bytes stream to match stdout Sink
-    // on the event of an Error, log the error and end the stream
-    let mut stream = FramedRead::new(r, BytesCodec::new())
-        .filter_map(|i| match i {
-            //BytesMut into Bytes
-            Ok(i) => future::ready(Some(i.freeze())),
-            Err(e) => {
-                eprintln!("failed to read from socket; error={e}");
-                future::ready(None)
-            }
-        })
-        .map(Ok);
-
-    tokio::select! {
-        r = sink.send_all(&mut stdin) => r?,
-        r = stdout.send_all(&mut stream) => r?,
-    }
-
-    Ok(())
-}

examples/connect-udp.rs

@@ -1,94 +0,0 @@
-//! An example of hooking up stdin/stdout to a UDP stream.
-//!
-//! This example will connect to a socket address specified in the argument list
-//! and then forward all data read on stdin to the server, printing out all data
-//! received on stdout. Each line entered on stdin will be translated to a UDP
-//! packet which is then sent to the remote address.
-//!
-//! Note that this is not currently optimized for performance, especially
-//! around buffer management. Rather it's intended to show an example of
-//! working with a client.
-//!
-//! This example can be quite useful when interacting with the other examples in
-//! this repository! Many of them recommend running this as a simple "hook up
-//! stdin/stdout to a server" to get up and running.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::{stdin, stdout};
-use tokio::net::UdpSocket;
-use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
-
-use bytes::Bytes;
-use futures::{Sink, SinkExt, Stream, StreamExt};
-use std::env;
-use std::error::Error;
-use std::net::SocketAddr;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Parse what address we're going to connect to
-    let args = env::args().skip(1).collect::<Vec<_>>();
-    let addr = args
-        .first()
-        .ok_or("this program requires at least one argument")?;
-    let addr = addr.parse::<SocketAddr>()?;
-
-    let stdin = FramedRead::new(stdin(), BytesCodec::new());
-    let stdin = stdin.map(|i| i.map(|bytes| bytes.freeze()));
-    let stdout = FramedWrite::new(stdout(), BytesCodec::new());
-
-    connect(&addr, stdin, stdout).await?;
-
-    Ok(())
-}
-
-pub async fn connect(
-    addr: &SocketAddr,
-    stdin: impl Stream<Item = Result<Bytes, std::io::Error>> + Unpin,
-    stdout: impl Sink<Bytes, Error = std::io::Error> + Unpin,
-) -> Result<(), Box<dyn Error>> {
-    // We'll bind our UDP socket to a local IP/port, but for now we
-    // basically let the OS pick both of those.
-    let bind_addr = if addr.ip().is_ipv4() {
-        "0.0.0.0:0"
-    } else {
-        "[::]:0"
-    };
-
-    let socket = UdpSocket::bind(&bind_addr).await?;
-    socket.connect(addr).await?;
-
-    tokio::select! {
-        r = send(stdin, &socket) => r?,
-        r = recv(stdout, &socket) => r?,
-    }
-
-    Ok(())
-}
-
-async fn send(
-    mut stdin: impl Stream<Item = Result<Bytes, std::io::Error>> + Unpin,
-    writer: &UdpSocket,
-) -> Result<(), std::io::Error> {
-    while let Some(item) = stdin.next().await {
-        let buf = item?;
-        writer.send(&buf[..]).await?;
-    }
-
-    Ok(())
-}
-
-async fn recv(
-    mut stdout: impl Sink<Bytes, Error = std::io::Error> + Unpin,
-    reader: &UdpSocket,
-) -> Result<(), std::io::Error> {
-    loop {
-        let mut buf = vec![0; 1024];
-        let n = reader.recv(&mut buf[..]).await?;
-
-        if n > 0 {
-            stdout.send(Bytes::copy_from_slice(&buf[..n])).await?;
-        }
-    }
-}

examples/connect.rs

@@ -0,0 +1,147 @@
+//! An example of hooking up stdin/stdout to either a TCP or UDP stream.
+//!
+//! This example will connect to a socket address specified in the argument list
+//! and then forward all data read on stdin to the server, printing out all data
+//! received on stdout. An optional `--udp` argument can be passed to specify
+//! that the connection should be made over UDP instead of TCP, translating each
+//! line entered on stdin to a UDP packet to be sent to the remote address.
+//!
+//! Note that this is not currently optimized for performance, especially
+//! around buffer management. Rather it's intended to show an example of
+//! working with a client.
+//!
+//! This example can be quite useful when interacting with the other examples in
+//! this repository! Many of them recommend running this as a simple "hook up
+//! stdin/stdout to a server" to get up and running.
+
+#![warn(rust_2018_idioms)]
+
+use futures::StreamExt;
+use tokio::io;
+use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
+
+use std::env;
+use std::error::Error;
+use std::net::SocketAddr;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    // Determine if we're going to run in TCP or UDP mode
+    let mut args = env::args().skip(1).collect::<Vec<_>>();
+    let tcp = match args.iter().position(|a| a == "--udp") {
+        Some(i) => {
+            args.remove(i);
+            false
+        }
+        None => true,
+    };
+
+    // Parse what address we're going to connect to
+    let addr = args
+        .first()
+        .ok_or("this program requires at least one argument")?;
+    let addr = addr.parse::<SocketAddr>()?;
+
+    let stdin = FramedRead::new(io::stdin(), BytesCodec::new());
+    let stdin = stdin.map(|i| i.map(|bytes| bytes.freeze()));
+    let stdout = FramedWrite::new(io::stdout(), BytesCodec::new());
+
+    if tcp {
+        tcp::connect(&addr, stdin, stdout).await?;
+    } else {
+        udp::connect(&addr, stdin, stdout).await?;
+    }
+
+    Ok(())
+}
+
+mod tcp {
+    use bytes::Bytes;
+    use futures::{future, Sink, SinkExt, Stream, StreamExt};
+    use std::{error::Error, io, net::SocketAddr};
+    use tokio::net::TcpStream;
+    use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
+
+    pub async fn connect(
+        addr: &SocketAddr,
+        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+    ) -> Result<(), Box<dyn Error>> {
+        let mut stream = TcpStream::connect(addr).await?;
+        let (r, w) = stream.split();
+        let mut sink = FramedWrite::new(w, BytesCodec::new());
+        // filter map Result<BytesMut, Error> stream into just a Bytes stream to match stdout Sink
+        // on the event of an Error, log the error and end the stream
+        let mut stream = FramedRead::new(r, BytesCodec::new())
+            .filter_map(|i| match i {
+                //BytesMut into Bytes
+                Ok(i) => future::ready(Some(i.freeze())),
+                Err(e) => {
+                    println!("failed to read from socket; error={}", e);
+                    future::ready(None)
+                }
+            })
+            .map(Ok);
+
+        match future::join(sink.send_all(&mut stdin), stdout.send_all(&mut stream)).await {
+            (Err(e), _) | (_, Err(e)) => Err(e.into()),
+            _ => Ok(()),
+        }
+    }
+}
+
+mod udp {
+    use bytes::Bytes;
+    use futures::{Sink, SinkExt, Stream, StreamExt};
+    use std::error::Error;
+    use std::io;
+    use std::net::SocketAddr;
+    use tokio::net::UdpSocket;
+
+    pub async fn connect(
+        addr: &SocketAddr,
+        stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+    ) -> Result<(), Box<dyn Error>> {
+        // We'll bind our UDP socket to a local IP/port, but for now we
+        // basically let the OS pick both of those.
+        let bind_addr = if addr.ip().is_ipv4() {
+            "0.0.0.0:0"
+        } else {
+            "[::]:0"
+        };
+
+        let socket = UdpSocket::bind(&bind_addr).await?;
+        socket.connect(addr).await?;
+
+        tokio::try_join!(send(stdin, &socket), recv(stdout, &socket))?;
+
+        Ok(())
+    }
+
+    async fn send(
+        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        writer: &UdpSocket,
+    ) -> Result<(), io::Error> {
+        while let Some(item) = stdin.next().await {
+            let buf = item?;
+            writer.send(&buf[..]).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn recv(
+        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+        reader: &UdpSocket,
+    ) -> Result<(), io::Error> {
+        loop {
+            let mut buf = vec![0; 1024];
+            let n = reader.recv(&mut buf[..]).await?;
+
+            if n > 0 {
+                stdout.send(Bytes::from(buf)).await?;
+            }
+        }
+    }
+}

examples/custom-executor-tokio-context.rs

@@ -23,7 +23,7 @@ fn main() {
 
     // Without the `HandleExt.wrap()` there would be a panic because there is
     // no timer running, since it would be referencing runtime r1.
-    rt1.block_on(rt2.wrap(async move {
+    let _ = rt1.block_on(rt2.wrap(async move {
         let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
         println!("addr: {:?}", listener.local_addr());
         tx.send(()).unwrap();

examples/dump.rs

@@ -1,98 +1,49 @@
-//! 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.
+//! This example demonstrates tokio's experimental taskdumping functionality.
 
 #[cfg(all(
     tokio_unstable,
+    tokio_taskdump,
     target_os = "linux",
-    any(
-        target_arch = "aarch64",
-        target_arch = "x86",
-        target_arch = "x86_64",
-        target_arch = "s390x"
-    )
+    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;
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    use std::hint::black_box;
 
     #[inline(never)]
-    async fn a(barrier: Arc<Barrier>) {
-        b(barrier).await
+    async fn a() {
+        black_box(b()).await
     }
 
     #[inline(never)]
-    async fn b(barrier: Arc<Barrier>) {
-        c(barrier).await
+    async fn b() {
+        black_box(c()).await
     }
 
     #[inline(never)]
-    async fn c(barrier: Arc<Barrier>) {
-        barrier.wait().await;
+    async fn c() {
+        black_box(tokio::task::yield_now()).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());
+    tokio::spawn(a());
+    tokio::spawn(b());
+    tokio::spawn(c());
 
-            // capture a dump, and print each trace
-            println!("{:-<80}", "");
-            if let Ok(dump) = timeout(Duration::from_secs(2), handle.dump()).await {
-                for task in dump.tasks().iter() {
-                    let id = task.id();
-                    let trace = task.trace();
-                    println!("TASK {id}:");
-                    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.");
-        }
+    let handle = tokio::runtime::Handle::current();
+    let dump = handle.dump();
+
+    for (i, task) in dump.tasks().iter().enumerate() {
+        let trace = task.trace();
+        println!("task {i} trace:");
+        println!("{trace}");
     }
-
-    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",
-        target_arch = "s390x"
-    )
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
 )))]
 fn main() {
     println!("task dumps are not available")

examples/echo-udp.rs

@@ -6,31 +6,9 @@
 //!
 //! and in another terminal you can run:
 //!
-//!     cargo run --example connect-udp 127.0.0.1:8080
+//!     cargo run --example connect -- --udp 127.0.0.1:8080
 //!
-//! Each line you type in to the `connect-udp` terminal should be echo'd back to you!
-//!
-//! # Binding to all interfaces
-//!
-//! By default this example binds to `127.0.0.1` so it is only reachable
-//! from the local machine.
-//!
-//! To listen on all interfaces instead:
-//!
-//! ```sh
-//! cargo run --example echo-udp -- 0.0.0.0:8080
-//! ```
-//!
-//! Binding to `0.0.0.0` exposes the server on all network interfaces.
-//! Only do this in trusted network environments.
-//!
-//! On multi-homed systems, a UDP socket bound to a wildcard address
-//! (`0.0.0.0` or `::`) cannot always send replies from the same local IP
-//! that received the packet. Replies may therefore originate from a
-//! different address than the client targeted. See [this Cloudflare blog
-//! post][udp-blog] for more details.
-//!
-//! [udp-blog]: https://blog.cloudflare.com/everything-you-ever-wanted-to-know-about-udp-sockets-but-were-afraid-to-ask-part-1
+//! Each line you type in to the `nc` terminal should be echo'd back to you!
 
 #![warn(rust_2018_idioms)]
 
@@ -60,7 +38,7 @@ impl Server {
             if let Some((size, peer)) = to_send {
                 let amt = socket.send_to(&buf[..size], &peer).await?;
 
-                println!("Echoed {amt}/{size} bytes to {peer}");
+                println!("Echoed {}/{} bytes to {}", amt, size, peer);
             }
 
             // If we're here then `to_send` is `None`, so we take a look for the

examples/echo.rs

@@ -9,14 +9,14 @@
 //!
 //! To see this server in action, you can run this in one terminal:
 //!
-//!     cargo run --example echo-tcp
+//!     cargo run --example echo
 //!
 //! and in another terminal you can run:
 //!
-//!     cargo run --example connect-tcp 127.0.0.1:8080
+//!     cargo run --example connect 127.0.0.1:8080
 //!
-//! Each line you type in to the `connect-tcp` terminal should be echo'd back to
-//! you! If you open up multiple terminals running the `connect-tcp` example you
+//! Each line you type in to the `connect` terminal should be echo'd back to
+//! you! If you open up multiple terminals running the `connect` example you
 //! should be able to see them all make progress simultaneously.
 
 #![warn(rust_2018_idioms)]
@@ -27,9 +27,6 @@ use tokio::net::TcpListener;
 use std::env;
 use std::error::Error;
 
-const DEFAULT_ADDR: &str = "127.0.0.1:8080";
-const BUFFER_SIZE: usize = 4096;
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     // Allow passing an address to listen on as the first argument of this
@@ -37,17 +34,17 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // 127.0.0.1:8080 for connections.
     let addr = env::args()
         .nth(1)
-        .unwrap_or_else(|| DEFAULT_ADDR.to_string());
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
     // Next up we create a TCP listener which will listen for incoming
     // connections. This TCP listener is bound to the address we determined
     // above and must be associated with an event loop.
     let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {addr}");
+    println!("Listening on: {}", addr);
 
     loop {
         // Asynchronously wait for an inbound socket.
-        let (mut socket, addr) = listener.accept().await?;
+        let (mut socket, _) = listener.accept().await?;
 
         // And this is where much of the magic of this server happens. We
         // crucially want all clients to make progress concurrently, rather than
@@ -58,27 +55,23 @@ async fn main() -> Result<(), Box<dyn Error>> {
         // which will allow all of our clients to be processed concurrently.
 
         tokio::spawn(async move {
-            let mut buf = vec![0; BUFFER_SIZE];
+            let mut buf = vec![0; 1024];
 
             // In a loop, read data from the socket and write the data back.
             loop {
-                match socket.read(&mut buf).await {
-                    Ok(0) => {
-                        // Connection closed by peer
-                        return;
-                    }
-                    Ok(n) => {
-                        // Write the data back. If writing fails, log the error and exit.
-                        if let Err(e) = socket.write_all(&buf[0..n]).await {
-                            eprintln!("Failed to write to socket {}: {}", addr, e);
-                            return;
-                        }
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to read from socket {}: {}", addr, e);
-                        return;
-                    }
+                let n = socket
+                    .read(&mut buf)
+                    .await
+                    .expect("failed to read data from socket");
+
+                if n == 0 {
+                    return;
                 }
+
+                socket
+                    .write_all(&buf[0..n])
+                    .await
+                    .expect("failed to write data to socket");
             }
         });
     }

examples/graceful-shutdown.rs

@@ -1,120 +0,0 @@
-//! Graceful shutdown example.
-//!
-//! This example follows the same approach described in the
-//! [Graceful Shutdown tutorial](https://tokio.rs/tokio/topics/shutdown):
-//!
-//! - A [`CancellationToken`] tells tasks to stop accepting new work.
-//! - A [`TaskTracker`] waits for in-flight work to complete.
-//!
-//! It runs a TCP echo server on `127.0.0.1:6142`. When Ctrl+C is
-//! pressed, the server stops accepting connections and waits for all
-//! active connections to finish before exiting.
-//!
-//! Start the server:
-//!
-//!     cargo run --example graceful-shutdown
-//!
-//! Then connect with:
-//!
-//!     nc 127.0.0.1 6142
-//!
-//! Press Ctrl+C on the server to trigger a graceful shutdown.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use tokio::net::{TcpListener, TcpStream};
-use tokio::time::{self, Duration};
-use tokio_util::sync::CancellationToken;
-use tokio_util::task::TaskTracker;
-
-use std::error::Error;
-use std::net::SocketAddr;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let listener = TcpListener::bind("127.0.0.1:6142").await?;
-    println!("listening on 127.0.0.1:6142");
-
-    let token = CancellationToken::new();
-    let tracker = TaskTracker::new();
-
-    loop {
-        tokio::select! {
-            result = listener.accept() => {
-                let (socket, addr) = match result {
-                    Ok(conn) => conn,
-                    Err(e) => {
-                        // Transient errors (e.g. fd exhaustion) are recoverable,
-                        // so we log and continue. A production server might add a
-                        // backoff or break on fatal errors to avoid a busy loop.
-                        eprintln!("failed to accept: {e}");
-                        continue;
-                    }
-                };
-                println!("accepted connection from {addr}");
-
-                let token = token.clone();
-                tracker.spawn(handle_connection(socket, addr, token));
-            }
-
-            _ = tokio::signal::ctrl_c() => {
-                println!("\nshutdown signal received, waiting for connections to finish");
-                break;
-            }
-        }
-    }
-
-    // Signal all tasks to stop and wait for them to complete.
-    token.cancel();
-    tracker.close();
-    tracker.wait().await;
-
-    println!("shutdown complete");
-    Ok(())
-}
-
-async fn handle_connection(mut socket: TcpStream, addr: SocketAddr, token: CancellationToken) {
-    tokio::select! {
-        _ = echo(&mut socket) => {}
-        _ = token.cancelled() => {
-            notify_shutdown(&mut socket).await;
-        }
-    }
-
-    println!("connection from {addr} closed");
-}
-
-/// Reads lines from the client and writes them back.
-///
-/// Called for every accepted connection. Runs until the client disconnects
-/// or a read/write error occurs.
-async fn echo(socket: &mut TcpStream) {
-    let (reader, mut writer) = socket.split();
-    let mut reader = BufReader::new(reader);
-    let mut line = String::new();
-
-    loop {
-        match reader.read_line(&mut line).await {
-            Ok(0) | Err(_) => return,
-            Ok(_) => {
-                if writer.write_all(line.as_bytes()).await.is_err() {
-                    return;
-                }
-                line.clear();
-            }
-        }
-    }
-}
-
-/// Sends a shutdown notice to the client before closing the connection.
-///
-/// Called when the cancellation token fires. Uses a timeout so that a
-/// slow or unresponsive client cannot hold up the server shutdown.
-async fn notify_shutdown(socket: &mut TcpStream) {
-    let _ = time::timeout(
-        Duration::from_secs(1),
-        socket.write_all(b"server shutting down\n"),
-    )
-    .await;
-}

examples/prewarm-fd-table.rs

@@ -1,86 +0,0 @@
-//! Demonstrates pre-warming the Linux file descriptor table to avoid latency
-//! spikes caused by file descriptor table growth in multi-threaded processes.
-//!
-//! On Linux, the kernel's FD table is grown lazily and protected by RCU
-//! synchronization. In multi-threaded processes, when a syscall like `socket()`
-//! triggers a table resize, the calling thread blocks until all RCU readers
-//! quiesce. This can cause stalls of tens of milliseconds on tokio worker threads,
-//! blocking the entire event loop (not just one task).
-//!
-//! The workaround is to force the kernel to expand the FD table once per process
-//! (before any runtime starts), by duplicating an FD to a high slot and then
-//! closing it. The kernel never shrinks the FD table during a process's lifetime,
-//! so the capacity persists.
-//!
-//! This is most relevant for services that open many connections concurrently
-//! (e.g. HTTP servers, connection pools). The pre-warm target should be at least
-//! your expected peak FD count, and must not exceed `RLIMIT_NOFILE`.
-//!
-//! See: <https://github.com/tokio-rs/tokio/issues/7970>
-//!
-//! Usage:
-//!
-//!     cargo run --example prewarm-fd-table
-
-#![warn(rust_2018_idioms)]
-
-/// Pre-warms the FD table using `fcntl(F_DUPFD_CLOEXEC)` to duplicate an FD
-/// into a high slot, expanding the table in a single syscall. `F_DUPFD_CLOEXEC`
-/// allocates the lowest available FD >= `target`, so it never clobbers an
-/// existing FD.
-#[cfg(target_os = "linux")]
-fn prewarm_fd_table(target: i32) -> std::io::Result<()> {
-    use std::os::unix::io::{FromRawFd, OwnedFd};
-
-    let dev_null = std::fs::File::open("/dev/null")?;
-    let raw = unsafe {
-        libc::fcntl(
-            std::os::unix::io::AsRawFd::as_raw_fd(&dev_null),
-            libc::F_DUPFD_CLOEXEC,
-            target,
-        )
-    };
-    if raw < 0 {
-        return Err(std::io::Error::last_os_error());
-    }
-
-    // Close both FDs. The table capacity persists.
-    let _owned = unsafe { OwnedFd::from_raw_fd(raw) };
-    drop(dev_null);
-
-    Ok(())
-}
-
-/// Fully safe alternative using only stdlib. Requires O(n) syscalls instead of
-/// one, but avoids `unsafe` entirely.
-#[cfg(target_os = "linux")]
-#[allow(dead_code)]
-fn prewarm_fd_table_safe(target: i32) -> std::io::Result<()> {
-    let f = std::fs::File::open("/dev/null")?;
-    let _fds: Vec<_> = (0..target)
-        .map(|_| f.try_clone())
-        .collect::<Result<_, _>>()?;
-    Ok(())
-}
-
-fn main() {
-    #[cfg(target_os = "linux")]
-    {
-        const FD_TARGET: i32 = 10_000;
-
-        println!("Pre-warming FD table to {FD_TARGET} entries...");
-        if let Err(e) = prewarm_fd_table(FD_TARGET) {
-            eprintln!("Warning: failed to pre-warm FD table: {e}");
-        } else {
-            println!("FD table pre-warmed successfully.");
-        }
-    }
-
-    // Build the runtime *after* pre-warming.
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap();
-
-    rt.block_on(async {});
-}

examples/print_each_packet.rs

@@ -13,9 +13,9 @@
 //!
 //! and in another terminal you can run:
 //!
-//!     cargo run --example connect-tcp 127.0.0.1:8080
+//!     cargo run --example connect 127.0.0.1:8080
 //!
-//! Each line you type in to the `connect-tcp` terminal should be written to terminal!
+//! Each line you type in to the `connect` terminal should be written to terminal!
 //!
 //! Minimal js example:
 //!
@@ -75,7 +75,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // to our event loop. After the socket's created we inform that we're ready
     // to go and start accepting connections.
     let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {addr}");
+    println!("Listening on: {}", addr);
 
     loop {
         // Asynchronously wait for an inbound socket.
@@ -96,8 +96,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             // The stream will return None once the client disconnects.
             while let Some(message) = framed.next().await {
                 match message {
-                    Ok(bytes) => println!("bytes: {bytes:?}"),
-                    Err(err) => println!("Socket closed with error: {err:?}"),
+                    Ok(bytes) => println!("bytes: {:?}", bytes),
+                    Err(err) => println!("Socket closed with error: {:?}", err),
                 }
             }
             println!("Socket received FIN packet and closed connection");

examples/proxy.rs

@@ -11,20 +11,22 @@
 //!
 //! This in another terminal
 //!
-//!     cargo run --example echo-tcp
+//!     cargo run --example echo
 //!
 //! And finally this in another terminal
 //!
-//!     cargo run --example connect-tcp 127.0.0.1:8081
+//!     cargo run --example connect 127.0.0.1:8081
 //!
 //! This final terminal will connect to our proxy, which will in turn connect to
 //! the echo server, and you'll be able to see data flowing between them.
 
 #![warn(rust_2018_idioms)]
 
-use tokio::io::copy_bidirectional;
+use tokio::io;
+use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 
+use futures::FutureExt;
 use std::env;
 use std::error::Error;
 
@@ -37,28 +39,41 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .nth(2)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
-    println!("Listening on: {listen_addr}");
-    println!("Proxying to: {server_addr}");
+    println!("Listening on: {}", listen_addr);
+    println!("Proxying to: {}", server_addr);
 
     let listener = TcpListener::bind(listen_addr).await?;
 
-    while let Ok((mut inbound, _)) = listener.accept().await {
-        let server_addr = server_addr.clone();
-
-        tokio::spawn(async move {
-            let mut outbound = match TcpStream::connect(server_addr).await {
-                Ok(outbound) => outbound,
-                Err(e) => {
-                    println!("Failed to connect; error={e}");
-                    return;
-                }
-            };
-
-            if let Err(e) = copy_bidirectional(&mut inbound, &mut outbound).await {
-                println!("Failed to transfer; error={e}");
+    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/tinydb.rs

@@ -12,14 +12,14 @@
 //!
 //! and next in another windows run:
 //!
-//!     cargo run --example connect-tcp 127.0.0.1:8080
+//!     cargo run --example connect 127.0.0.1:8080
 //!
-//! In the `connect-tcp` window you can type in commands where when you hit enter
+//! In the `connect` window you can type in commands where when you hit enter
 //! you'll get a response from the server for that command. An example session
 //! is:
 //!
 //!
-//!     $ cargo run --example connect-tcp 127.0.0.1:8080
+//!     $ cargo run --example connect 127.0.0.1:8080
 //!     GET foo
 //!     foo = bar
 //!     GET FOOBAR
@@ -90,7 +90,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
     let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {addr}");
+    println!("Listening on: {}", addr);
 
     // Create the shared state of this server that will be shared amongst all
     // clients. We populate the initial database and then create the `Database`
@@ -131,11 +131,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
                                 let response = response.serialize();
 
                                 if let Err(e) = lines.send(response.as_str()).await {
-                                    println!("error on sending response; error = {e:?}");
+                                    println!("error on sending response; error = {:?}", e);
                                 }
                             }
                             Err(e) => {
-                                println!("error on decoding from socket; error = {e:?}");
+                                println!("error on decoding from socket; error = {:?}", e);
                             }
                         }
                     }
@@ -143,7 +143,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                     // The connection will be closed at this point as `lines.next()` has returned `None`.
                 });
             }
-            Err(e) => println!("error accepting socket; error = {e:?}"),
+            Err(e) => println!("error accepting socket; error = {:?}", e),
         }
     }
 }
@@ -162,7 +162,7 @@ fn handle_request(line: &str, db: &Arc<Database>) -> Response {
                 value: value.clone(),
             },
             None => Response::Error {
-                msg: format!("no key {key}"),
+                msg: format!("no key {}", key),
             },
         },
         Request::Set { key, value } => {
@@ -203,7 +203,7 @@ impl Request {
                     value: value.to_string(),
                 })
             }
-            Some(cmd) => Err(format!("unknown command: {cmd}")),
+            Some(cmd) => Err(format!("unknown command: {}", cmd)),
             None => Err("empty input".into()),
         }
     }
@@ -212,13 +212,13 @@ impl Request {
 impl Response {
     fn serialize(&self) -> String {
         match *self {
-            Response::Value { ref key, ref value } => format!("{key} = {value}"),
+            Response::Value { ref key, ref value } => format!("{} = {}", key, value),
             Response::Set {
                 ref key,
                 ref value,
                 ref previous,
-            } => format!("set {key} = `{value}`, previous: {previous:?}"),
-            Response::Error { ref msg } => format!("error: {msg}"),
+            } => format!("set {} = `{}`, previous: {:?}", key, value, previous),
+            Response::Error { ref msg } => format!("error: {}", msg),
         }
     }
 }

examples/tinyhttp.rs

@@ -18,7 +18,7 @@ use futures::SinkExt;
 use http::{header::HeaderValue, Request, Response, StatusCode};
 #[macro_use]
 extern crate serde_derive;
-use std::{env, error::Error, fmt, io};
+use std::{convert::TryFrom, env, error::Error, fmt, io};
 use tokio::net::{TcpListener, TcpStream};
 use tokio_stream::StreamExt;
 use tokio_util::codec::{Decoder, Encoder, Framed};
@@ -31,13 +31,13 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .nth(1)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
     let server = TcpListener::bind(&addr).await?;
-    println!("Listening on: {addr}");
+    println!("Listening on: {}", addr);
 
     loop {
         let (stream, _) = server.accept().await?;
         tokio::spawn(async move {
             if let Err(e) = process(stream).await {
-                println!("failed to process connection; error = {e}");
+                println!("failed to process connection; error = {}", e);
             }
         });
     }
@@ -82,7 +82,9 @@ async fn respond(req: Request<()>) -> Result<Response<String>, Box<dyn Error>> {
             String::new()
         }
     };
-    let response = response.body(body).map_err(io::Error::other)?;
+    let response = response
+        .body(body)
+        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
 
     Ok(response)
 }
@@ -157,8 +159,8 @@ impl Decoder for Http {
             let mut parsed_headers = [httparse::EMPTY_HEADER; 16];
             let mut r = httparse::Request::new(&mut parsed_headers);
             let status = r.parse(src).map_err(|e| {
-                let msg = format!("failed to parse http request: {e:?}");
-                io::Error::other(msg)
+                let msg = format!("failed to parse http request: {:?}", e);
+                io::Error::new(io::ErrorKind::Other, msg)
             })?;
 
             let amt = match status {
@@ -178,7 +180,8 @@ impl Decoder for Http {
                 headers[i] = Some((k, v));
             }
 
-            let method = http::Method::try_from(r.method.unwrap()).map_err(io::Error::other)?;
+            let method = http::Method::try_from(r.method.unwrap())
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
             (
                 method,
@@ -188,7 +191,10 @@ impl Decoder for Http {
             )
         };
         if version != 1 {
-            return Err(io::Error::other("only HTTP/1.1 accepted"));
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "only HTTP/1.1 accepted",
+            ));
         }
         let data = src.split_to(amt).freeze();
         let mut ret = Request::builder();
@@ -203,11 +209,13 @@ impl Decoder for Http {
                 None => break,
             };
             let value = HeaderValue::from_bytes(data.slice(v.0..v.1).as_ref())
-                .map_err(|_| io::Error::other("header decode error"))?;
+                .map_err(|_| io::Error::new(io::ErrorKind::Other, "header decode error"))?;
             ret = ret.header(&data[k.0..k.1], value);
         }
 
-        let req = ret.body(()).map_err(io::Error::other)?;
+        let req = ret
+            .body(())
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
         Ok(Some(req))
     }
 }
@@ -251,11 +259,11 @@ mod date {
         unix_date: u64,
     }
 
-    thread_local!(static LAST: RefCell<LastRenderedNow> = const { RefCell::new(LastRenderedNow {
+    thread_local!(static LAST: RefCell<LastRenderedNow> = RefCell::new(LastRenderedNow {
         bytes: [0; 128],
         amt: 0,
         unix_date: 0,
-    }) });
+    }));
 
     impl fmt::Display for Now {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -264,7 +272,8 @@ mod date {
                 let now = SystemTime::now();
                 let now_unix = now
                     .duration_since(SystemTime::UNIX_EPOCH)
-                    .map_or(0, |since_epoch| since_epoch.as_secs());
+                    .map(|since_epoch| since_epoch.as_secs())
+                    .unwrap_or(0);
                 if cache.unix_date != now_unix {
                     cache.update(now, now_unix);
                 }

examples/udp-codec.rs

@@ -46,7 +46,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Run both futures simultaneously of `a` and `b` sending messages back and forth.
     match tokio::try_join!(a, b) {
-        Err(e) => println!("an error occurred; error = {e:?}"),
+        Err(e) => println!("an error occurred; error = {:?}", e),
         _ => println!("done!"),
     }
 

netlify.toml

@@ -9,10 +9,7 @@
     --cfg docsrs \
     --cfg tokio_unstable \
     """
-  RUSTFLAGS="""
-    --cfg docsrs \
-    --cfg tokio_unstable
-    """
+  RUSTFLAGS="--cfg tokio_unstable --cfg docsrs"
 
 [[redirects]]
   from = "/"

spellcheck.dic

@@ -1,328 +0,0 @@
-327
-&
-+
-<
-=
->
-\
-~
-—
-0o777
-0s
-0xA
-0xD
-100ms
-100ns
-10ms
-10μs
-~12
-120s
-12.5%
-±1m
-±1ms
-1ms
-1s
-25%
-250ms
-2x
-~4
-443
-450ms
-50ms
-8MB
-ABI
-accessors
-adaptor
-adaptors
-Adaptors
-AIO
-ambient
-amongst
-api
-APIs
-async
-atomics
-awaitable
-backend
-backpressure
-backtrace
-backtraces
-backtracing
-binded
-bitfield
-bitfields
-Blockingly
-boolean
-broadcasted
-cancelled
-cancelling
-Cancelling
-CLI
-cloneable
-codebase
-codec
-codecs
-combinator
-combinators
-condvar
-config
-Config
-connectionless
-coroutines
-cpu
-cpus
-cqe
-CQE
-cqe's
-customizable
-Customizable
-Cygwin
-datagram
-Datagram
-datagrams
-deallocate
-deallocated
-Deallocates
-debuginfo
-decrement
-decrementing
-demangled
-dequeued
-dereferenced
-derefs
-deregister
-deregistered
-deregistering
-deregisters
-Deregisters
-deregistration
-descriptor's
-destructor
-destructors
-destructure
-Destructures
-Dev
-dns
-DNS
-DoS
-dwOpenMode
-endian
-enqueue
-enqueued
-EntryInner
-enum
-eof
-Erlang's
-errored
-EWMA
-expirations
-fcntl
-fd
-fd's
-FIFOs
-filename
-filesystem
-filesystems
-fn
-fns
-FreeBSD
-frontend
-fs
-functionalities
-getters
-GID
-goroutines
-Growable
-gzip
-H2
-hashmaps
-HashMaps
-hashsets
-HdrHistogram
-ICMP
-ie
-iff
-Illumos
-impl
-implementers
-implementor
-implementors
-incrementing
-inlining
-interoperate
-invariants
-Invariants
-io
-IOCP
-iOS
-IOs
-io_uring
-IP
-IPv4
-IPv6
-iteratively
-Kotlin's
-latencies
-Lauck
-libc
-lifecycle
-lifo
-LLVM
-lookups
-macOS
-MacOS
-Marsaglia's
-metadata
-mio
-Mio
-mio's
-miri
-misconfigured
-mock's
-monomorphization
-mpmc
-mpsc
-multi
-Multi
-multicast
-Multithreaded
-mut
-mutex
-Mutex
-Nagle
-namespace
-NetBSD
-nonblocking
-nondecreasing
-noop
-ntasks
-NTO
-NUMA
-ok
-oneshot
-opcode
-OpenBSD
-ORed
-os
-parker
-parsers
-peekable
-PGID
-PID
-plaintext
-poller
-POSIX
-proxied
-qos
-RAII
-RCU
-reallocations
-recv's
-Redox
-refactors
-refcount
-refcounting
-repo
-repr
-representable
-reqwest
-reregistering
-resize
-resized
-RMW
-RNG
-runtime
-runtime's
-runtimes
-rwlock
-rx
-scalability
-scheduler's
-semver
-setpgid
-sharded
-signalled
-signalling
-SmallCrush
-Solaris
-spawner
-spawners
-Splitter
-spmc
-spsc
-SQE
-src
-stabilised
-startup
-stateful
-stderr
-stdin
-stdout
-stealable
-stealer
-stealers
-struct
-structs
-subfield
-suboptimal
-subprocess
-superset
-symlink
-symlinks
-sys
-syscall
-syscalls
-tcp
-TCP
-TestU01
-threadpool
-timestamp
-timestamps
-TLS
-TOCTOU
-TODO
-tokio
-Tokio
-tokio's
-Tokio's
-tuple
-Tuple
-tvOS
-tx
-udp
-UDP
-UID
-unhandled
-unix
-unlink
-unpark
-Unpark
-unparked
-unparking
-unparks
-Unparks
-unreceived
-unsafety
-unsets
-Unsets
-unsynchronized
-untrusted
-uring
-usecases
-Valgrind
-Varghese
-vec
-versa
-versioned
-versioning
-visionOS
-vtable
-waker
-wakers
-Wakers
-wakeup
-wakeups
-WASI
-watchOS
-workstealing
-ZST

spellcheck.toml

@@ -1,13 +0,0 @@
-dev_comments = false
-skip_readme = false
-
-[Hunspell]
-lang = "en_US"
-search_dirs = ["."]
-extra_dictionaries = ["spellcheck.dic"]
-skip_os_lookups = true
-use_builtin = true
-
-[Hunspell.quirks]
-allow_concatenation = true
-

stress-test/Cargo.toml

@@ -2,17 +2,13 @@
 name = "stress-test"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
-license = "MIT"
+edition = "2018"
 publish = false
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tokio = { version = "1.0.0", path = "../tokio/", features = ["full"] }
+tokio = { path = "../tokio/", features = ["full"] }
 
 [dev-dependencies]
-rand = "0.9"
-
-[lints]
-workspace = true
+rand = "0.8"

stress-test/examples/simple_echo_tcp.rs

@@ -42,7 +42,7 @@ fn main() {
                 .write_all(one_mega_random_bytes.as_slice())
                 .await
                 .unwrap();
-            let _ = stream.read(&mut buff).await.unwrap();
+            stream.read(&mut buff).await.unwrap();
         }
         tx.send(()).unwrap();
     });

target-specs/README.md

@@ -1,9 +0,0 @@
-This is used for the `no-atomic-u64-test` ci check that verifies that Tokio
-works even if the `AtomicU64` type is missing.
-
-When increasing the nightly compiler version, you may need to regenerate this
-target using the following command:
-```
-rustc +nightly -Z unstable-options --print target-spec-json --target i686-unknown-linux-gnu | grep -v 'is-builtin' | sed 's/"max-atomic-width": 64/"max-atomic-width": 32/' > target-specs/i686-unknown-linux-gnu.json
-```
-

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

@@ -1,37 +1,29 @@
 {
   "arch": "x86",
   "cpu": "pentium4",
-  "crt-objects-fallback": "false",
   "crt-static-respected": true,
-  "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128",
-  "default-uwtable": 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,
-  "linker-flavor": "gnu-cc",
   "llvm-target": "i686-unknown-linux-gnu",
   "max-atomic-width": 32,
-  "metadata": {
-    "description": "32-bit Linux (kernel 3.2, glibc 2.17+)",
-    "host_tools": true,
-    "std": true,
-    "tier": 1
-  },
   "os": "linux",
   "position-independent-executables": true,
   "pre-link-args": {
-    "gnu-cc": [
-      "-m32"
-    ],
-    "gnu-lld-cc": [
+    "gcc": [
       "-m32"
     ]
   },
   "relro-level": "full",
-  "rustc-abi": "x86-sse2",
   "stack-probes": {
-    "kind": "inline"
+    "kind": "inline-or-call",
+    "min-llvm-version-for-inline": [
+      16,
+      0,
+      0
+    ]
   },
   "supported-sanitizers": [
     "address"
@@ -44,5 +36,5 @@
   "target-family": [
     "unix"
   ],
-  "target-pointer-width": 32
+  "target-pointer-width": "32"
 }

tests-build/Cargo.toml

@@ -2,8 +2,7 @@
 name = "tests-build"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
-license = "MIT"
+edition = "2018"
 publish = false
 
 [features]
@@ -11,10 +10,7 @@ full = ["tokio/full"]
 rt = ["tokio/rt", "tokio/macros"]
 
 [dependencies]
-tokio = { version = "1.0.0", path = "../tokio", optional = true }
+tokio = { path = "../tokio", optional = true }
 
 [dev-dependencies]
 trybuild = "1.0"
-
-[lints]
-workspace = true

tests-build/README.md

@@ -6,5 +6,5 @@ To run all of the tests in this directory, run the following commands:
 cargo test --features full
 cargo test --features rt
 ```
-If any of the tests fail, you can pass `TRYBUILD=overwrite` to the `cargo test`
+If one of the tests fail, you can pass `TRYBUILD=overwrite` to the `cargo test`
 command that failed to have it regenerate the test output.

tests-build/tests/fail/macros_invalid_input.rs

@@ -41,34 +41,8 @@ async fn test_crate_not_path_int() {}
 #[tokio::test(crate = "456")]
 async fn test_crate_not_path_invalid() {}
 
-#[tokio::test(flavor = "multi_thread", unhandled_panic = "shutdown_runtime")]
-async fn test_multi_thread_with_unhandled_panic() {}
-
 #[tokio::test]
 #[test]
 async fn test_has_second_test_attr() {}
 
-#[tokio::test]
-#[::core::prelude::v1::test]
-async fn test_has_second_test_attr_v1() {}
-
-#[tokio::test]
-#[core::prelude::rust_2015::test]
-async fn test_has_second_test_attr_rust_2015() {}
-
-#[tokio::test]
-#[::std::prelude::rust_2018::test]
-async fn test_has_second_test_attr_rust_2018() {}
-
-#[tokio::test]
-#[std::prelude::rust_2021::test]
-async fn test_has_second_test_attr_rust_2021() {}
-
-#[tokio::test]
-#[tokio::test]
-async fn test_has_generated_second_test_attr() {}
-
-#[tokio::test(name = 123)]
-async fn test_name_not_string() {}
-
 fn main() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -1,127 +1,95 @@
 error: the `async` keyword is missing from the function declaration
- --> tests/fail/macros_invalid_input.rs:6:1
+ --> $DIR/macros_invalid_input.rs:6:1
   |
 6 | fn main_is_not_async() {}
   | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`, `name`.
- --> tests/fail/macros_invalid_input.rs:8:15
+error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
+ --> $DIR/macros_invalid_input.rs:8:15
   |
 8 | #[tokio::main(foo)]
   |               ^^^
 
 error: Must have specified ident
-  --> tests/fail/macros_invalid_input.rs:11:15
+  --> $DIR/macros_invalid_input.rs:11:15
    |
 11 | #[tokio::main(threadpool::bar)]
    |               ^^^^^^^^^^^^^^^
 
 error: the `async` keyword is missing from the function declaration
-  --> tests/fail/macros_invalid_input.rs:15:1
+  --> $DIR/macros_invalid_input.rs:15:1
    |
 15 | fn test_is_not_async() {}
    | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`, `name`.
-  --> tests/fail/macros_invalid_input.rs:17:15
+error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
+  --> $DIR/macros_invalid_input.rs:17:15
    |
 17 | #[tokio::test(foo)]
    |               ^^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`, `name`.
-  --> tests/fail/macros_invalid_input.rs:20:15
+error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
+  --> $DIR/macros_invalid_input.rs:20:15
    |
 20 | #[tokio::test(foo = 123)]
    |               ^^^^^^^^^
 
 error: Failed to parse value of `flavor` as string.
-  --> tests/fail/macros_invalid_input.rs:23:24
+  --> $DIR/macros_invalid_input.rs:23:24
    |
 23 | #[tokio::test(flavor = 123)]
    |                        ^^^
 
-error: No such runtime flavor `foo`. The runtime flavors are `current_thread`, `local`, and `multi_thread`.
-  --> tests/fail/macros_invalid_input.rs:26:24
+error: No such runtime flavor `foo`. The runtime flavors are `current_thread` and `multi_thread`.
+  --> $DIR/macros_invalid_input.rs:26:24
    |
 26 | #[tokio::test(flavor = "foo")]
    |                        ^^^^^
 
 error: The `start_paused` option requires the `current_thread` runtime flavor. Use `#[tokio::test(flavor = "current_thread")]`
-  --> tests/fail/macros_invalid_input.rs:29:55
+  --> $DIR/macros_invalid_input.rs:29:55
    |
 29 | #[tokio::test(flavor = "multi_thread", start_paused = false)]
    |                                                       ^^^^^
 
 error: Failed to parse value of `worker_threads` as integer.
-  --> tests/fail/macros_invalid_input.rs:32:57
+  --> $DIR/macros_invalid_input.rs:32:57
    |
 32 | #[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
    |                                                         ^^^^^
 
 error: The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[tokio::test(flavor = "multi_thread")]`
-  --> tests/fail/macros_invalid_input.rs:35:59
+  --> $DIR/macros_invalid_input.rs:35:59
    |
 35 | #[tokio::test(flavor = "current_thread", worker_threads = 4)]
    |                                                           ^
 
 error: Failed to parse value of `crate` as path.
-  --> tests/fail/macros_invalid_input.rs:38:23
+  --> $DIR/macros_invalid_input.rs:38:23
    |
 38 | #[tokio::test(crate = 456)]
    |                       ^^^
 
 error: Failed to parse value of `crate` as path: "456"
-  --> tests/fail/macros_invalid_input.rs:41:23
+  --> $DIR/macros_invalid_input.rs:41:23
    |
 41 | #[tokio::test(crate = "456")]
    |                       ^^^^^
 
-error: The `unhandled_panic` option requires the `current_thread` runtime flavor. Use `#[tokio::test(flavor = "current_thread")]`
-  --> tests/fail/macros_invalid_input.rs:44:58
+error: second test attribute is supplied
+  --> $DIR/macros_invalid_input.rs:45:1
    |
-44 | #[tokio::test(flavor = "multi_thread", unhandled_panic = "shutdown_runtime")]
-   |                                                          ^^^^^^^^^^^^^^^^^^
-
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:48:1
-   |
-48 | #[test]
+45 | #[test]
    | ^^^^^^^
 
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:52:1
+error: duplicated attribute
+  --> $DIR/macros_invalid_input.rs:45:1
    |
-52 | #[::core::prelude::v1::test]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:56:1
+45 | #[test]
+   | ^^^^^^^
    |
-56 | #[core::prelude::rust_2015::test]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:60:1
+note: the lint level is defined here
+  --> $DIR/macros_invalid_input.rs:1:9
    |
-60 | #[::std::prelude::rust_2018::test]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:64:1
-   |
-64 | #[std::prelude::rust_2021::test]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: second test attribute is supplied, consider removing or changing the order of your test attributes
-  --> tests/fail/macros_invalid_input.rs:67:1
-   |
-67 | #[tokio::test]
-   | ^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the attribute macro `tokio::test` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: Failed to parse value of `name` as string.
-  --> tests/fail/macros_invalid_input.rs:71:22
-   |
-71 | #[tokio::test(name = 123)]
-   |                      ^^^
+1  | #![deny(duplicate_macro_attributes)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^

tests-build/tests/fail/macros_join.rs

@@ -1,42 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() {
-    // do not leak `RotatorSelect`
-    let _ = tokio::join!(async {
-        fn foo(_: impl RotatorSelect) {}
-    });
-
-    // do not leak `std::task::Poll::Pending`
-    let _ = tokio::join!(async { Pending });
-
-    // do not leak `std::task::Poll::Ready`
-    let _ = tokio::join!(async { Ready(0) });
-
-    // do not leak `std::future::Future`
-    let _ = tokio::join!(async {
-        struct MyFuture;
-
-        impl Future for MyFuture {
-            type Output = ();
-
-            fn poll(
-                self: std::pin::Pin<&mut Self>,
-                _cx: &mut std::task::Context<'_>,
-            ) -> std::task::Poll<Self::Output> {
-                todo!()
-            }
-        }
-    });
-
-    // do not leak `std::pin::Pin`
-    let _ = tokio::join!(async {
-        let mut x = 5;
-        let _ = Pin::new(&mut x);
-    });
-
-    // do not leak `std::future::poll_fn`
-    let _ = tokio::join!(async {
-        let _ = poll_fn(|_cx| todo!());
-    });
-}

tests-build/tests/fail/macros_join.stderr

@@ -1,60 +0,0 @@
-error[E0405]: cannot find trait `RotatorSelect` in this scope
- --> tests/fail/macros_join.rs:7:24
-  |
-7 |         fn foo(_: impl RotatorSelect) {}
-  |                        ^^^^^^^^^^^^^ not found in this scope
-
-error[E0425]: cannot find value `Pending` in this scope
-  --> tests/fail/macros_join.rs:11:34
-   |
-11 |     let _ = tokio::join!(async { Pending });
-   |                                  ^^^^^^^ not found in this scope
-   |
-help: consider importing this unit variant
-   |
- 1 + use std::task::Poll::Pending;
-   |
-
-error[E0425]: cannot find function, tuple struct or tuple variant `Ready` in this scope
-  --> tests/fail/macros_join.rs:14:34
-   |
-14 |     let _ = tokio::join!(async { Ready(0) });
-   |                                  ^^^^^ not found in this scope
-   |
-help: consider importing this tuple variant
-   |
- 1 + use std::task::Poll::Ready;
-   |
-
-error[E0405]: cannot find trait `Future` in this scope
-  --> tests/fail/macros_join.rs:20:14
-   |
-20 |         impl Future for MyFuture {
-   |              ^^^^^^ not found in this scope
-   |
-help: consider importing this trait
-   |
- 1 + use std::future::Future;
-   |
-
-error[E0433]: cannot find type `Pin` in this scope
-  --> tests/fail/macros_join.rs:35:17
-   |
-35 |         let _ = Pin::new(&mut x);
-   |                 ^^^ use of undeclared type `Pin`
-   |
-help: consider importing this struct
-   |
- 1 + use std::pin::Pin;
-   |
-
-error[E0425]: cannot find function `poll_fn` in this scope
-  --> tests/fail/macros_join.rs:40:17
-   |
-40 |         let _ = poll_fn(|_cx| todo!());
-   |                 ^^^^^^^ not found in this scope
-   |
-help: consider importing this function
-   |
- 1 + use std::future::poll_fn;
-   |

tests-build/tests/fail/macros_try_join.rs

@@ -1,42 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() {
-    // do not leak `RotatorSelect`
-    let _ = tokio::try_join!(async {
-        fn foo(_: impl RotatorSelect) {}
-    });
-
-    // do not leak `std::task::Poll::Pending`
-    let _ = tokio::try_join!(async { Pending });
-
-    // do not leak `std::task::Poll::Ready`
-    let _ = tokio::try_join!(async { Ready(0) });
-
-    // do not leak `std::future::Future`
-    let _ = tokio::try_join!(async {
-        struct MyFuture;
-
-        impl Future for MyFuture {
-            type Output = ();
-
-            fn poll(
-                self: std::pin::Pin<&mut Self>,
-                _cx: &mut std::task::Context<'_>,
-            ) -> std::task::Poll<Self::Output> {
-                todo!()
-            }
-        }
-    });
-
-    // do not leak `std::pin::Pin`
-    let _ = tokio::try_join!(async {
-        let mut x = 5;
-        let _ = Pin::new(&mut x);
-    });
-
-    // do not leak `std::future::poll_fn`
-    let _ = tokio::try_join!(async {
-        let _ = poll_fn(|_cx| todo!());
-    });
-}

tests-build/tests/fail/macros_try_join.stderr

@@ -1,60 +0,0 @@
-error[E0405]: cannot find trait `RotatorSelect` in this scope
- --> tests/fail/macros_try_join.rs:7:24
-  |
-7 |         fn foo(_: impl RotatorSelect) {}
-  |                        ^^^^^^^^^^^^^ not found in this scope
-
-error[E0425]: cannot find value `Pending` in this scope
-  --> tests/fail/macros_try_join.rs:11:38
-   |
-11 |     let _ = tokio::try_join!(async { Pending });
-   |                                      ^^^^^^^ not found in this scope
-   |
-help: consider importing this unit variant
-   |
- 1 + use std::task::Poll::Pending;
-   |
-
-error[E0425]: cannot find function, tuple struct or tuple variant `Ready` in this scope
-  --> tests/fail/macros_try_join.rs:14:38
-   |
-14 |     let _ = tokio::try_join!(async { Ready(0) });
-   |                                      ^^^^^ not found in this scope
-   |
-help: consider importing this tuple variant
-   |
- 1 + use std::task::Poll::Ready;
-   |
-
-error[E0405]: cannot find trait `Future` in this scope
-  --> tests/fail/macros_try_join.rs:20:14
-   |
-20 |         impl Future for MyFuture {
-   |              ^^^^^^ not found in this scope
-   |
-help: consider importing this trait
-   |
- 1 + use std::future::Future;
-   |
-
-error[E0433]: cannot find type `Pin` in this scope
-  --> tests/fail/macros_try_join.rs:35:17
-   |
-35 |         let _ = Pin::new(&mut x);
-   |                 ^^^ use of undeclared type `Pin`
-   |
-help: consider importing this struct
-   |
- 1 + use std::pin::Pin;
-   |
-
-error[E0425]: cannot find function `poll_fn` in this scope
-  --> tests/fail/macros_try_join.rs:40:17
-   |
-40 |         let _ = poll_fn(|_cx| todo!());
-   |                 ^^^^^^^ not found in this scope
-   |
-help: consider importing this function
-   |
- 1 + use std::future::poll_fn;
-   |

tests-build/tests/fail/macros_type_mismatch.rs

@@ -23,40 +23,6 @@ async fn extra_semicolon() -> Result<(), ()> {
     Ok(());
 }
 
-/// This test is a characterization test for the `?` operator.
-///
-/// See <https://github.com/tokio-rs/tokio/issues/6930#issuecomment-2572502517> for more details.
-///
-/// It should fail with a single error message about the return type of the function, but instead
-/// if fails with an extra error message due to the `?` operator being used within the async block
-/// rather than the original function.
-///
-/// ```text
-/// 28 |     None?;
-///    |         ^ cannot use the `?` operator in an async block that returns `()`
-/// ```
-#[tokio::main]
-async fn question_mark_operator_with_invalid_option() -> Option<()> {
-    None?;
-}
-
-/// This test is a characterization test for the `?` operator.
-///
-/// See <https://github.com/tokio-rs/tokio/issues/6930#issuecomment-2572502517> for more details.
-///
-/// It should fail with a single error message about the return type of the function, but instead
-/// if fails with an extra error message due to the `?` operator being used within the async block
-/// rather than the original function.
-///
-/// ```text
-/// 33 |     Ok(())?;
-///    |           ^ cannot use the `?` operator in an async block that returns `()`
-/// ```
-#[tokio::main]
-async fn question_mark_operator_with_invalid_result() -> Result<(), ()> {
-    Ok(())?;
-}
-
 // https://github.com/tokio-rs/tokio/issues/4635
 #[allow(redundant_semicolons)]
 #[rustfmt::skip]

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,69 +1,24 @@
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:3:1: 3:15}` to be a future that resolves to `()`, but it resolves to `Result<(), _>`
- --> tests/fail/macros_type_mismatch.rs:3:1
-  |
-3 | #[tokio::main]
-  | ^^^^^^^^^^^^^^ expected `()`, found `Result<(), _>`
-  |
-  = note: expected unit type `()`
-                  found enum `Result<(), _>`
-  = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:3:1: 3:15}` to `&dyn Future<Output = ()>`
-  = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0308]: mismatched types
  --> tests/fail/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<(), _>`
   |
   = note: expected unit type `()`
                   found enum `Result<(), _>`
-help: a return type might be missing here
-  |
-4 | async fn missing_semicolon_or_return_type() -> _ {
-  |                                             ++++
-help: consider using `Result::expect` to unwrap the `Result<(), _>` value, panicking if the value is a `Result::Err`
-  |
-5 |     Ok(()).expect("REASON")
-  |           +++++++++++++++++
-
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:8:1: 8:15}` to be a future that resolves to `()`, but it resolves to `Result<(), _>`
- --> tests/fail/macros_type_mismatch.rs:8:1
-  |
-8 | #[tokio::main]
-  | ^^^^^^^^^^^^^^ expected `()`, found `Result<(), _>`
-  |
-  = note: expected unit type `()`
-                  found enum `Result<(), _>`
-  = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:8:1: 8:15}` to `&dyn Future<Output = ()>`
-  = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0308]: mismatched types
   --> tests/fail/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<(), _>`
    |
    = note: expected unit type `()`
                    found enum `Result<(), _>`
-help: a return type might be missing here
-   |
- 9 | async fn missing_return_type() -> _ {
-   |                                ++++
-help: consider using `Result::expect` to unwrap the `Result<(), _>` value, panicking if the value is a `Result::Err`
-   |
-10 |     return Ok(());.expect("REASON")
-   |                   +++++++++++++++++
-
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:13:1: 13:15}` to be a future that resolves to `Result<(), ()>`, but it resolves to `()`
-  --> tests/fail/macros_type_mismatch.rs:13:1
-   |
-13 | #[tokio::main]
-   | ^^^^^^^^^^^^^^ expected `Result<(), ()>`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-   = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:13:1: 13:15}` to `&dyn Future<Output = Result<(), ()>>`
-   = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0308]: mismatched types
   --> tests/fail/macros_type_mismatch.rs:23:5
@@ -82,95 +37,11 @@ help: try adding an expression at the end of the block
 24 +     Ok(())
    |
 
-error[E0277]: the `?` operator can only be used in an async block that returns `Result` or `Option` (or another type that implements `FromResidual`)
-  --> tests/fail/macros_type_mismatch.rs:40:9
-   |
-38 | #[tokio::main]
-   | -------------- this function should return `Result` or `Option` to accept `?`
-39 | async fn question_mark_operator_with_invalid_option() -> Option<()> {
-40 |     None?;
-   |         ^ cannot use the `?` operator in an async block that returns `()`
-
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:38:1: 38:15}` to be a future that resolves to `Option<()>`, but it resolves to `()`
-  --> tests/fail/macros_type_mismatch.rs:38:1
-   |
-38 | #[tokio::main]
-   | ^^^^^^^^^^^^^^ expected `Option<()>`, found `()`
-   |
-   = note:   expected enum `Option<()>`
-           found unit type `()`
-   = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:38:1: 38:15}` to `&dyn Future<Output = Option<()>>`
-   = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:40:5
+  --> tests/fail/macros_type_mismatch.rs:32:5
    |
-39 | async fn question_mark_operator_with_invalid_option() -> Option<()> {
-   |                                                          ---------- expected `Option<()>` because of return type
-40 |     None?;
-   |     ^^^^^^ expected `Option<()>`, found `()`
-   |
-   = note:   expected enum `Option<()>`
-           found unit type `()`
-help: try adding an expression at the end of the block
-   |
-40 ~     None?;;
-41 +     None
-   |
-40 ~     None?;;
-41 +     Some(())
-   |
-
-error[E0277]: the `?` operator can only be used in an async block that returns `Result` or `Option` (or another type that implements `FromResidual`)
-  --> tests/fail/macros_type_mismatch.rs:57:11
-   |
-55 | #[tokio::main]
-   | -------------- this function should return `Result` or `Option` to accept `?`
-56 | async fn question_mark_operator_with_invalid_result() -> Result<(), ()> {
-57 |     Ok(())?;
-   |           ^ cannot use the `?` operator in an async block that returns `()`
-
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:55:1: 55:15}` to be a future that resolves to `Result<(), ()>`, but it resolves to `()`
-  --> tests/fail/macros_type_mismatch.rs:55:1
-   |
-55 | #[tokio::main]
-   | ^^^^^^^^^^^^^^ expected `Result<(), ()>`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-   = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:55:1: 55:15}` to `&dyn Future<Output = Result<(), ()>>`
-   = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:57:5
-   |
-56 | async fn question_mark_operator_with_invalid_result() -> Result<(), ()> {
-   |                                                          -------------- expected `Result<(), ()>` because of return type
-57 |     Ok(())?;
-   |     ^^^^^^^^ expected `Result<(), ()>`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-help: try adding an expression at the end of the block
-   |
-57 ~     Ok(())?;;
-58 +     Ok(())
-   |
-
-error[E0271]: expected `{async block@$DIR/tests/fail/macros_type_mismatch.rs:63:1: 63:15}` to be a future that resolves to `()`, but it resolves to `{integer}`
-  --> tests/fail/macros_type_mismatch.rs:63:1
-   |
-63 | #[tokio::main]
-   | ^^^^^^^^^^^^^^ expected `()`, found integer
-   |
-   = note: required for the cast from `&{async block@$DIR/tests/fail/macros_type_mismatch.rs:63:1: 63:15}` to `&dyn Future<Output = ()>`
-   = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:66:5
-   |
-64 | async fn issue_4635() {
-   |                      - help: try adding a return type: `-> i32`
-65 |     return 1;
-66 |     ;
+30 | async fn issue_4635() {
+   |                       - help: try adding a return type: `-> i32`
+31 |     return 1;
+32 |     ;
    |     ^ expected `()`, found integer

tests-build/tests/macros.rs

@@ -1,5 +1,4 @@
 #[test]
-#[cfg_attr(miri, ignore)]
 fn compile_fail_full() {
     let t = trybuild::TestCases::new();
 
@@ -12,24 +11,12 @@ fn compile_fail_full() {
     #[cfg(feature = "full")]
     t.pass("tests/pass/macros_main_loop.rs");
 
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/impl_trait.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/use_builder_outer.rs");
-
     #[cfg(feature = "full")]
     t.compile_fail("tests/fail/macros_invalid_input.rs");
 
     #[cfg(feature = "full")]
     t.compile_fail("tests/fail/macros_dead_code.rs");
 
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_join.rs");
-
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_try_join.rs");
-
     #[cfg(feature = "full")]
     t.compile_fail("tests/fail/macros_type_mismatch.rs");
 

tests-build/tests/pass/impl_trait.rs

@@ -1,23 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn never() -> ! {
-    loop {}
-}
-
-#[tokio::main]
-async fn impl_trait() -> impl Iterator<Item = impl core::fmt::Debug> {
-    [()].into_iter()
-}
-
-#[tokio::main]
-async fn impl_trait2() -> Result<(), impl core::fmt::Debug> {
-    Err(())
-}
-
-fn main() {
-    if impl_trait().count() == 10 {
-        never();
-    }
-    let _ = impl_trait2();
-}

tests-build/tests/pass/use_builder_outer.rs

@@ -1,9 +0,0 @@
-#![deny(unused_qualifications)]
-
-use tests_build::tokio;
-pub use tokio::runtime;
-
-#[tokio::main]
-async fn main() {
-    if true {}
-}

tests-integration/Cargo.toml

@@ -2,8 +2,7 @@
 name = "tests-integration"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
-license = "MIT"
+edition = "2018"
 publish = false
 
 [[bin]]
@@ -40,7 +39,6 @@ rt-process-signal = ["rt-net", "tokio/process", "tokio/signal"]
 # This is an explicit feature so we can use `cargo hack` testing single features
 # instead of all possible permutations.
 wasi-rt = ["rt", "macros", "sync"]
-wasi-threads-rt = ["wasi-rt", "rt-multi-thread"]
 
 full = [
     "macros",
@@ -56,11 +54,8 @@ rt = ["tokio/rt"]
 rt-multi-thread = ["rt", "tokio/rt-multi-thread"]
 
 [dependencies]
-tokio = { version = "1.0.0", path = "../tokio" }
-tokio-test = { version = "0.4", path = "../tokio-test", optional = true }
+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"
-
-[lints]
-workspace = true

tests-integration/src/bin/test-mem.rs

@@ -1,4 +1,4 @@
-use std::future::poll_fn;
+use futures::future::poll_fn;
 
 fn main() {
     let rt = tokio::runtime::Builder::new_multi_thread()

tests-integration/tests/macros_main.rs

@@ -1,4 +1,8 @@
-#![cfg(all(feature = "macros", feature = "rt-multi-thread"))]
+#![cfg(all(
+    feature = "macros",
+    feature = "rt-multi-thread",
+    not(target_os = "wasi")
+))]
 
 #[tokio::main]
 async fn basic_main() -> usize {
@@ -16,12 +20,6 @@ async fn spawning() -> usize {
     join.await.unwrap()
 }
 
-#[tokio::main(flavor = "local")]
-async fn local_main() -> usize {
-    let join = tokio::task::spawn_local(async { 1 });
-    join.await.unwrap()
-}
-
 #[test]
 fn main_with_spawn() {
     assert_eq!(1, spawning());
@@ -30,7 +28,5 @@ fn main_with_spawn() {
 #[test]
 fn shell() {
     assert_eq!(1, basic_main());
-    assert_eq!(bool::default(), generic_fun::<bool>());
-
-    assert_eq!(1, local_main());
+    assert_eq!(bool::default(), generic_fun::<bool>())
 }

tests-integration/tests/macros_select.rs

@@ -4,10 +4,7 @@ use futures::channel::oneshot;
 use futures::executor::block_on;
 use std::thread;
 
-#[cfg_attr(
-    not(feature = "rt-multi-thread"),
-    ignore = "WASI: std::thread::spawn not supported"
-)]
+#[cfg_attr(target_os = "wasi", ignore = "WASI: std::thread::spawn not supported")]
 #[test]
 fn join_with_select() {
     block_on(async {

tests-integration/tests/process_stdio.rs

@@ -1,5 +1,5 @@
 #![warn(rust_2018_idioms)]
-#![cfg(all(feature = "full", not(target_os = "wasi"), not(miri)))]
+#![cfg(all(feature = "full", not(target_os = "wasi")))]
 
 use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
 use tokio::join;
@@ -7,10 +7,10 @@ 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};
-use std::task::ready;
 
 fn cat() -> Command {
     let mut cmd = Command::new(env!("CARGO_BIN_EXE_test-cat"));
@@ -25,7 +25,7 @@ async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
     // Produce n lines on the child's stdout.
     let write = async {
         for i in 0..n {
-            let bytes = format!("line {i}\n").into_bytes();
+            let bytes = format!("line {}\n", i).into_bytes();
             stdin.write_all(&bytes).await.unwrap();
         }
 
@@ -52,7 +52,7 @@ async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
                 (false, 0) => panic!("broken pipe"),
                 (true, n) if n != 0 => panic!("extraneous data"),
                 _ => {
-                    let expected = format!("line {num_lines}");
+                    let expected = format!("line {}", num_lines);
                     assert_eq!(expected, data);
                 }
             };
@@ -206,13 +206,13 @@ async fn vectored_writes() {
         let mut input = Bytes::from_static(b"hello\n").chain(Bytes::from_static(b"world!\n"));
         let mut writes_completed = 0;
 
-        std::future::poll_fn(|cx| loop {
+        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 = ready!(Pin::new(&mut stdin).poll_write_vectored(cx, &slices))?;
+            let n = futures::ready!(Pin::new(&mut stdin).poll_write_vectored(cx, &slices))?;
             writes_completed += 1;
             input.advance(n);
         })

tokio-macros/CHANGELOG.md

@@ -1,72 +1,3 @@
-# 2.7.2 (July 29th, 2026)
-
-- macros: upgrade syn to v3 ([#8304])
-
-[#8304]: https://github.com/tokio-rs/tokio/pull/8304
-
-# 2.7.1 (July 17th, 2026)
-
-- macros: clarify `tokio::main` expansion ([#8193])
-
-[#8193]: https://github.com/tokio-rs/tokio/pull/8193
-
-# 2.7.0 (April 3rd, 2026)
-
-- macros: stabilize `LocalRuntime` ([#7557])
-- macros: add runtime name ([#7924])
-
-[#7557]: https://github.com/tokio-rs/tokio/pull/7557
-[#7924]: https://github.com/tokio-rs/tokio/pull/7924
-
-# 2.6.1 (Mar 2nd, 2026)
-
-- macros: improve error message for return type mismatch in #[tokio::main] ([#7856])
-- macros: use call_site hygiene to avoid unused qualification ([#7866])
-
-[#7856]: https://github.com/tokio-rs/tokio/pull/7856
-[#7866]: https://github.com/tokio-rs/tokio/pull/7866
-
-# 2.6.0 (Oct 14th, 2025)
-
-The MSRV is raised to 1.71.
-
-- msrv: increase MSRV to 1.71 ([#7658])
-- macros: add `local` runtime flavor ([#7375], [#7597])
-- macros: suppress `clippy::unwrap_in_result` in `#[tokio::main]` ([#7651])
-
-[#7375]: https://github.com/tokio-rs/tokio/pull/7375
-[#7597]: https://github.com/tokio-rs/tokio/pull/7597
-[#7651]: https://github.com/tokio-rs/tokio/pull/7651
-[#7658]: https://github.com/tokio-rs/tokio/pull/7658
-
-# 2.5.0 (Jan 8th, 2025)
-
-- macros: suppress `clippy::needless_return` in `#[tokio::main]` ([#6874])
-
-[#6874]: https://github.com/tokio-rs/tokio/pull/6874
-
-# 2.4.0 (July 22nd, 2024)
-
-- msrv: increase MSRV to 1.70 ([#6645])
-- macros: allow `unhandled_panic` behavior for `#[tokio::main]` and `#[tokio::test]` ([#6593])
-
-[#6593]: https://github.com/tokio-rs/tokio/pull/6593
-[#6645]: https://github.com/tokio-rs/tokio/pull/6645
-
-# 2.3.0 (May 30th, 2024)
-
-- macros: make `#[tokio::test]` append `#[test]` at the end of the attribute list ([#6497])
-
-[#6497]: https://github.com/tokio-rs/tokio/pull/6497
-
-# 2.2.0 (November 19th, 2023)
-
-### Changed
-
-- use `::core` qualified imports instead of `::std` inside `tokio::test` macro ([#5973])
-
-[#5973]: https://github.com/tokio-rs/tokio/pull/5973
-
 # 2.1.0 (April 25th, 2023)
 
 - macros: fix typo in `#[tokio::test]` docs ([#5636])

tokio-macros/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "tokio-macros"
 # When releasing to crates.io:
-# - Remove path dependencies (if any)
+# - Remove path dependencies
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-x.y.z" git tag.
-version = "2.7.2"
-edition = "2021"
-rust-version = "1.71"
+# - Create "tokio-macros-1.x.y" git tag.
+version = "2.1.0"
+edition = "2018"
+rust-version = "1.56"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -22,15 +22,12 @@ proc-macro = true
 [features]
 
 [dependencies]
-proc-macro2 = "1.0.60"
+proc-macro2 = "1.0.7"
 quote = "1"
-syn = { version = "3.0", features = ["full"] }
+syn = { version = "2.0", features = ["full"] }
 
 [dev-dependencies]
-tokio = { version = "1.0.0", features = ["full", "test-util"] }
+tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
 
 [package.metadata.docs.rs]
 all-features = true
-
-[lints]
-workspace = true

tokio-macros/LICENSE

@@ -1,7 +1,32 @@
-MIT License
+Copyright (c) 2023 Tokio Contributors
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+The MIT License (MIT)
 
 Copyright (c) 2019 Yoshua Wuyts
-Copyright (c) Tokio Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

tokio-macros/src/entry.rs

@@ -10,7 +10,6 @@ type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![,]>;
 enum RuntimeFlavor {
     CurrentThread,
     Threaded,
-    Local,
 }
 
 impl RuntimeFlavor {
@@ -18,61 +17,30 @@ impl RuntimeFlavor {
         match s {
             "current_thread" => Ok(RuntimeFlavor::CurrentThread),
             "multi_thread" => Ok(RuntimeFlavor::Threaded),
-            "local" => Ok(RuntimeFlavor::Local),
             "single_thread" => Err("The single threaded runtime flavor is called `current_thread`.".to_string()),
             "basic_scheduler" => Err("The `basic_scheduler` runtime flavor has been renamed to `current_thread`.".to_string()),
             "threaded_scheduler" => Err("The `threaded_scheduler` runtime flavor has been renamed to `multi_thread`.".to_string()),
-            _ => Err(format!("No such runtime flavor `{s}`. The runtime flavors are `current_thread`, `local`, and `multi_thread`.")),
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq)]
-enum UnhandledPanic {
-    Ignore,
-    ShutdownRuntime,
-}
-
-impl UnhandledPanic {
-    fn from_str(s: &str) -> Result<UnhandledPanic, String> {
-        match s {
-            "ignore" => Ok(UnhandledPanic::Ignore),
-            "shutdown_runtime" => Ok(UnhandledPanic::ShutdownRuntime),
-            _ => Err(format!("No such unhandled panic behavior `{s}`. The unhandled panic behaviors are `ignore` and `shutdown_runtime`.")),
-        }
-    }
-
-    fn into_tokens(self, crate_path: &TokenStream) -> TokenStream {
-        match self {
-            UnhandledPanic::Ignore => quote! { #crate_path::runtime::UnhandledPanic::Ignore },
-            UnhandledPanic::ShutdownRuntime => {
-                quote! { #crate_path::runtime::UnhandledPanic::ShutdownRuntime }
-            }
+            _ => Err(format!("No such runtime flavor `{}`. The runtime flavors are `current_thread` and `multi_thread`.", s)),
         }
     }
 }
 
 struct FinalConfig {
-    name: Option<String>,
     flavor: RuntimeFlavor,
     worker_threads: Option<usize>,
     start_paused: Option<bool>,
     crate_name: Option<Path>,
-    unhandled_panic: Option<UnhandledPanic>,
 }
 
 /// Config used in case of the attribute not being able to build a valid config
 const DEFAULT_ERROR_CONFIG: FinalConfig = FinalConfig {
-    name: None,
     flavor: RuntimeFlavor::CurrentThread,
     worker_threads: None,
     start_paused: None,
     crate_name: None,
-    unhandled_panic: None,
 };
 
 struct Configuration {
-    name: Option<String>,
     rt_multi_thread_available: bool,
     default_flavor: RuntimeFlavor,
     flavor: Option<RuntimeFlavor>,
@@ -80,13 +48,11 @@ struct Configuration {
     start_paused: Option<(bool, Span)>,
     is_test: bool,
     crate_name: Option<Path>,
-    unhandled_panic: Option<(UnhandledPanic, Span)>,
 }
 
 impl Configuration {
     fn new(is_test: bool, rt_multi_thread: bool) -> Self {
         Configuration {
-            name: None,
             rt_multi_thread_available: rt_multi_thread,
             default_flavor: match is_test {
                 true => RuntimeFlavor::CurrentThread,
@@ -97,20 +63,9 @@ impl Configuration {
             start_paused: None,
             is_test,
             crate_name: None,
-            unhandled_panic: None,
         }
     }
 
-    fn set_name(&mut self, name: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.name.is_some() {
-            return Err(syn::Error::new(span, "`name` set multiple times."));
-        }
-
-        let runtime_name = parse_string(name, span, "name")?;
-        self.name = Some(runtime_name);
-        Ok(())
-    }
-
     fn set_flavor(&mut self, runtime: syn::Lit, span: Span) -> Result<(), syn::Error> {
         if self.flavor.is_some() {
             return Err(syn::Error::new(span, "`flavor` set multiple times."));
@@ -162,25 +117,6 @@ impl Configuration {
         Ok(())
     }
 
-    fn set_unhandled_panic(
-        &mut self,
-        unhandled_panic: syn::Lit,
-        span: Span,
-    ) -> Result<(), syn::Error> {
-        if self.unhandled_panic.is_some() {
-            return Err(syn::Error::new(
-                span,
-                "`unhandled_panic` set multiple times.",
-            ));
-        }
-
-        let unhandled_panic = parse_string(unhandled_panic, span, "unhandled_panic")?;
-        let unhandled_panic =
-            UnhandledPanic::from_str(&unhandled_panic).map_err(|err| syn::Error::new(span, err))?;
-        self.unhandled_panic = Some((unhandled_panic, span));
-        Ok(())
-    }
-
     fn macro_name(&self) -> &'static str {
         if self.is_test {
             "tokio::test"
@@ -190,23 +126,22 @@ impl Configuration {
     }
 
     fn build(&self) -> Result<FinalConfig, syn::Error> {
-        use RuntimeFlavor as F;
-
         let flavor = self.flavor.unwrap_or(self.default_flavor);
+        use RuntimeFlavor::*;
 
         let worker_threads = match (flavor, self.worker_threads) {
-            (F::CurrentThread | F::Local, Some((_, worker_threads_span))) => {
+            (CurrentThread, Some((_, worker_threads_span))) => {
                 let msg = format!(
                     "The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[{}(flavor = \"multi_thread\")]`",
                     self.macro_name(),
                 );
                 return Err(syn::Error::new(worker_threads_span, msg));
             }
-            (F::CurrentThread | F::Local, None) => None,
-            (F::Threaded, worker_threads) if self.rt_multi_thread_available => {
+            (CurrentThread, None) => None,
+            (Threaded, worker_threads) if self.rt_multi_thread_available => {
                 worker_threads.map(|(val, _span)| val)
             }
-            (F::Threaded, _) => {
+            (Threaded, _) => {
                 let msg = if self.flavor.is_none() {
                     "The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled."
                 } else {
@@ -217,36 +152,22 @@ impl Configuration {
         };
 
         let start_paused = match (flavor, self.start_paused) {
-            (F::Threaded, Some((_, start_paused_span))) => {
+            (Threaded, Some((_, start_paused_span))) => {
                 let msg = format!(
                     "The `start_paused` option requires the `current_thread` runtime flavor. Use `#[{}(flavor = \"current_thread\")]`",
                     self.macro_name(),
                 );
                 return Err(syn::Error::new(start_paused_span, msg));
             }
-            (F::CurrentThread | F::Local, Some((start_paused, _))) => Some(start_paused),
-            (_, None) => None,
-        };
-
-        let unhandled_panic = match (flavor, self.unhandled_panic) {
-            (F::Threaded, Some((_, unhandled_panic_span))) => {
-                let msg = format!(
-                    "The `unhandled_panic` option requires the `current_thread` runtime flavor. Use `#[{}(flavor = \"current_thread\")]`",
-                    self.macro_name(),
-                );
-                return Err(syn::Error::new(unhandled_panic_span, msg));
-            }
-            (F::CurrentThread | F::Local, Some((unhandled_panic, _))) => Some(unhandled_panic),
+            (CurrentThread, Some((start_paused, _))) => Some(start_paused),
             (_, None) => None,
         };
 
         Ok(FinalConfig {
-            name: self.name.clone(),
             crate_name: self.crate_name.clone(),
             flavor,
             worker_threads,
             start_paused,
-            unhandled_panic,
         })
     }
 }
@@ -257,12 +178,12 @@ fn parse_int(int: syn::Lit, span: Span, field: &str) -> Result<usize, syn::Error
             Ok(value) => Ok(value),
             Err(e) => Err(syn::Error::new(
                 span,
-                format!("Failed to parse value of `{field}` as integer: {e}"),
+                format!("Failed to parse value of `{}` as integer: {}", field, e),
             )),
         },
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{field}` as integer."),
+            format!("Failed to parse value of `{}` as integer.", field),
         )),
     }
 }
@@ -273,7 +194,7 @@ fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result<String, syn::E
         syn::Lit::Verbatim(s) => Ok(s.to_string()),
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{field}` as string."),
+            format!("Failed to parse value of `{}` as string.", field),
         )),
     }
 }
@@ -293,7 +214,7 @@ fn parse_path(lit: syn::Lit, span: Span, field: &str) -> Result<Path, syn::Error
         }
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{field}` as path."),
+            format!("Failed to parse value of `{}` as path.", field),
         )),
     }
 }
@@ -303,40 +224,11 @@ fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, syn::Erro
         syn::Lit::Bool(b) => Ok(b.value),
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{field}` as bool."),
+            format!("Failed to parse value of `{}` as bool.", field),
         )),
     }
 }
 
-fn contains_impl_trait(ty: &syn::Type) -> bool {
-    match ty {
-        syn::Type::ImplTrait(_) => true,
-        syn::Type::Array(t) => contains_impl_trait(&t.elem),
-        syn::Type::Ptr(t) => contains_impl_trait(&t.elem),
-        syn::Type::Reference(t) => contains_impl_trait(&t.elem),
-        syn::Type::Slice(t) => contains_impl_trait(&t.elem),
-        syn::Type::Tuple(t) => t.elems.iter().any(contains_impl_trait),
-        syn::Type::Paren(t) => contains_impl_trait(&t.elem),
-        syn::Type::Group(t) => contains_impl_trait(&t.elem),
-        syn::Type::Path(t) => match t.path.segments.last() {
-            Some(segment) => match &segment.arguments {
-                syn::PathArguments::AngleBracketed(args) => args.args.iter().any(|arg| match arg {
-                    syn::GenericArgument::Type(t) => contains_impl_trait(t),
-                    syn::GenericArgument::AssocType(t) => contains_impl_trait(&t.ty),
-                    _ => false,
-                }),
-                syn::PathArguments::Parenthesized(args) => {
-                    args.inputs.iter().any(|arg| contains_impl_trait(&arg.ty))
-                        || matches!(&args.output, syn::ReturnType::Type(_, t) if contains_impl_trait(t))
-                }
-                syn::PathArguments::None => false,
-            },
-            None => false,
-        },
-        _ => false,
-    }
-}
-
 fn build_config(
     input: &ItemFn,
     args: AttributeArgs,
@@ -383,16 +275,10 @@ fn build_config(
                     "crate" => {
                         config.set_crate_name(lit.clone(), syn::spanned::Spanned::span(lit))?;
                     }
-                    "unhandled_panic" => {
-                        config
-                            .set_unhandled_panic(lit.clone(), syn::spanned::Spanned::span(lit))?;
-                    }
-                    "name" => {
-                        config.set_name(lit.clone(), syn::spanned::Spanned::span(lit))?;
-                    }
                     name => {
                         let msg = format!(
-                            "Unknown attribute {name} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`, `name`.",
+                            "Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`",
+                            name,
                         );
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
@@ -407,20 +293,21 @@ fn build_config(
                 let msg = match name.as_str() {
                     "threaded_scheduler" | "multi_thread" => {
                         format!(
-                            "Set the runtime flavor with #[{macro_name}(flavor = \"multi_thread\")]."
+                            "Set the runtime flavor with #[{}(flavor = \"multi_thread\")].",
+                            macro_name
                         )
                     }
                     "basic_scheduler" | "current_thread" | "single_threaded" => {
                         format!(
-                            "Set the runtime flavor with #[{macro_name}(flavor = \"current_thread\")]."
+                            "Set the runtime flavor with #[{}(flavor = \"current_thread\")].",
+                            macro_name
                         )
                     }
-                    "flavor" | "worker_threads" | "start_paused" | "crate" | "unhandled_panic"
-                    | "name" => {
-                        format!("The `{name}` attribute requires an argument.")
+                    "flavor" | "worker_threads" | "start_paused" => {
+                        format!("The `{}` attribute requires an argument.", name)
                     }
                     name => {
-                        format!("Unknown attribute {name} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`, `name`.")
+                        format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`", name)
                     }
                 };
                 return Err(syn::Error::new_spanned(path, msg));
@@ -453,50 +340,27 @@ fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenSt
         (start, end)
     };
 
-    let crate_path = config.crate_name.map_or_else(
-        || {
-            Ident::new("tokio", Span::call_site().located_at(last_stmt_start_span))
-                .into_token_stream()
-        },
-        ToTokens::into_token_stream,
-    );
-
-    let use_builder = quote_spanned! {Span::call_site().located_at(last_stmt_start_span)=>
-        use #crate_path::runtime::Builder;
-    };
+    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 mut rt = match config.flavor {
-        RuntimeFlavor::CurrentThread | RuntimeFlavor::Local => {
-            quote_spanned! {last_stmt_start_span=>
-                Builder::new_current_thread()
-            }
-        }
+        RuntimeFlavor::CurrentThread => quote_spanned! {last_stmt_start_span=>
+            #crate_path::runtime::Builder::new_current_thread()
+        },
         RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=>
-            Builder::new_multi_thread()
+            #crate_path::runtime::Builder::new_multi_thread()
         },
     };
-
-    let build = if let RuntimeFlavor::Local = config.flavor {
-        quote_spanned! {last_stmt_start_span=> build_local(Default::default())}
-    } else {
-        quote_spanned! {last_stmt_start_span=> build()}
-    };
-
     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) };
-    }
-    if let Some(v) = config.unhandled_panic {
-        let unhandled_panic = v.into_tokens(&crate_path);
-        rt = quote_spanned! {last_stmt_start_span=> #rt.unhandled_panic(#unhandled_panic) };
-    }
-    if let Some(v) = config.name {
-        rt = quote_spanned! {last_stmt_start_span=> #rt.name(#v) };
+        rt = quote! { #rt.start_paused(#v) };
     }
 
-    let generated_attrs = if is_test {
+    let header = if is_test {
         quote! {
             #[::core::prelude::v1::test]
         }
@@ -505,20 +369,15 @@ fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenSt
     };
 
     let body_ident = quote! { body };
-    // This explicit `return` is intentional. See tokio-rs/tokio#4636
     let last_block = quote_spanned! {last_stmt_end_span=>
-
-        #[allow(clippy::expect_used, clippy::diverging_sub_expression, clippy::needless_return, clippy::unwrap_in_result)]
+        #[allow(clippy::expect_used, clippy::diverging_sub_expression)]
         {
-            #use_builder
-
             return #rt
                 .enable_all()
-                .#build
+                .build()
                 .expect("Failed building the Runtime")
                 .block_on(#body_ident);
         }
-
     };
 
     let body = input.body();
@@ -532,46 +391,26 @@ fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenSt
     //
     // We don't do this for the main function as it should only be used once so
     // there will be no benefit.
-    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 },
-    };
-
     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;
+            let body: ::std::pin::Pin<&mut dyn ::std::future::Future<Output = #output_type>> = body;
         }
     } else {
-        // force typecheck without runtime overhead
-        let check_block = match &input.sig.output {
-            syn::ReturnType::Type(_, t)
-                if matches!(**t, syn::Type::Never(_)) || contains_impl_trait(t) =>
-            {
-                quote! {}
-            }
-            _ => quote! {
-                if false {
-                    let _: &dyn ::core::future::Future<Output = #output_type> = &body;
-                }
-            },
-        };
-
         quote! {
             let body = async #body;
-            // Compile-time assertion that the future's output matches the return type.
-            let body = {
-                #check_block
-                body
-            };
         }
     };
 
-    input.into_tokens(generated_attrs, body, last_block)
+    input.into_tokens(header, body, last_block)
 }
 
 fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenStream {
@@ -579,6 +418,7 @@ fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenS
     tokens
 }
 
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
     // 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
@@ -603,35 +443,6 @@ pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
     }
 }
 
-// Check whether given attribute is a test attribute of forms:
-// * `#[test]`
-// * `#[core::prelude::*::test]` or `#[::core::prelude::*::test]`
-// * `#[std::prelude::*::test]` or `#[::std::prelude::*::test]`
-fn is_test_attribute(attr: &Attribute) -> bool {
-    let path = match &attr.meta {
-        syn::Meta::Path(path) => path,
-        _ => return false,
-    };
-    let candidates = [
-        ["core", "prelude", "*", "test"],
-        ["std", "prelude", "*", "test"],
-    ];
-    if path.leading_colon.is_none()
-        && path.segments.len() == 1
-        && path.segments[0].arguments.is_none()
-        && path.segments[0].ident == "test"
-    {
-        return true;
-    } else if path.segments.len() != candidates[0].len() {
-        return false;
-    }
-    candidates.into_iter().any(|segments| {
-        path.segments.iter().zip(segments).all(|(segment, path)| {
-            segment.arguments.is_none() && (path == "*" || segment.ident == path)
-        })
-    })
-}
-
 pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
     // 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
@@ -640,8 +451,8 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
         Ok(it) => it,
         Err(e) => return token_stream_with_error(item, e),
     };
-    let config = if let Some(attr) = input.attrs().find(|attr| is_test_attribute(attr)) {
-        let msg = "second test attribute is supplied, consider removing or changing the order of your test attributes";
+    let config = if let Some(attr) = input.attrs().find(|attr| attr.meta.path().is_ident("test")) {
+        let msg = "second test attribute is supplied";
         Err(syn::Error::new_spanned(attr, msg))
     } else {
         AttributeArgs::parse_terminated
@@ -682,11 +493,13 @@ impl ItemFn {
     /// Convert our local function item into a token stream.
     fn into_tokens(
         self,
-        generated_attrs: proc_macro2::TokenStream,
+        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);
@@ -694,15 +507,12 @@ impl ItemFn {
 
         // 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 behavior of `syn`.
+        // 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);
         }
 
-        // Add generated macros at the end, so macros processed later are aware of them.
-        generated_attrs.to_tokens(&mut tokens);
-
         self.vis.to_tokens(&mut tokens);
         self.sig.to_tokens(&mut tokens);
 
@@ -776,6 +586,6 @@ impl ToTokens for Body<'_> {
             for stmt in self.stmts {
                 stmt.to_tokens(tokens);
             }
-        });
+        })
     }
 }

tokio-macros/src/lib.rs

@@ -12,6 +12,11 @@
 
 //! Macros for use with Tokio
 
+// This `extern` is required for older `rustc` versions but newer `rustc`
+// versions warn about the unused `extern crate`.
+#[allow(unused_extern_crates)]
+extern crate proc_macro;
+
 mod entry;
 mod select;
 
@@ -29,11 +34,10 @@ use proc_macro::TokenStream;
 /// powerful interface.
 ///
 /// Note: This macro can be used on any function and not just the `main`
-/// function. Although the function is written with `async fn`, this macro
-/// expands it to a synchronous function that starts a runtime each time it is
-/// called. If the function is called often, it is preferable to create the
-/// runtime using the runtime builder so the runtime can be reused across calls.
-/// For details on the expansion, see [Bridging with sync code][bridging].
+/// function. Using it on a non-main function makes the function behave as if it
+/// was synchronous by starting a new runtime each time it is called. If the
+/// 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
 ///
@@ -42,12 +46,7 @@ use proc_macro::TokenStream;
 /// Awaiting on other futures from the function provided here will not
 /// perform as fast as those spawned as workers.
 ///
-/// # Runtime flavors
-///
-/// The macro can be configured with a `flavor` parameter to select
-/// different runtime configurations.
-///
-/// ## Multi-threaded
+/// # Multi-threaded runtime
 ///
 /// To use the multi-threaded runtime, the macro can be configured using
 ///
@@ -62,56 +61,23 @@ use proc_macro::TokenStream;
 /// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
 /// flag.
 ///
-/// ## Current-thread
+/// # Current thread runtime
 ///
 /// To use the single-threaded runtime known as the `current_thread` runtime,
 /// the macro can be configured using
 ///
-/// ```rust
+/// ```
 /// #[tokio::main(flavor = "current_thread")]
 /// # async fn main() {}
 /// ```
 ///
-/// ## Local
+/// ## Function arguments:
 ///
-/// To use the [local runtime], the macro can be configured using
+/// Arguments are allowed for any functions aside from `main` which is special
 ///
-/// ```rust
-/// #[tokio::main(flavor = "local")]
-/// # async fn main() {}
-/// ```
+/// ## Usage
 ///
-/// # Function arguments
-///
-/// Arguments are allowed for any functions, aside from `main` which is special.
-///
-/// # Usage
-///
-/// ## Set the name of the runtime
-///
-/// ```rust
-/// #[tokio::main(name = "my-runtime")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// fn main() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .name("my-runtime")
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
-///
-/// ## Using the multi-threaded runtime
+/// ### Using the multi-thread runtime
 ///
 /// ```rust
 /// #[tokio::main]
@@ -134,7 +100,7 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Using the current-thread runtime
+/// ### Using current thread runtime
 ///
 /// The basic scheduler is single-threaded.
 ///
@@ -159,34 +125,7 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Using the local runtime
-///
-/// The [local runtime] is similar to the current-thread runtime but
-/// supports [`task::spawn_local`](../tokio/task/fn.spawn_local.html).
-///
-/// ```rust
-/// #[tokio::main(flavor = "local")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .build_local(tokio::runtime::LocalOptions::default())
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
-///
-///
-/// ## Set number of worker threads
+/// ### Set number of worker threads
 ///
 /// ```rust
 /// #[tokio::main(worker_threads = 2)]
@@ -210,7 +149,7 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Configure the runtime to start with time paused
+/// ### Configure the runtime to start with time paused
 ///
 /// ```rust
 /// #[tokio::main(flavor = "current_thread", start_paused = true)]
@@ -236,7 +175,7 @@ use proc_macro::TokenStream;
 ///
 /// Note that `start_paused` requires the `test-util` feature to be enabled.
 ///
-/// ## Rename package
+/// ### Rename package
 ///
 /// ```rust
 /// use tokio as tokio1;
@@ -262,55 +201,8 @@ use proc_macro::TokenStream;
 ///         })
 /// }
 /// ```
-///
-/// ## Configure unhandled panic behavior
-///
-/// Available options are `shutdown_runtime` and `ignore`. For more details, see
-/// [`Builder::unhandled_panic`].
-///
-/// This option is only compatible with the `current_thread` runtime.
-///
-/// ```no_run
-/// #[cfg(tokio_unstable)]
-/// #[tokio::main(flavor = "current_thread", unhandled_panic = "shutdown_runtime")]
-/// async fn main() {
-///     let _ = tokio::spawn(async {
-///         panic!("This panic will shutdown the runtime.");
-///     }).await;
-/// }
-/// # #[cfg(not(tokio_unstable))]
-/// # fn main() { }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```no_run
-/// #[cfg(tokio_unstable)]
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .unhandled_panic(tokio::runtime::UnhandledPanic::ShutdownRuntime)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             let _ = tokio::spawn(async {
-///                 panic!("This panic will shutdown the runtime.");
-///             }).await;
-///         })
-/// }
-/// # #[cfg(not(tokio_unstable))]
-/// # fn main() { }
-/// ```
-///
-/// **Note**: This option depends on Tokio's [unstable API][unstable]. See [the
-/// documentation on unstable features][unstable] for details on how to enable
-/// Tokio's unstable features.
-///
-/// [`Builder::unhandled_panic`]: ../tokio/runtime/struct.Builder.html#method.unhandled_panic
-/// [unstable]: ../tokio/index.html#unstable-features
-/// [local runtime]: ../tokio/runtime/struct.LocalRuntime.html
-/// [bridging]: https://tokio.rs/tokio/topics/bridging#what-tokiomain-expands-to
 #[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()
 }
@@ -375,6 +267,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()
 }
@@ -421,31 +314,6 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ## Usage
 ///
-/// ### Set the name of the runtime
-///
-/// ```no_run
-/// #[tokio::test(name = "my-test-runtime")]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .name("my-test-runtime")
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
 /// ### Using the multi-thread runtime
 ///
 /// ```no_run
@@ -497,7 +365,7 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ### Set number of worker threads
 ///
 /// ```no_run
-/// #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+/// #[tokio::test(flavor ="multi_thread", worker_threads = 2)]
 /// async fn my_test() {
 ///     assert!(true);
 /// }
@@ -556,53 +424,6 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 ///     println!("Hello world");
 /// }
 /// ```
-///
-/// ### Configure unhandled panic behavior
-///
-/// Available options are `shutdown_runtime` and `ignore`. For more details, see
-/// [`Builder::unhandled_panic`].
-///
-/// This option is only compatible with the `current_thread` runtime.
-///
-/// ```no_run
-/// #[cfg(tokio_unstable)]
-/// #[tokio::test(flavor = "current_thread", unhandled_panic = "shutdown_runtime")]
-/// async fn my_test() {
-///     let _ = tokio::spawn(async {
-///         panic!("This panic will shutdown the runtime.");
-///     }).await;
-/// }
-///
-/// # fn main() { }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[cfg(tokio_unstable)]
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .unhandled_panic(UnhandledPanic::ShutdownRuntime)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             let _ = tokio::spawn(async {
-///                 panic!("This panic will shutdown the runtime.");
-///             }).await;
-///         })
-/// }
-///
-/// # fn main() { }
-/// ```
-///
-/// **Note**: This option depends on Tokio's [unstable API][unstable]. See [the
-/// documentation on unstable features][unstable] for details on how to enable
-/// Tokio's unstable features.
-///
-/// [`Builder::unhandled_panic`]: ../tokio/runtime/struct.Builder.html#method.unhandled_panic
-/// [unstable]: ../tokio/index.html#unstable-features
 #[proc_macro_attribute]
 pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::test(args.into(), item.into(), true).into()

tokio-macros/src/select.rs

@@ -11,7 +11,7 @@ pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
     };
 
     let variants = (0..branches)
-        .map(|num| Ident::new(&format!("_{num}"), Span::call_site()))
+        .map(|num| Ident::new(&format!("_{}", num), Span::call_site()))
         .collect::<Vec<_>>();
 
     // Use a bitfield to track which futures completed
@@ -73,27 +73,27 @@ fn clean_pattern(pat: &mut syn::Pat) {
             }
         }
         syn::Pat::Or(or) => {
-            for case in &mut or.cases {
+            for case in or.cases.iter_mut() {
                 clean_pattern(case);
             }
         }
         syn::Pat::Slice(slice) => {
-            for elem in &mut slice.elems {
+            for elem in slice.elems.iter_mut() {
                 clean_pattern(elem);
             }
         }
         syn::Pat::Struct(struct_pat) => {
-            for field in &mut struct_pat.fields {
+            for field in struct_pat.fields.iter_mut() {
                 clean_pattern(&mut field.pat);
             }
         }
         syn::Pat::Tuple(tuple) => {
-            for elem in &mut tuple.elems {
+            for elem in tuple.elems.iter_mut() {
                 clean_pattern(elem);
             }
         }
         syn::Pat::TupleStruct(tuple) => {
-            for elem in &mut tuple.elems {
+            for elem in tuple.elems.iter_mut() {
                 clean_pattern(elem);
             }
         }

tokio-stream/CHANGELOG.md

@@ -1,99 +1,3 @@
-# 0.1.19 (July 22nd, 2026)
-
-### Added
-
-- stream: implement `FromStream` for standard collections ([#7954], [#7966])
-- stream: implement `FusedStream` for various stream adaptors ([#7854], [#8090], [#8096])
-- stream: implement `Peekable::size_hint` ([#8109])
-- task: add `JoinSetStream` wrapper for `JoinSet` ([#8189])
-
-### Changed
-
-- stream: bump minimum required `tokio` version to `1.38.0` ([#7887])
-- stream: use cooperative budgeting in `tokio_stream::iter` ([#8218])
-- stream: update coop handling for `empty` and `once` ([#8227])
-
-### Fixed
-
-- stream: fix overflow in `StreamMap::size_hint` ([#8216])
-- stream: honor `StreamMap::next_many` limit ([#8215])
-- stream: stop polling underlying stream once `map_while` yields `None` ([#8233])
-
-[#7854]: https://github.com/tokio-rs/tokio/pull/7854
-[#7887]: https://github.com/tokio-rs/tokio/pull/7887
-[#7954]: https://github.com/tokio-rs/tokio/pull/7954
-[#7966]: https://github.com/tokio-rs/tokio/pull/7966
-[#8090]: https://github.com/tokio-rs/tokio/pull/8090
-[#8096]: https://github.com/tokio-rs/tokio/pull/8096
-[#8109]: https://github.com/tokio-rs/tokio/pull/8109
-[#8189]: https://github.com/tokio-rs/tokio/pull/8189
-[#8215]: https://github.com/tokio-rs/tokio/pull/8215
-[#8216]: https://github.com/tokio-rs/tokio/pull/8216
-[#8218]: https://github.com/tokio-rs/tokio/pull/8218
-[#8227]: https://github.com/tokio-rs/tokio/pull/8227
-[#8233]: https://github.com/tokio-rs/tokio/pull/8233
-
-# 0.1.18 (January 4th, 2026)
-
-### Added
-
-- stream: add `ChunksTimeout::into_remainder` ([#7715])
-- stream: add examples to wrapper types ([#7024])
-- sync: implement `Stream::size_hint` for `ReceiverStream` and `UnboundedReceiverStream` ([#7492])
-
-### Fixed
-
-- stream: work around the rustc bug in `StreamExt::collect` ([#7754])
-
-### Documented
-
-- stream: improve the docs of `TcpListenerStream` ([#7578])
-
-[#7024]: https://github.com/tokio-rs/tokio/pull/7024
-[#7492]: https://github.com/tokio-rs/tokio/pull/7492
-[#7578]: https://github.com/tokio-rs/tokio/pull/7578
-[#7715]: https://github.com/tokio-rs/tokio/pull/7715
-[#7754]: https://github.com/tokio-rs/tokio/pull/7754
-
-# 0.1.17 (December 6th, 2024)
-
-- deps: fix dev-dependency on tokio-test ([#6931], [#7019])
-- stream: fix link on `Peekable` ([#6861])
-- sync: fix `Stream` link in broadcast docs ([#6873])
-
-[#6861]: https://github.com/tokio-rs/tokio/pull/6861
-[#6873]: https://github.com/tokio-rs/tokio/pull/6873
-[#6931]: https://github.com/tokio-rs/tokio/pull/6931
-[#7019]: https://github.com/tokio-rs/tokio/pull/7019
-
-# 0.1.16 (September 5th, 2024)
-
-This release bumps the MSRV of tokio-stream to 1.70.
-
-- stream: add `next_many` and `poll_next_many` to `StreamMap` ([#6409])
-- stream: make stream adapters public ([#6658])
-- readme: add readme for tokio-stream ([#6456])
-
-[#6409]: https://github.com/tokio-rs/tokio/pull/6409
-[#6658]: https://github.com/tokio-rs/tokio/pull/6658
-[#6456]: https://github.com/tokio-rs/tokio/pull/6456
-
-# 0.1.15 (March 14th, 2024)
-
-This release bumps the MSRV of tokio-stream to 1.63.
-
-- docs: fix typo in argument name ([#6389])
-- docs: fix typo in peekable docs ([#6130])
-- docs: link to latest version of tokio-util docs ([#5694])
-- docs: typographic improvements ([#6262])
-- stream: add `StreamExt::peekable` ([#6095])
-
-[#5694]: https://github.com/tokio-rs/tokio/pull/5694
-[#6095]: https://github.com/tokio-rs/tokio/pull/6095
-[#6130]: https://github.com/tokio-rs/tokio/pull/6130
-[#6262]: https://github.com/tokio-rs/tokio/pull/6262
-[#6389]: https://github.com/tokio-rs/tokio/pull/6389
-
 # 0.1.14 (April 26th, 2023)
 
 This bugfix release bumps the minimum version of Tokio to 1.15, which is

tokio-stream/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "tokio-stream"
 # When releasing to crates.io:
-# - Remove path dependencies (if any)
+# - Remove path dependencies
 # - Update CHANGELOG.md.
 # - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.19"
+version = "0.1.14"
 edition = "2021"
-rust-version = "1.71"
+rust-version = "1.56"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
@@ -24,7 +24,6 @@ full = [
     "net",
     "io-util",
     "fs",
-    "rt",
     "sync",
     "signal"
 ]
@@ -33,21 +32,20 @@ time = ["tokio/time"]
 net = ["tokio/net"]
 io-util = ["tokio/io-util"]
 fs = ["tokio/fs"]
-rt = ["tokio/rt"]
 sync = ["tokio/sync", "tokio-util"]
 signal = ["tokio/signal"]
 
 [dependencies]
 futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.11"
-tokio = { version = "1.38.0", features = ["sync"] }
-tokio-util = { version = "0.7.0", optional = true }
+pin-project-lite = "0.2.0"
+tokio = { version = "1.15.0", path = "../tokio", features = ["sync"] }
+tokio-util = { version = "0.7.0", path = "../tokio-util", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.38.0", features = ["full", "test-util"] }
+tokio = { version = "1.2.0", path = "../tokio", features = ["full", "test-util"] }
 async-stream = "0.3"
 parking_lot = "0.12.0"
-tokio-test = "0.4"
+tokio-test = { path = "../tokio-test" }
 futures = { version = "0.3", default-features = false }
 
 [package.metadata.docs.rs]
@@ -58,6 +56,3 @@ rustdoc-args = ["--cfg", "docsrs"]
 # This should allow `docsrs` to be read across projects, so that `tokio-stream`
 # can pick up stubbed types exported by `tokio`.
 rustc-args = ["--cfg", "docsrs"]
-
-[lints]
-workspace = true

tokio-stream/LICENSE

@@ -1,21 +1,25 @@
-MIT License
+Copyright (c) 2023 Tokio Contributors
 
-Copyright (c) Tokio Contributors
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

tokio-stream/README.md

@@ -1,13 +0,0 @@
-# tokio-stream
-
-Utilities to work with `Stream` and `tokio`.
-
-## License
-
-This project is licensed under the [MIT license](LICENSE).
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you, shall be licensed as MIT, without any additional
-terms or conditions.

tokio-stream/fuzz/Cargo.toml

@@ -2,7 +2,7 @@
 name = "tokio-stream-fuzz"
 version = "0.0.0"
 publish = false
-edition = "2021"
+edition = "2018"
 
 [package.metadata]
 cargo-fuzz = true