runtime: fix remote abort (#3942)

Co-authored-by: @tijsvd

.cirrus.yml

@@ -1,66 +1,19 @@
-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-14-2
-env:
-  RUST_STABLE: stable
-  RUST_NIGHTLY: nightly-2025-01-25
-  RUSTFLAGS: -D warnings
-  # This excludes unstable features like io_uring, which require '--cfg tokio_unstable'.
-  TOKIO_STABLE_FEATURES: full,test-util
+  image: freebsd-12-2-release-amd64
 
 # 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 --features $TOKIO_STABLE_FEATURES
-    # Free the disk space before the next build,
-    # otherwise cirrus-ci complains about "No space left on device".
-    - cargo clean
-    # Enable all unstable features except `taskdump`, which is Linux-only.
-    - |
-      RUSTFLAGS="$RUSTFLAGS --cfg tokio_unstable" \
-      RUSTDOCFLAGS="$RUSTDOCFLAGS --cfg tokio_unstable" \
-        cargo test \
-          --features $TOKIO_STABLE_FEATURES,io-uring,tracing
-
-task:
-  name: FreeBSD docs
+  name: FreeBSD
   env:
-    RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-    RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+    LOOM_MAX_PREEMPTIONS: 2
+    RUSTFLAGS: -Dwarnings
   setup_script:
-    - pkg install -y bash
+    - pkg install -y bash curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_NIGHTLY
-    - . $HOME/.cargo/env
-    - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
-  test_script:
-    - . $HOME/.cargo/env
-    # We use `--features $TOKIO_STABLE_FEATURES,io-uring,tracing` instead of
-    # `--all-features` to exclude `taskdump`, which is Linux-only.
-    - cargo doc --lib --no-deps --features $TOKIO_STABLE_FEATURES,io-uring,tracing --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
+    - sh rustup.sh -y --profile minimal --default-toolchain stable
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - |
@@ -68,4 +21,9 @@ task:
       rustc --version
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --features $TOKIO_STABLE_FEATURES --target i686-unknown-freebsd
+    - cargo test --all
+    - cargo doc --all --no-deps
+  i686_test_script:
+    - . $HOME/.cargo/env
+    - |
+      cargo test --all --target i686-unknown-freebsd

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: [tokio-rs]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,7 +9,12 @@ assignees: ''
 
 **Version**
 List the versions of all `tokio` crates you are using. The easiest way to get
-this information is using `cargo tree` subcommand:
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
 
 `cargo tree | grep tokio`
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +0,0 @@
-contact_links:
-  - name: Question
-    url: https://github.com/tokio-rs/tokio/discussions
-    about: Questions about Tokio should be posted as a GitHub discussion.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,16 @@
+---
+name: Question
+about: Please use the discussions tab for questions
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Please post your question as a discussion here:
+https://github.com/tokio-rs/tokio/discussions
+
+
+You may also be able to find help here:
+https://discord.gg/tokio
+https://users.rust-lang.org/

.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/labeler.yml

@@ -1,21 +0,0 @@
-
-R-loom-sync:
-- tokio/src/sync/*
-- tokio/src/sync/**/*
-
-R-loom-time-driver:
-- tokio/src/runtime/time/*
-- tokio/src/runtime/time/**/*
-
-R-loom-current-thread:
-- tokio/src/runtime/scheduler/*
-- tokio/src/runtime/scheduler/current_thread/*
-- tokio/src/runtime/task/*
-- tokio/src/runtime/task/**
-
-R-loom-multi-thread:
-- tokio/src/runtime/scheduler/*
-- tokio/src/runtime/scheduler/multi_thread/*
-- tokio/src/runtime/scheduler/multi_thread/**
-- tokio/src/runtime/task/*
-- tokio/src/runtime/task/**

.github/workflows/audit.yml

@@ -9,16 +9,14 @@ on:
   schedule:
     - cron: '0 2 * * *' # run at 2 AM UTC
 
-permissions:
-  contents: read
-
 jobs:
-  cargo-deny:
-    permissions:
-      checks: write
-      contents: read
-      issues: write
+  security-audit:
     runs-on: ubuntu-latest
+    if: "!contains(github.event.head_commit.message, 'ci skip')"
     steps:
-    - uses: actions/checkout@v5
-    - uses: EmbarkStudios/cargo-deny-action@v2
+      - uses: actions/checkout@v2
+
+      - name: Audit Check
+        uses: actions-rs/audit-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/bench.yml

@@ -0,0 +1,55 @@
+name: Benchmark
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  benchmark:
+    name: Benchmark
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        bench:
+          - rt_multi_threaded
+          - sync_mpsc
+          - sync_rwlock
+          - sync_semaphore
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
+
+      # Run benchmark with `go test -bench` and stores the output to a file
+      - name: Run benchmark
+        run: cargo bench --bench ${{ matrix.bench }} | tee ../output.txt
+        working-directory: benches
+
+      # Download previous benchmark result from cache (if exists)
+      - name: Download previous benchmark data
+        uses: actions/cache@v1
+        with:
+          path: ./cache
+          key: ${{ runner.os }}-benchmark
+
+      # Run `github-action-benchmark` action
+      - name: Store benchmark result
+        uses: rhysd/github-action-benchmark@v1
+        with:
+          name: ${{ matrix.bench }}
+          # What benchmark tool the output.txt came from
+          tool: 'cargo'
+          # Where the output from the benchmark tool is stored
+          output-file-path: output.txt
+          # # Where the previous data file is stored
+          # external-data-json-path: ./cache/benchmark-data.json
+          # Workflow will fail when an alert happens
+          fail-on-alert: true
+          # GitHub API token to make a commit comment
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          # Enable alert commit comment
+          comment-on-alert: true
+          alert-comment-cc-users: '@tokio-rs/maintainers'
+          auto-push: true
+
+      # Upload the updated cache file for the next job by actions/cache

.github/workflows/labeler.yml

@@ -1,25 +0,0 @@
-name: "Pull Request Labeler"
-on:
-- pull_request_target
-
-# See .github/labeler.yml file
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  triage:
-    permissions:
-      contents: read  # for actions/labeler to determine modified files
-      pull-requests: write  # for actions/labeler to add labels to PRs
-    runs-on: ubuntu-latest
-    if: github.repository_owner == 'tokio-rs'
-    steps:
-    - uses: actions/labeler@v3
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
-        sync-labels: true

.github/workflows/loom.yml

@@ -1,97 +0,0 @@
-on:
-  push:
-    branches: ["master", "tokio-*.x"]
-  pull_request:
-    types: [labeled, opened, synchronize, reopened]
-    branches: ["master", "tokio-*.x"]
-
-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
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: stable
-
-permissions:
-  contents: read
-
-jobs:
-  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@v5
-      - 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@v5
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: run tests
-        run: cargo test --lib --release --features full -- --nocapture runtime::time::tests
-        working-directory: tokio
-
-  loom-current-thread:
-    name: loom current-thread scheduler
-    # base_ref is null when it's not a pull request
-    if: github.repository_owner == 'tokio-rs' && (contains(github.event.pull_request.labels.*.name, 'R-loom-current-thread') || (github.base_ref == null))
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - 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))
-    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
-    steps:
-      - uses: actions/checkout@v5
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - uses: Swatinem/rust-cache@v2
-      - name: loom ${{ matrix.scope }}
-        run: cargo test --lib --release --features full -- --nocapture $SCOPE
-        working-directory: tokio
-        env:
-          SCOPE: ${{ matrix.scope }}

.github/workflows/pr-audit.yml

@@ -8,16 +8,25 @@ 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@v5
-    - uses: EmbarkStudios/cargo-deny-action@v2
+      - uses: actions/checkout@v2
+
+      - name: Install cargo-audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-audit
+
+      - name: Generate lockfile
+        uses: actions-rs/cargo@v1
+        with:
+          command: generate-lockfile
+
+      - name: Audit dependencies
+        uses: actions-rs/cargo@v1
+        with:
+          command: audit

.github/workflows/stress-test.yml

@@ -5,21 +5,8 @@ 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
-
-permissions:
-  contents: read
-
 jobs:
-  stress-test:
+  stess-test:
     name: Stress Test
     runs-on: ubuntu-latest
     strategy:
@@ -27,19 +14,19 @@ jobs:
         stress-test:
           - simple_echo_tcp
     steps:
-      - uses: actions/checkout@v5
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-            toolchain: ${{ env.rust_stable }}
-      - name: Install Valgrind
-        uses: taiki-e/install-action@valgrind
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: rustup update stable
+
+      - name: Install Valgrind
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y valgrind
 
-      - uses: Swatinem/rust-cache@v2
       # Compiles each of the stress test examples.
       - name: Compile stress test examples
         run: cargo build -p stress-test --release --example ${{ matrix.stress-test }}
 
       # Runs each of the examples using Valgrind. Detects leaks and displays them.
       - name: Run valgrind
-        run: valgrind --error-exitcode=1 --leak-check=full --show-leak-kinds=all --fair-sched=yes ./target/release/examples/${{ matrix.stress-test }}
+        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

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

@@ -1,103 +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@v5
-
-      - 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@v4
-        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)
-
-      - 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
-        run: |
-          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 always exits with 0, so we check if the tests passed by using grep.
-          if grep -q "test result: FAILED" qemu-output.log; then
-            echo "tests failed (QEMU exited abnormally)"
-            exit 1
-          else
-            echo "all tests passed"
-          fi

.gitignore

@@ -1,5 +1,2 @@
 target
 Cargo.lock
-
-.cargo/config.toml
-.cargo/config

CONTRIBUTING.md

@@ -124,67 +124,26 @@ 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
--->
-
+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:
 ```
-cargo +1.88 clippy --all --tests --all-features
+RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --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')
+rustfmt --check --edition 2018 $(find . -name '*.rs' -print)
 
 # Powershell
-Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2021 $_.FullName }
+Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2018 $_.FullName }
 ```
 The `--check` argument prints the things that need to be fixed. If you remove
 it, `rustfmt` will update your files locally instead.
@@ -192,35 +151,9 @@ 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" \
+LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
     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 -Zmiri-retag-fields" \
-    cargo +nightly miri test --features full --lib --tests
-```
-
-### Performing spellcheck on tokio codebase
-
-You can perform spell-check on 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
 
@@ -228,22 +161,8 @@ If the change being proposed alters code (as opposed to only documentation for
 example), it is either adding new functionality to Tokio or it is fixing
 existing, broken functionality. In both of these cases, the pull request should
 include one or more tests to ensure that Tokio does not regress in the future.
-There are two ways to write tests: [integration tests][integration-tests]
-and [documentation tests][documentation-tests].
-(Tokio avoids [unit tests][unit-tests] as much as possible).
-
-Tokio uses [conditional compilation attributes][conditional-compilation]
-throughout the codebase, to modify rustc's behavior. Code marked with such
-attributes can be enabled using RUSTFLAGS and RUSTDOCFLAGS environment
-variables. One of the most prevalent flags passed in these variables is
-the `--cfg` option. To run tests in a particular file, check first what
-options #![cfg] declaration defines for that file.
-
-For instance, to run a test marked with the 'tokio_unstable' cfg option,
-you must pass this flag to the compiler when running the test.
-```
-$ RUSTFLAGS="--cfg tokio_unstable" cargo test -p tokio --all-features --test rt_metrics
-```
+There are two ways to write tests: integration tests and documentation tests
+(Tokio avoids unit tests as much as possible).
 
 #### Integration tests
 
@@ -254,31 +173,6 @@ utilities available to use in tests, no matter the crate being tested.
 The best strategy for writing a new integration test is to look at existing
 integration tests in the crate and follow the style.
 
-#### Fuzz tests
-
-Some of our crates include a set of fuzz tests, this will be marked by a
-directory `fuzz`. It is a good idea to run fuzz tests after each change.
-To get started with fuzz testing you'll need to install
-[cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz).
-
-`cargo install --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
@@ -355,29 +249,6 @@ example would explicitly use `Timeout::new`. For example:
 /// # }
 ```
 
-### 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.
-
 ### Commits
 
 It is a recommended best practice to keep your changes as logically grouped as
@@ -401,16 +272,14 @@ A good commit message should describe what changed and why.
     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
+  * 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:
 
-  * time: introduce `Timeout` and deprecate `Deadline`
-  * codec: export `Encoder`, `Decoder`, `Framed*`
-  * ci: fix the FreeBSD ci configuration
+  * 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).
@@ -427,7 +296,7 @@ A good commit message should describe what changed and why.
 Sample complete commit message:
 
 ```txt
-module: explain the commit in one line
+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
@@ -558,14 +427,11 @@ _Adapted from the [Node.js contributing guide][node]_.
 
 ## 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.
+The Tokio GitHub repository has a lot of issues and PRs, which is not easy 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.
 
-### Area
-
-The area label describes the crates relevant to this issue or PR.
+**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.
@@ -576,7 +442,7 @@ The area label describes the crates relevant to this issue or PR.
    be used for the procedural macros, and not `join!` or `select!`.
  - **A-ci** This issue concerns our GitHub Actions setup.
 
-### Category
+**Category.** The category label describes the 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.
@@ -594,7 +460,8 @@ The area label describes the crates relevant to this issue or PR.
  - **C-request** A non-feature request, e.g. "please add deprecation notices to
    `-alpha.*` versions of crates"
 
-### Calls for participation
+**Call for participation.** I don't know why it's called `E-`. Many issues are
+missing a difficulty rating, and you should feel free to add one.
 
  - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
    or `C-feature-accepted`.
@@ -606,13 +473,7 @@ The area label describes the crates relevant to this issue or PR.
  - **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**.
+**Module.** A more fine groaned categorization than area.
 
  - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
  - **M-codec** The `tokio_util::codec` module.
@@ -625,14 +486,13 @@ The module label provides a more fine grained categorization than **Area**.
  - **M-process** The `tokio::process` module.
  - **M-runtime** The `tokio::runtime` module.
  - **M-signal** The `tokio::signal` module.
+ - **M-stream** The `tokio::stream` 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.
+**Topic.** Some extra information.
 
  - **T-docs** This is about documentation.
  - **T-performance** This is about performance.
@@ -642,34 +502,6 @@ Any label not listed here is not in active use.
 
 [project]: https://github.com/orgs/tokio-rs/projects/1
 
-## LTS guarantees
-
-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.
-
-## 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.
-
-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
@@ -702,8 +534,9 @@ When releasing a new version of a crate, follow these steps:
 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.
+3. **Update other documentation links.** Update the `#![doc(html_root_url)]`
+   attribute in the crate's `lib.rs` and 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
@@ -728,7 +561,3 @@ When releasing a new version of a crate, follow these steps:
    entry for that release version into your editor and close the window.
 
 [keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md
-[unit-tests]: https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html
-[integration-tests]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
-[documentation-tests]: https://doc.rust-lang.org/rust-by-example/testing/doc_testing.html
-[conditional-compilation]: https://doc.rust-lang.org/reference/conditional-compilation.html

Cargo.toml

@@ -1,10 +1,9 @@
 [workspace]
-resolver = "2"
+
 members = [
   "tokio",
   "tokio-macros",
   "tokio-test",
-  "tokio-stream",
   "tokio-util",
 
   # Internal
@@ -14,19 +13,3 @@ members = [
   "tests-build",
   "tests-integration",
 ]
-
-[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"))',
-] }

Cross.toml

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

LICENSE

@@ -1,21 +1,25 @@
-MIT License
+Copyright (c) 2019 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

@@ -29,6 +29,7 @@ the Rust programming language. It is:
 [Website](https://tokio.rs) |
 [Guides](https://tokio.rs/tokio/tutorial) |
 [API Docs](https://docs.rs/tokio/latest/tokio) |
+[Roadmap](https://github.com/tokio-rs/tokio/blob/master/ROADMAP.md) |
 [Chat](https://discord.gg/tokio)
 
 ## Overview
@@ -39,7 +40,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
@@ -50,23 +51,15 @@ an asynchronous application.
 
 ## Example
 
-A basic TCP echo server with Tokio.
-
-Make sure you activated the full features of the tokio crate on Cargo.toml:
-
-```toml
-[dependencies]
-tokio = { version = "1.48.0", features = ["full"] }
-```
-Then, on your main.rs:
+A basic TCP echo server with Tokio:
 
 ```rust,no_run
 use tokio::net::TcpListener;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+    let mut listener = TcpListener::bind("127.0.0.1:8080").await?;
 
     loop {
         let (mut socket, _) = listener.accept().await?;
@@ -78,7 +71,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);
@@ -132,8 +125,6 @@ project.
 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.
@@ -142,105 +133,33 @@ several other libraries, including:
 
 * [`tower`]: A library of modular and reusable components for building robust networking clients and servers.
 
-* [`tracing`] (formerly `tokio-trace`): A framework for application-level tracing and async-aware diagnostics.
+* [`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
 
-## Changelog
-
-The Tokio repository contains multiple crates. Each crate has its own changelog.
-
- * `tokio` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio/CHANGELOG.md)
- * `tokio-util` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-util/CHANGELOG.md)
- * `tokio-stream` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-stream/CHANGELOG.md)
- * `tokio-macros` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-macros/CHANGELOG.md)
- * `tokio-test` - [view changelog](https://github.com/tokio-rs/tokio/blob/master/tokio-test/CHANGELOG.md)
-
 ## Supported Rust Versions
 
-<!--
-When updating this, also update:
-- .github/workflows/ci.yml
-- CONTRIBUTING.md
-- README.md
-- tokio/README.md
-- tokio/Cargo.toml
-- tokio-util/Cargo.toml
-- tokio-test/Cargo.toml
-- tokio-stream/Cargo.toml
--->
-
-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.
-
-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.17 to 1.26 - Rust 1.49
- * 1.15 to 1.16 - Rust 1.46
- * 1.0 to 1.14 - Rust 1.45
-
-Note that although we try to avoid the situation where a dependency transitively
-increases the MSRV of Tokio, we do not guarantee that this does not happen.
-However, every minor release will have some set of versions of dependencies that
-works with the MSRV of that minor release.
-
-## 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.
-
-## Bug patching policy
-
-For the purposes of making patch releases with bugfixes, we have designated
-certain minor releases as LTS (long term support) releases. Whenever a bug
-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.43.x` - LTS release until March 2026. (MSRV 1.70)
- * `1.47.x` - LTS release until September 2026. (MSRV 1.70)
-
-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.43.x` patch release, you
-can use the following dependency specification:
-```text
-tokio = { version = "~1.43", 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.
+Tokio is built against the latest stable release. The minimum supported version is 1.45.
+The current Tokio version is not guaranteed to build on Rust versions earlier than the
+minimum supported version.
 
 ## License
 

ROADMAP.md

@@ -0,0 +1,67 @@
+# Tokio Roadmap
+
+## A Roadmap to 1.0
+
+The question of "why not 1.0?" has come up a few times. After all, Tokio 0.1 has
+been stable for three years. The short answer: because it isn't time. There is
+nobody who would rather ship a Tokio 1.0 than us. It also isn't something to rush.
+
+After all, `async / await` only landed in the stable Rust channel weeks ago.
+There has been no significant production validation yet, except maybe fuchsia
+and that seems like a fairly specialized use case. This release of Tokio
+includes significant new code and new strategies with feature flags. Also, there
+are still big open questions, such as the [proposed changes][pr-1744] to
+`AsyncRead` and `AsyncWrite`.
+
+Tokio 1.0 will be released as soon as the APIs are proven to handle real-world
+production cases.
+
+### Tokio 1.0 in Q3 2020 with LTS support
+
+The Tokio 1.0 release will be **no later** than Q3 2020. It will also come with
+"long-term support" guarantees:
+
+* A minimum of 5 years of maintenance.
+* A minimum of 3 years before a hypothetical 2.0 release.
+
+When Tokio 1.0 is released in Q3 2020, on-going support, security fixes, and
+critical bug fixes are guaranteed until **at least** Q3 2025. Tokio 2.0 will not
+be released until **at least** Q3 2023 (though, ideally there will never be a
+Tokio 2.0 release).
+
+### How to get there
+
+While Tokio 0.1 probably should have been a 1.0, Tokio 0.2 will be a **true**
+0.2 release. There will be breaking change releases every 2 ~ 3 months until 1.0.
+These changes will be **much** smaller than going from 0.1 -> 0.2. It is
+expected that the 1.0 release will look a lot like 0.2.
+
+### What is expected to change
+
+The biggest change will be the `AsyncRead` and `AsyncWrite` traits. Based on
+experience gained over the past 3 years, there are a couple of issues to
+address:
+
+* Be able to **safely** use uninitialized memory as a read buffer.
+* Practical read vectored and write vectored APIs.
+
+There are a few strategies to solve these problems. These strategies need to be
+investigated and the solution validated. You can see [this comment][pr-1744-comment] for a
+detailed statement of the problem.
+
+The other major change, which has been in the works for a while, is updating
+Mio. Mio 0.6 was first released almost 4 years ago and has not had a breaking
+change since. Mio 0.7 has been in the works for a while. It includes a full
+rewrite of the windows support as well as a refined API. More will be written
+about this shortly.
+
+Finally, now that the API is starting to stabilize, effort will be put into
+documentation. Tokio 0.2 is being released before updating the website and many
+of the old content will no longer be relevant. In the coming weeks, expect to
+see updates there.
+
+So, we have our work cut out for us. We hope you enjoy this 0.2 release and are
+looking forward to your feedback and help.
+
+[pr-1744]: https://github.com/tokio-rs/tokio/pull/1744
+[pr-1744-comment]: https://github.com/tokio-rs/tokio/pull/1744#issuecomment-553575438

SECURITY.md

@@ -1,13 +1,13 @@
 ## Report a security issue
 
-The Tokio project team welcomes security reports and is committed to providing prompt attention to security issues. Security issues should be reported privately via [[email protected]](mailto:[email protected]). Security issues should not be reported via the public GitHub Issue tracker.
+The Tokio project team welcomes security reports and is committed to providing prompt attention to security issues. Security issues should be reported privately via [[email protected]](mailto:[email protected]). Security issues should not be reported via the public Github Issue tracker.
 
 ## Vulnerability coordination
 
-Remediation of security vulnerabilities is prioritized by the project team. The project team coordinates remediation with third-party project stakeholders via [GitHub Security Advisories](https://help.github.com/en/github/managing-security-vulnerabilities/about-github-security-advisories). Third-party stakeholders may include the reporter of the issue, affected direct or indirect users of Tokio, and maintainers of upstream dependencies if applicable.
+Remediation of security vulnerabilities is prioritized by the project team. The project team coordinates remediation with third-party project stakeholders via [Github Security Advisories](https://help.github.com/en/github/managing-security-vulnerabilities/about-github-security-advisories). Third-party stakeholders may include the reporter of the issue, affected direct or indirect users of Tokio, and maintainers of upstream dependencies if applicable.
 
-Downstream project maintainers and Tokio users can request participation in coordination of applicable security issues by sending your contact email address, GitHub username(s) and any other salient information to [[email protected]](mailto:[email protected]). Participation in security issue coordination processes is at the discretion of the Tokio team.
+Downstream project maintainers and Tokio users can request participation in coordination of applicable security issues by sending your contact email address, Github username(s) and any other salient information to [[email protected]](mailto:[email protected]). Participation in security issue coordination processes is at the discretion of the Tokio team.
 
 ## Security advisories
 
-The project team is committed to transparency in the security issue disclosure process. The Tokio team announces security issues via [project GitHub Release notes](https://github.com/tokio-rs/tokio/releases) and the [RustSec advisory database](https://github.com/RustSec/advisory-db) (i.e. `cargo-audit`).
+The project team is committed to transparency in the security issue disclosure process. The Tokio team announces security issues via [project Github Release notes](https://github.com/tokio-rs/tokio/releases) and the [RustSec advisory database](https://github.com/RustSec/advisory-db) (i.e. `cargo-audit`).

benches/Cargo.toml

@@ -2,21 +2,11 @@
 name = "benches"
 version = "0.0.0"
 publish = false
-edition = "2021"
-license = "MIT"
-
-[features]
-test-util = ["tokio/test-util"]
+edition = "2018"
 
 [dependencies]
-tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-criterion = "0.5.1"
-rand = "0.9"
-rand_chacha = "0.9"
-
-[dev-dependencies]
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
+tokio = { version = "0.3.0", path = "../tokio", features = ["full"] }
+bencher = "0.1.5"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.42"
@@ -26,40 +16,16 @@ 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"
 harness = false
 
-[[bench]]
-name = "sync_mpsc_oneshot"
-path = "sync_mpsc_oneshot.rs"
-harness = false
-
-[[bench]]
-name = "sync_watch"
-path = "sync_watch.rs"
-harness = false
-
-[[bench]]
-name = "rt_current_thread"
-path = "rt_current_thread.rs"
-harness = false
-
 [[bench]]
 name = "rt_multi_threaded"
 path = "rt_multi_threaded.rs"
 harness = false
 
-[[bench]]
-name = "sync_notify"
-path = "sync_notify.rs"
-harness = false
 
 [[bench]]
 name = "sync_rwlock"
@@ -75,26 +41,3 @@ harness = false
 name = "signal"
 path = "signal.rs"
 harness = false
-
-[[bench]]
-name = "fs"
-path = "fs.rs"
-harness = false
-
-[[bench]]
-name = "copy"
-path = "copy.rs"
-harness = false
-
-[[bench]]
-name = "time_now"
-path = "time_now.rs"
-harness = false
-
-[[bench]]
-name = "time_timeout"
-path = "time_timeout.rs"
-harness = false
-
-[lints]
-workspace = true

benches/copy.rs

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

benches/fs.rs

@@ -1,112 +0,0 @@
-#![cfg(unix)]
-
-use tokio_stream::StreamExt;
-
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use tokio_util::codec::{BytesCodec, FramedRead /*FramedWrite*/};
-
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use std::fs::File as StdFile;
-use std::io::Read as StdRead;
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(2)
-        .build()
-        .unwrap()
-}
-
-const BLOCK_COUNT: usize = 1_000;
-
-const BUFFER_SIZE: usize = 4096;
-const DEV_ZERO: &str = "/dev/zero";
-
-fn async_read_codec(c: &mut Criterion) {
-    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);
-
-                for _i in 0..BLOCK_COUNT {
-                    let _bytes = input_stream.next().await.unwrap();
-                }
-            };
-
-            rt.block_on(task());
-        })
-    });
-}
-
-fn async_read_buf(c: &mut Criterion) {
-    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();
-            let mut buffer = [0u8; BUFFER_SIZE];
-
-            for _i in 0..BLOCK_COUNT {
-                file.read_exact(&mut buffer).unwrap();
-            }
-        })
-    });
-}
-
-criterion_group!(
-    file,
-    async_read_std_file,
-    async_read_buf,
-    async_read_codec,
-    sync_read
-);
-criterion_main!(file);

benches/rt_current_thread.rs

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

benches/rt_multi_threaded.rs

@@ -1,177 +1,71 @@
-//! Benchmark implementation details of the threaded scheduler. These benches are
+//! Benchmark implementation details of the theaded scheduler. These benches are
 //! intended to be used as a form of regression testing and not as a general
 //! purpose benchmark demonstrating real-world performance.
 
 use tokio::runtime::{self, Runtime};
 use tokio::sync::oneshot;
 
+use bencher::{benchmark_group, benchmark_main, Bencher};
+use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::Relaxed;
-use std::sync::atomic::{AtomicBool, AtomicUsize};
 use std::sync::{mpsc, Arc};
-use std::time::{Duration, Instant};
 
-use criterion::{criterion_group, criterion_main, Criterion};
+fn spawn_many(b: &mut Bencher) {
+    const NUM_SPAWN: usize = 10_000;
 
-const NUM_WORKERS: usize = 4;
-const NUM_SPAWN: usize = 10_000;
-const STALL_DUR: Duration = Duration::from_micros(10);
-
-fn rt_multi_spawn_many_local(c: &mut Criterion) {
     let rt = rt();
 
     let (tx, rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
 
-    c.bench_function("spawn_many_local", |b| {
-        b.iter(|| {
-            rem.store(NUM_SPAWN, Relaxed);
+    b.iter(|| {
+        rem.store(NUM_SPAWN, Relaxed);
 
-            rt.block_on(async {
-                for _ in 0..NUM_SPAWN {
-                    let tx = tx.clone();
-                    let rem = rem.clone();
-
-                    tokio::spawn(async move {
-                        if 1 == rem.fetch_sub(1, Relaxed) {
-                            tx.send(()).unwrap();
-                        }
-                    });
-                }
-
-                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 yield_many(b: &mut Bencher) {
+    const NUM_YIELD: usize = 1_000;
+    const TASKS: usize = 200;
+
+    let rt = rt();
+
+    let (tx, rx) = mpsc::sync_channel(TASKS);
+
+    b.iter(move || {
+        for _ in 0..TASKS {
+            let tx = tx.clone();
+
+            rt.spawn(async move {
+                for _ in 0..NUM_YIELD {
+                    tokio::task::yield_now().await;
+                }
+
+                tx.send(()).unwrap();
+            });
+        }
+
+        for _ in 0..TASKS {
+            let _ = rx.recv().unwrap();
+        }
+    });
+}
+
+fn ping_pong(b: &mut Bencher) {
     const NUM_PINGS: usize = 1_000;
 
     let rt = rt();
@@ -179,46 +73,46 @@ fn 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,48 +123,29 @@ 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();
+        });
     });
 }
 
 fn rt() -> Runtime {
     runtime::Builder::new_multi_thread()
-        .worker_threads(NUM_WORKERS)
+        .worker_threads(4)
         .enable_all()
         .build()
         .unwrap()
 }
 
-fn stall() {
-    let now = Instant::now();
-    while now.elapsed() < STALL_DUR {
-        std::thread::yield_now();
-    }
-}
+benchmark_group!(scheduler, spawn_many, ping_pong, yield_many, chained_spawn,);
 
-criterion_group!(
-    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,
-);
-
-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,95 +2,63 @@
 //! This essentially measure the time to enqueue a task in the local and remote
 //! case.
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use bencher::{black_box, Bencher};
 
 async fn work() -> usize {
     let val = 1 + 1;
-    tokio::task::yield_now().await;
     black_box(val)
 }
 
-fn single_rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
+fn basic_scheduler_local_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
-        .unwrap()
+        .unwrap();
+    runtime.block_on(async {
+        bench.iter(|| {
+            let h = tokio::spawn(work());
+            black_box(h);
+        })
+    });
 }
 
-fn multi_rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
+fn threaded_scheduler_local_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
         .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();
+    runtime.block_on(async {
+        bench.iter(|| {
+            let h = tokio::spawn(work());
+            black_box(h);
         })
     });
 }
 
-fn basic_scheduler_spawn10(c: &mut Criterion) {
-    let runtime = single_rt();
+fn basic_scheduler_remote_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
 
-    c.bench_function("basic_scheduler_spawn10", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let mut handles = Vec::with_capacity(10);
-                for _ in 0..10 {
-                    handles.push(tokio::spawn(work()));
-                }
-                for handle in handles {
-                    assert_eq!(handle.await.unwrap(), 2);
-                }
-            });
-        })
+    bench.iter(|| {
+        let h = runtime.spawn(work());
+        black_box(h);
     });
 }
 
-fn threaded_scheduler_spawn(c: &mut Criterion) {
-    let runtime = multi_rt();
+fn threaded_scheduler_remote_spawn(bench: &mut Bencher) {
+    let runtime = tokio::runtime::Builder::new_multi_thread().build().unwrap();
 
-    c.bench_function("threaded_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
+    bench.iter(|| {
+        let h = runtime.spawn(work());
+        black_box(h);
     });
 }
 
-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,
-    threaded_scheduler_spawn,
-    threaded_scheduler_spawn10,
+    basic_scheduler_local_spawn,
+    threaded_scheduler_local_spawn,
+    basic_scheduler_remote_spawn,
+    threaded_scheduler_remote_spawn
 );
 
-criterion_main!(spawn);
+bencher::benchmark_main!(spawn);

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

benches/sync_mpsc_oneshot.rs

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

benches/sync_notify.rs

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

benches/sync_rwlock.rs

@@ -1,30 +1,26 @@
+use bencher::{black_box, Bencher};
 use std::sync::Arc;
 use tokio::{sync::RwLock, task};
 
-use criterion::measurement::WallTime;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkGroup, Criterion};
-
-fn read_uncontended(g: &mut BenchmarkGroup<WallTime>) {
+fn read_uncontended(b: &mut Bencher) {
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(6)
         .build()
         .unwrap();
 
     let lock = Arc::new(RwLock::new(()));
-    g.bench_function("read", |b| {
-        b.iter(|| {
-            let lock = lock.clone();
-            rt.block_on(async move {
-                for _ in 0..6 {
-                    let read = lock.read().await;
-                    let _read = black_box(read);
-                }
-            })
+    b.iter(|| {
+        let lock = lock.clone();
+        rt.block_on(async move {
+            for _ in 0..6 {
+                let read = lock.read().await;
+                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()
@@ -32,57 +28,53 @@ fn read_concurrent_uncontended_multi(g: &mut BenchmarkGroup<WallTime>) {
 
     async fn task(lock: Arc<RwLock<()>>) {
         let read = lock.read().await;
-        let _read = black_box(read);
+        black_box(read);
     }
 
     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();
 
     async fn task(lock: Arc<RwLock<()>>) {
         let read = lock.read().await;
-        let _read = black_box(read);
+        black_box(read);
     }
 
     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()
@@ -90,74 +82,61 @@ fn read_concurrent_contended_multi(g: &mut BenchmarkGroup<WallTime>) {
 
     async fn task(lock: Arc<RwLock<()>>) {
         let read = lock.read().await;
-        let _read = black_box(read);
+        black_box(read);
     }
 
     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();
 
     async fn task(lock: Arc<RwLock<()>>) {
         let read = lock.read().await;
-        let _read = black_box(read);
+        black_box(read);
     }
 
     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,85 +0,0 @@
-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)
-        .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_resubscribe<const N_TASKS: usize>(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-    let (snd, _) = watch::channel(0i32);
-    let snd = Arc::new(snd);
-    let wg = Arc::new((AtomicU64::new(0), Notify::new()));
-    for n in 0..N_TASKS {
-        let mut rcv = snd.subscribe();
-        let wg = wg.clone();
-        let mut rng = rand::rngs::StdRng::seed_from_u64(n as u64);
-        rt.spawn(async move {
-            while rcv.changed().await.is_ok() {
-                let _ = *rcv.borrow(); // contend on rwlock
-                let r = do_work(&mut rng);
-                let _ = black_box(r);
-                if wg.0.fetch_sub(1, Ordering::Release) == 1 {
-                    wg.1.notify_one();
-                }
-            }
-        });
-    }
-
-    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();
-                }
-            });
-        })
-    });
-}
-
-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();
-}
-
-criterion_group!(contention, bench_contention_resubscribe);
-
-criterion_main!(contention);

benches/time_now.rs

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

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"

examples/Cargo.toml

@@ -2,54 +2,40 @@
 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**.
+# [dependencies] instead.
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full", "tracing"] }
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-
+tokio = { version = "0.3.0", path = "../tokio", features = ["full", "tracing"] }
 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"
+tracing-subscriber = { version = "0.2.7", default-features = false, features = ["fmt", "ansi", "env-filter", "chrono", "tracing-log"] }
+tokio-util = { version = "0.5.0", path = "../tokio-util", features = ["full"] }
+bytes = "0.6"
+futures = "0.3.0"
+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(all(tokio_unstable, target_os = "linux"))'.dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full", "tracing", "taskdump"] }
-
-[target.'cfg(windows)'.dev-dependencies.windows-sys]
-version = "0.61"
+time = "0.1"
 
 [[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"
+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"
@@ -77,30 +63,3 @@ path = "udp-codec.rs"
 [[example]]
 name = "tinyhttp"
 path = "tinyhttp.rs"
-
-[[example]]
-name = "custom-executor"
-path = "custom-executor.rs"
-
-[[example]]
-name = "custom-executor-tokio-context"
-path = "custom-executor-tokio-context.rs"
-
-[[example]]
-name = "named-pipe"
-path = "named-pipe.rs"
-
-[[example]]
-name = "named-pipe-ready"
-path = "named-pipe-ready.rs"
-
-[[example]]
-name = "named-pipe-multi-client"
-path = "named-pipe-multi-client.rs"
-
-[[example]]
-name = "dump"
-path = "dump.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

@@ -27,9 +27,9 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::{TcpListener, TcpStream};
+use tokio::stream::{Stream, StreamExt};
 use tokio::sync::{mpsc, Mutex};
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
+use tokio_util::codec::{Framed, LinesCodec, LinesCodecError};
 
 use futures::SinkExt;
 use std::collections::HashMap;
@@ -37,7 +37,9 @@ use std::env;
 use std::error::Error;
 use std::io;
 use std::net::SocketAddr;
+use std::pin::Pin;
 use std::sync::Arc;
+use std::task::{Context, Poll};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -166,6 +168,43 @@ impl Peer {
     }
 }
 
+#[derive(Debug)]
+enum Message {
+    /// A message that should be broadcasted to others.
+    Broadcast(String),
+
+    /// A message that should be received by a client
+    Received(String),
+}
+
+// Peer implements `Stream` in a way that polls both the `Rx`, and `Framed` types.
+// A message is produced whenever an event is ready until the `Framed` stream returns `None`.
+impl Stream for Peer {
+    type Item = Result<Message, LinesCodecError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // First poll the `UnboundedReceiver`.
+
+        if let Poll::Ready(Some(v)) = Pin::new(&mut self.rx).poll_next(cx) {
+            return Poll::Ready(Some(Ok(Message::Received(v))));
+        }
+
+        // Secondly poll the `Framed` stream.
+        let result: Option<_> = futures::ready!(Pin::new(&mut self.lines).poll_next(cx));
+
+        Poll::Ready(match result {
+            // We've received a message we should broadcast to others.
+            Some(Ok(message)) => Some(Ok(Message::Broadcast(message))),
+
+            // An error occurred.
+            Some(Err(e)) => Some(Err(e)),
+
+            // The stream has been exhausted.
+            None => None,
+        })
+    }
+}
+
 /// Process an individual chat client
 async fn process(
     state: Arc<Mutex<Shared>>,
@@ -193,38 +232,34 @@ 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");
+        let msg = format!("{} has joined the chat", username);
         tracing::info!("{}", msg);
         state.broadcast(addr, &msg).await;
     }
 
     // Process incoming messages until our stream is exhausted by a disconnect.
-    loop {
-        tokio::select! {
-            // A message was received from a peer. Send it to the current user.
-            Some(msg) = peer.rx.recv() => {
+    while let Some(result) = peer.next().await {
+        match result {
+            // A message was received from the current user, we should
+            // broadcast this message to the other users.
+            Ok(Message::Broadcast(msg)) => {
+                let mut state = state.lock().await;
+                let msg = format!("{}: {}", username, msg);
+
+                state.broadcast(addr, &msg).await;
+            }
+            // A message was received from a peer. Send it to the
+            // current user.
+            Ok(Message::Received(msg)) => {
                 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}");
-
-                    state.broadcast(addr, &msg).await;
-                }
-                // An error occurred.
-                Some(Err(e)) => {
-                    tracing::error!(
-                        "an error occurred while processing messages for {}; error = {:?}",
-                        username,
-                        e
-                    );
-                }
-                // The stream has been exhausted.
-                None => break,
-            },
+            Err(e) => {
+                tracing::error!(
+                    "an error occurred while processing messages for {}; error = {:?}",
+                    username,
+                    e
+                );
+            }
         }
     }
 
@@ -234,7 +269,7 @@ async fn process(
         let mut state = state.lock().await;
         state.peers.remove(&addr);
 
-        let msg = format!("{username} has left the chat");
+        let msg = format!("{} has left the chat", username);
         tracing::info!("{}", msg);
         state.broadcast(addr, &msg).await;
     }

examples/connect-tcp.rs

@@ -1,71 +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) => {
-                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(()),
-    }
-}

examples/connect-udp.rs

@@ -1,91 +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::try_join!(send(stdin, &socket), recv(stdout, &socket))?;
-
-    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::{future, 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?;
+
+        future::try_join(send(stdin, &socket), recv(stdout, &socket)).await?;
+
+        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

@@ -1,32 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-//It takes advantage from RuntimeExt which provides the extension to customize your
-//runtime.
-
-use tokio::net::TcpListener;
-use tokio::runtime::Builder;
-use tokio::sync::oneshot;
-use tokio_util::context::RuntimeExt;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-    let rt1 = Builder::new_multi_thread()
-        .worker_threads(1)
-        // no timer!
-        .build()
-        .unwrap();
-    let rt2 = Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_all()
-        .build()
-        .unwrap();
-
-    // 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 listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-        println!("addr: {:?}", listener.local_addr());
-        tx.send(()).unwrap();
-    }));
-    futures::executor::block_on(rx).unwrap();
-}

examples/custom-executor.rs

@@ -1,56 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-// The main components are a spawn fn that will wrap futures in a special future
-// that will always enter the tokio context on poll. This only spawns one extra thread
-// to manage and run the tokio drivers in the background.
-
-use tokio::net::TcpListener;
-use tokio::sync::oneshot;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-
-    my_custom_runtime::spawn(async move {
-        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-
-        println!("addr: {:?}", listener.local_addr());
-
-        tx.send(()).unwrap();
-    });
-
-    futures::executor::block_on(rx).unwrap();
-}
-
-mod my_custom_runtime {
-    use once_cell::sync::Lazy;
-    use std::future::Future;
-    use tokio_util::context::TokioContext;
-
-    pub fn spawn(f: impl Future<Output = ()> + Send + 'static) {
-        EXECUTOR.spawn(f);
-    }
-
-    struct ThreadPool {
-        inner: futures::executor::ThreadPool,
-        rt: tokio::runtime::Runtime,
-    }
-
-    static EXECUTOR: Lazy<ThreadPool> = Lazy::new(|| {
-        // Spawn tokio runtime on a single background thread
-        // enabling IO and timers.
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-        let inner = futures::executor::ThreadPool::builder().create().unwrap();
-
-        ThreadPool { inner, rt }
-    });
-
-    impl ThreadPool {
-        fn spawn(&self, f: impl Future<Output = ()> + Send + 'static) {
-            let handle = self.rt.handle().clone();
-            self.inner.spawn_ok(TokioContext::new(f, handle));
-        }
-    }
-}

examples/dump.rs

@@ -1,89 +0,0 @@
-//! This example demonstrates tokio's experimental task dumping functionality.
-//! This application deadlocks. Input CTRL+C to display traces of each task, or
-//! input CTRL+C twice within 1 second to quit.
-
-#[cfg(all(
-    tokio_unstable,
-    target_os = "linux",
-    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
-))]
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    use std::sync::Arc;
-    use tokio::sync::Barrier;
-
-    #[inline(never)]
-    async fn a(barrier: Arc<Barrier>) {
-        b(barrier).await
-    }
-
-    #[inline(never)]
-    async fn b(barrier: Arc<Barrier>) {
-        c(barrier).await
-    }
-
-    #[inline(never)]
-    async fn c(barrier: Arc<Barrier>) {
-        barrier.wait().await;
-    }
-
-    // Prints a task dump upon receipt of CTRL+C, or returns if CTRL+C is
-    // inputted twice within a second.
-    async fn dump_or_quit() {
-        use tokio::time::{timeout, Duration, Instant};
-        let handle = tokio::runtime::Handle::current();
-        let mut last_signal: Option<Instant> = None;
-        // wait for CTRL+C
-        while let Ok(_) = tokio::signal::ctrl_c().await {
-            // exit if a CTRL+C is inputted twice within 1 second
-            if let Some(time_since_last_signal) = last_signal.map(|i| i.elapsed()) {
-                if time_since_last_signal < Duration::from_secs(1) {
-                    return;
-                }
-            }
-            last_signal = Some(Instant::now());
-
-            // capture a dump, and print each trace
-            println!("{:-<80}", "");
-            if let Ok(dump) = timeout(Duration::from_secs(2), handle.dump()).await {
-                for 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.");
-        }
-    }
-
-    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,
-    target_os = "linux",
-    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
-)))]
-fn main() {
-    println!("task dumps are not available")
-}

examples/echo-udp.rs

@@ -6,9 +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!
+//! Each line you type in to the `nc` terminal should be echo'd back to you!
 
 #![warn(rust_2018_idioms)]
 
@@ -38,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)]
@@ -40,7 +40,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // 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.
@@ -55,7 +55,7 @@ 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; 1024];
+            let mut buf = [0; 1024];
 
             // In a loop, read data from the socket and write the data back.
             loop {

examples/hello_world.rs

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

examples/named-pipe-multi-client.rs

@@ -1,98 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use std::time::Duration;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-    use tokio::time;
-    use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-multi-client";
-    const N: usize = 10;
-
-    // The first server needs to be constructed early so that clients can
-    // be correctly connected. Otherwise a waiting client will error.
-    //
-    // Here we also make use of `first_pipe_instance`, which will ensure
-    // that there are no other servers up and running already.
-    let mut server = ServerOptions::new()
-        .first_pipe_instance(true)
-        .create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Artificial workload.
-        time::sleep(Duration::from_secs(1)).await;
-
-        for _ in 0..N {
-            // Wait for client to connect.
-            server.connect().await?;
-            let mut inner = server;
-
-            // Construct the next server to be connected before sending the one
-            // we already have of onto a task. This ensures that the server
-            // isn't closed (after it's done in the task) before a new one is
-            // available. Otherwise the client might error with
-            // `io::ErrorKind::NotFound`.
-            server = ServerOptions::new().create(PIPE_NAME)?;
-
-            let _ = tokio::spawn(async move {
-                let mut buf = vec![0u8; 4];
-                inner.read_exact(&mut buf).await?;
-                inner.write_all(b"pong").await?;
-                Ok::<_, io::Error>(())
-            });
-        }
-
-        Ok::<_, io::Error>(())
-    });
-
-    let mut clients = Vec::new();
-
-    for _ in 0..N {
-        clients.push(tokio::spawn(async move {
-            // This showcases a generic connect loop.
-            //
-            // We immediately try to create a client, if it's not found or
-            // the pipe is busy we use the specialized wait function on the
-            // client builder.
-            let mut client = loop {
-                match ClientOptions::new().open(PIPE_NAME) {
-                    Ok(client) => break client,
-                    Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
-                    Err(e) => return Err(e),
-                }
-
-                time::sleep(Duration::from_millis(5)).await;
-            };
-
-            let mut buf = [0u8; 4];
-            client.write_all(b"ping").await?;
-            client.read_exact(&mut buf).await?;
-            Ok::<_, io::Error>(buf)
-        }));
-    }
-
-    for client in clients {
-        let result = client.await?;
-        assert_eq!(&result?[..], b"pong");
-    }
-
-    server.await??;
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe-ready.rs

@@ -1,161 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::Interest;
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let buf = {
-            let mut read_buf = [0u8; 5];
-            let mut read_buf_cursor = 0;
-
-            loop {
-                server.readable().await?;
-
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match server.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            read_buf
-        };
-
-        {
-            let write_buf = b"pong\n";
-            let mut write_buf_cursor = 0;
-
-            loop {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    break;
-                }
-
-                server.writable().await?;
-
-                match server.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut read_buf = [0u8; 5];
-        let mut read_buf_cursor = 0;
-        let write_buf = b"ping\n";
-        let mut write_buf_cursor = 0;
-
-        loop {
-            let mut interest = Interest::READABLE;
-            if write_buf_cursor < write_buf.len() {
-                interest |= Interest::WRITABLE;
-            }
-
-            let ready = client.ready(interest).await?;
-
-            if ready.is_readable() {
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match client.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            if ready.is_writable() {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    continue;
-                }
-
-                match client.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        let buf = String::from_utf8_lossy(&read_buf).into_owned();
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, *b"ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe.rs

@@ -1,60 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::AsyncWriteExt;
-    use tokio::io::{AsyncBufReadExt, BufReader};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let mut server = BufReader::new(server);
-
-        let mut buf = String::new();
-        server.read_line(&mut buf).await?;
-        server.write_all(b"pong\n").await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut client = BufReader::new(client);
-
-        let mut buf = String::new();
-        client.write_all(b"ping\n").await?;
-        client.read_line(&mut buf).await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, "ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

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:
 //!
@@ -55,7 +55,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{BytesCodec, Decoder};
 
 use std::env;
@@ -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::future::try_join;
 use futures::FutureExt;
 use std::env;
 use std::error::Error;
@@ -38,24 +40,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 mut outbound = TcpStream::connect(server_addr.clone()).await?;
-
-        tokio::spawn(async move {
-            copy_bidirectional(&mut inbound, &mut outbound)
-                .map(|r| {
-                    if let Err(e) = r {
-                        println!("Failed to transfer; error={e}");
-                    }
-                })
-                .await
+    while let Ok((inbound, _)) = listener.accept().await {
+        let transfer = transfer(inbound, server_addr.clone()).map(|r| {
+            if let Err(e) = r {
+                println!("Failed to transfer; error={}", e);
+            }
         });
+
+        tokio::spawn(transfer);
     }
 
     Ok(())
 }
+
+async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn Error>> {
+    let mut outbound = TcpStream::connect(proxy_addr).await?;
+
+    let (mut ri, mut wi) = inbound.split();
+    let (mut ro, mut wo) = outbound.split();
+
+    let client_to_server = async {
+        io::copy(&mut ri, &mut wo).await?;
+        wo.shutdown().await
+    };
+
+    let server_to_client = async {
+        io::copy(&mut ro, &mut wi).await?;
+        wi.shutdown().await
+    };
+
+    try_join(client_to_server, server_to_client).await?;
+
+    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
@@ -42,7 +42,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Framed, LinesCodec};
 
 use futures::SinkExt;
@@ -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,13 +143,13 @@ 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),
         }
     }
 }
 
 fn handle_request(line: &str, db: &Arc<Database>) -> Response {
-    let request = match Request::parse(line) {
+    let request = match Request::parse(&line) {
         Ok(req) => req,
         Err(e) => return Response::Error { msg: 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

@@ -20,7 +20,7 @@ use http::{header::HeaderValue, Request, Response, StatusCode};
 extern crate serde_derive;
 use std::{env, error::Error, fmt, io};
 use tokio::net::{TcpListener, TcpStream};
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Decoder, Encoder, Framed};
 
 #[tokio::main]
@@ -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,21 +180,22 @@ impl Decoder for Http {
                 headers[i] = Some((k, v));
             }
 
-            let method = http::Method::try_from(r.method.unwrap()).map_err(io::Error::other)?;
-
             (
-                method,
+                toslice(r.method.unwrap().as_bytes()),
                 toslice(r.path.unwrap().as_bytes()),
                 r.version.unwrap(),
                 amt,
             )
         };
         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();
-        ret = ret.method(method);
+        ret = ret.method(&data[method.0..method.1]);
         let s = data.slice(path.0..path.1);
         let s = unsafe { String::from_utf8_unchecked(Vec::from(s.as_ref())) };
         ret = ret.uri(s);
@@ -203,11 +206,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))
     }
 }
@@ -216,9 +221,8 @@ mod date {
     use std::cell::RefCell;
     use std::fmt::{self, Write};
     use std::str;
-    use std::time::SystemTime;
 
-    use httpdate::HttpDate;
+    use time::{self, Duration};
 
     pub struct Now(());
 
@@ -248,26 +252,22 @@ mod date {
     struct LastRenderedNow {
         bytes: [u8; 128],
         amt: usize,
-        unix_date: u64,
+        next_update: time::Timespec,
     }
 
-    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,
-    }) });
+        next_update: time::Timespec::new(0, 0),
+    }));
 
     impl fmt::Display for Now {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             LAST.with(|cache| {
                 let mut cache = cache.borrow_mut();
-                let now = SystemTime::now();
-                let now_unix = now
-                    .duration_since(SystemTime::UNIX_EPOCH)
-                    .map(|since_epoch| since_epoch.as_secs())
-                    .unwrap_or(0);
-                if cache.unix_date != now_unix {
-                    cache.update(now, now_unix);
+                let now = time::get_time();
+                if now >= cache.next_update {
+                    cache.update(now);
                 }
                 f.write_str(cache.buffer())
             })
@@ -279,10 +279,11 @@ mod date {
             str::from_utf8(&self.bytes[..self.amt]).unwrap()
         }
 
-        fn update(&mut self, now: SystemTime, now_unix: u64) {
+        fn update(&mut self, now: time::Timespec) {
             self.amt = 0;
-            self.unix_date = now_unix;
-            write!(LocalBuffer(self), "{}", HttpDate::from(now)).unwrap();
+            write!(LocalBuffer(self), "{}", time::at(now).rfc822()).unwrap();
+            self.next_update = now + Duration::seconds(1);
+            self.next_update.nsec = 0;
         }
     }
 

examples/udp-codec.rs

@@ -9,8 +9,8 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::UdpSocket;
+use tokio::stream::StreamExt;
 use tokio::{io, time};
-use tokio_stream::StreamExt;
 use tokio_util::codec::BytesCodec;
 use tokio_util::udp::UdpFramed;
 
@@ -45,8 +45,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let b = pong(&mut b);
 
     // 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:?}"),
+    match futures::future::try_join(a, b).await {
+        Err(e) => println!("an error occurred; error = {:?}", e),
         _ => println!("done!"),
     }
 

netlify.toml

@@ -1,19 +0,0 @@
-[build]
-  command = """
-    rustup install nightly --profile minimal && cargo doc --no-deps --all-features
-    """
-  publish = "target/doc"
-
-[build.environment]
-  RUSTDOCFLAGS="""
-    --cfg docsrs \
-    --cfg tokio_unstable \
-    """
-  RUSTFLAGS="""
-    --cfg docsrs \
-    --cfg tokio_unstable
-    """
-
-[[redirects]]
-  from = "/"
-  to = "/tokio"

spellcheck.dic

@@ -1,309 +0,0 @@
-308
-&
-+
-<
-=
->
-\
-~
-—
-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
-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
-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
-ie
-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
-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
-nonblocking
-nondecreasing
-noop
-ntasks
-NUMA
-ok
-oneshot
-ORed
-os
-parker
-parsers
-peekable
-PGID
-PID
-plaintext
-poller
-POSIX
-proxied
-qos
-RAII
-reallocations
-recv's
-refactors
-refcount
-refcounting
-repo
-repr
-representable
-reqwest
-reregistering
-resize
-resized
-RMW
-runtime
-runtime's
-runtimes
-rwlock
-rx
-scalability
-scheduler's
-semver
-setpgid
-sharded
-signalled
-signalling
-SmallCrush
-Solaris
-spawner
-Splitter
-spmc
-spsc
-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
-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
-vtable
-waker
-wakers
-Wakers
-wakeup
-wakeups
-workstealing

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.7.3"

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,48 +0,0 @@
-{
-  "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,
-  "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": [
-      "-m32"
-    ]
-  },
-  "relro-level": "full",
-  "rustc-abi": "x86-sse2",
-  "stack-probes": {
-    "kind": "inline"
-  },
-  "supported-sanitizers": [
-    "address"
-  ],
-  "supported-split-debuginfo": [
-    "packed",
-    "unpacked",
-    "off"
-  ],
-  "target-family": [
-    "unix"
-  ],
-  "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

@@ -1,10 +1,2 @@
 Tests the various combination of feature flags. This is broken out to a separate
 crate to work around limitations with cargo features.
-
-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`
-command that failed to have it regenerate the test output.

tests-build/tests/fail/macros_core_no_default.stderr

@@ -4,4 +4,4 @@ error: The default runtime flavor is `multi_thread`, but the `rt-multi-thread` f
 3 | #[tokio::main]
   | ^^^^^^^^^^^^^^
   |
-  = note: this error originates in the attribute macro `tokio::main` (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)

tests-build/tests/fail/macros_dead_code.rs

@@ -1,8 +0,0 @@
-#![deny(dead_code)]
-
-use tests_build::tokio;
-
-#[tokio::main]
-async fn f() {}
-
-fn main() {}

tests-build/tests/fail/macros_dead_code.stderr

@@ -1,11 +0,0 @@
-error: function `f` is never used
- --> $DIR/macros_dead_code.rs:6:10
-  |
-6 | async fn f() {}
-  |          ^
-  |
-note: the lint level is defined here
- --> $DIR/macros_dead_code.rs:1:9
-  |
-1 | #![deny(dead_code)]
-  |         ^^^^^^^^^

tests-build/tests/fail/macros_invalid_input.rs

@@ -1,5 +1,3 @@
-#![deny(duplicate_macro_attributes)]
-
 use tests_build::tokio;
 
 #[tokio::main]
@@ -14,58 +12,14 @@ async fn main_attr_has_path_args() {}
 #[tokio::test]
 fn test_is_not_async() {}
 
+#[tokio::test]
+async fn test_fn_has_args(_x: u8) {}
+
 #[tokio::test(foo)]
 async fn test_attr_has_args() {}
 
-#[tokio::test(foo = 123)]
-async fn test_unexpected_attr() {}
-
-#[tokio::test(flavor = 123)]
-async fn test_flavor_not_string() {}
-
-#[tokio::test(flavor = "foo")]
-async fn test_unknown_flavor() {}
-
-#[tokio::test(flavor = "multi_thread", start_paused = false)]
-async fn test_multi_thread_with_start_paused() {}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
-async fn test_worker_threads_not_int() {}
-
-#[tokio::test(flavor = "current_thread", worker_threads = 4)]
-async fn test_worker_threads_and_current_thread() {}
-
-#[tokio::test(crate = 456)]
-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() {}
-
 fn main() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -1,121 +1,41 @@
-error: the `async` keyword is missing from the function declaration
- --> tests/fail/macros_invalid_input.rs:6:1
+error: the async keyword is missing from the function declaration
+ --> $DIR/macros_invalid_input.rs:4:1
   |
-6 | fn main_is_not_async() {}
+4 | fn main_is_not_async() {}
   | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`.
- --> tests/fail/macros_invalid_input.rs:8:15
+error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`
+ --> $DIR/macros_invalid_input.rs:6:15
   |
-8 | #[tokio::main(foo)]
+6 | #[tokio::main(foo)]
   |               ^^^
 
 error: Must have specified ident
-  --> tests/fail/macros_invalid_input.rs:11:15
-   |
-11 | #[tokio::main(threadpool::bar)]
-   |               ^^^^^^^^^^^^^^^
+ --> $DIR/macros_invalid_input.rs:9:15
+  |
+9 | #[tokio::main(threadpool::bar)]
+  |               ^^^^^^^^^^^^^^^
 
-error: the `async` keyword is missing from the function declaration
-  --> tests/fail/macros_invalid_input.rs:15:1
+error: the async keyword is missing from the function declaration
+  --> $DIR/macros_invalid_input.rs:13:1
    |
-15 | fn test_is_not_async() {}
+13 | fn test_is_not_async() {}
    | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`.
-  --> tests/fail/macros_invalid_input.rs:17:15
+error: the test function cannot accept arguments
+  --> $DIR/macros_invalid_input.rs:16:27
    |
-17 | #[tokio::test(foo)]
+16 | async fn test_fn_has_args(_x: u8) {}
+   |                           ^^^^^^
+
+error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`
+  --> $DIR/macros_invalid_input.rs:18:15
+   |
+18 | #[tokio::test(foo)]
    |               ^^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`, `unhandled_panic`
-  --> tests/fail/macros_invalid_input.rs:20:15
+error: second test attribute is supplied
+  --> $DIR/macros_invalid_input.rs:22:1
    |
-20 | #[tokio::test(foo = 123)]
-   |               ^^^^^^^^^
-
-error: Failed to parse value of `flavor` as string.
-  --> tests/fail/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
-   |
-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
-   |
-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
-   |
-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
-   |
-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
-   |
-38 | #[tokio::test(crate = 456)]
-   |                       ^^^
-
-error: Failed to parse value of `crate` as path: "456"
-  --> tests/fail/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
-   |
-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]
+22 | #[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
-   |
-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
-   |
-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
-   |
-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)

tests-build/tests/fail/macros_type_mismatch.rs

@@ -1,69 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn missing_semicolon_or_return_type() {
-    Ok(())
-}
-
-#[tokio::main]
-async fn missing_return_type() {
-    return Ok(());
-}
-
-#[tokio::main]
-async fn extra_semicolon() -> Result<(), ()> {
-    /* TODO(taiki-e): help message still wrong
-    help: try using a variant of the expected enum
-       |
-    23 |     Ok(Ok(());)
-       |
-    23 |     Err(Ok(());)
-       |
-    */
-    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]
-#[tokio::main]
-async fn issue_4635() {
-    return 1;
-    ;
-}
-
-fn main() {}

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,112 +0,0 @@
-error[E0308]: mismatched types
- --> tests/fail/macros_type_mismatch.rs:5:5
-  |
-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[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:10:5
-   |
-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[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:23:5
-   |
-14 | async fn extra_semicolon() -> Result<(), ()> {
-   |                               -------------- expected `Result<(), ()>` because of return type
-...
-23 |     Ok(());
-   |     ^^^^^^^ expected `Result<(), ()>`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-help: try adding an expression at the end of the block
-   |
-23 ~     Ok(());;
-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[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:40: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[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[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 |     ;
-   |     ^ expected `()`, found integer

tests-build/tests/macros.rs

@@ -1,26 +1,10 @@
 #[test]
-#[cfg_attr(miri, ignore)]
 fn compile_fail_full() {
     let t = trybuild::TestCases::new();
 
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/forward_args_and_output.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_return.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_loop.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_type_mismatch.rs");
-
     #[cfg(all(feature = "rt", not(feature = "full")))]
     t.compile_fail("tests/fail/macros_core_no_default.rs");
 

tests-build/tests/macros_clippy.rs

@@ -1,7 +0,0 @@
-#[cfg(feature = "full")]
-#[tokio::test]
-async fn test_with_semicolon_without_return_type() {
-    #![deny(clippy::semicolon_if_nothing_returned)]
-
-    dbg!(0);
-}

tests-build/tests/pass/forward_args_and_output.rs

@@ -1,13 +0,0 @@
-use tests_build::tokio;
-
-fn main() {}
-
-// arguments and output type is forwarded so other macros can access them
-
-#[tokio::test]
-async fn test_fn_has_args(_x: u8) {}
-
-#[tokio::test]
-async fn test_has_output() -> Result<(), Box<dyn std::error::Error>> {
-    Ok(())
-}

tests-build/tests/pass/macros_main_loop.rs

@@ -1,14 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    loop {
-        if !never() {
-            return Ok(());
-        }
-    }
-}
-
-fn never() -> bool {
-    std::time::Instant::now() > std::time::Instant::now()
-}

tests-build/tests/pass/macros_main_return.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    return Ok(());
-}

tests-integration/Cargo.toml

@@ -2,46 +2,10 @@
 name = "tests-integration"
 version = "0.1.0"
 authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
-license = "MIT"
+edition = "2018"
 publish = false
 
-[[bin]]
-name = "test-cat"
-
-[[bin]]
-name = "test-mem"
-required-features = ["rt-net"]
-
-[[bin]]
-name = "test-process-signal"
-required-features = ["rt-process-signal"]
-
-[[test]]
-name = "macros_main"
-
-[[test]]
-name = "macros_pin"
-
-[[test]]
-name = "macros_select"
-
-[[test]]
-name = "rt_yield"
-required-features = ["rt", "macros", "sync"]
-
 [features]
-# For mem check
-rt-net = ["tokio/rt", "tokio/rt-multi-thread", "tokio/net"]
-# For test-process-signal
-rt-process-signal = ["rt-net", "tokio/process", "tokio/signal"]
-# For testing wasi + rt/macros/sync features
-#
-# 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",
     "rt",
@@ -56,11 +20,9 @@ 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
+[dev-dependencies]
+futures = { version = "0.3.0", features = ["async-await"] }

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

@@ -1,21 +0,0 @@
-use std::future::poll_fn;
-
-fn main() {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_io()
-        .build()
-        .unwrap();
-
-    rt.block_on(async {
-        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
-        tokio::spawn(async move {
-            loop {
-                poll_fn(|cx| listener.poll_accept(cx)).await.unwrap();
-            }
-        });
-    });
-
-    std::thread::sleep(std::time::Duration::from_millis(50));
-    drop(rt);
-}

tests-integration/src/bin/test-process-signal.rs

@@ -1,11 +0,0 @@
-// https://github.com/tokio-rs/tokio/issues/3550
-fn main() {
-    for _ in 0..1000 {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-
-        drop(rt);
-    }
-}

tests-integration/tests/macros_main.rs

@@ -1,4 +1,4 @@
-#![cfg(all(feature = "macros", feature = "rt-multi-thread"))]
+#![cfg(all(feature = "macros", feature = "rt"))]
 
 #[tokio::main]
 async fn basic_main() -> usize {
@@ -16,13 +16,6 @@ async fn spawning() -> usize {
     join.await.unwrap()
 }
 
-#[cfg(tokio_unstable)]
-#[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());
@@ -31,8 +24,5 @@ fn main_with_spawn() {
 #[test]
 fn shell() {
     assert_eq!(1, basic_main());
-    assert_eq!(bool::default(), generic_fun::<bool>());
-
-    #[cfg(tokio_unstable)]
-    assert_eq!(1, local_main());
+    assert_eq!(bool::default(), generic_fun::<bool>())
 }

tests-integration/tests/macros_select.rs

@@ -4,10 +4,6 @@ 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"
-)]
 #[test]
 fn join_with_select() {
     block_on(async {

tests-integration/tests/process_stdio.rs

@@ -1,8 +1,7 @@
 #![warn(rust_2018_idioms)]
-#![cfg(all(feature = "full", not(target_os = "wasi"), not(miri)))]
+#![cfg(feature = "full")]
 
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::join;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
 use tokio_test::assert_ok;
 
@@ -10,10 +9,18 @@ use futures::future::{self, FutureExt};
 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"));
+    let mut me = env::current_exe().unwrap();
+    me.pop();
+
+    if me.ends_with("deps") {
+        me.pop();
+    }
+
+    me.push("test-cat");
+
+    let mut cmd = Command::new(me);
     cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
     cmd
 }
@@ -25,7 +32,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 +59,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);
                 }
             };
@@ -141,103 +148,3 @@ async fn try_wait() {
     // Can't get id after process has exited
     assert_eq!(child.id(), None);
 }
-
-#[tokio::test]
-async fn pipe_from_one_command_to_another() {
-    let mut first = cat().spawn().expect("first cmd");
-    let mut third = cat().spawn().expect("third cmd");
-
-    // Convert ChildStdout to Stdio
-    let second_stdin: Stdio = first
-        .stdout
-        .take()
-        .expect("first.stdout")
-        .try_into()
-        .expect("first.stdout into Stdio");
-
-    // Convert ChildStdin to Stdio
-    let second_stdout: Stdio = third
-        .stdin
-        .take()
-        .expect("third.stdin")
-        .try_into()
-        .expect("third.stdin into Stdio");
-
-    let mut second = cat()
-        .stdin(second_stdin)
-        .stdout(second_stdout)
-        .spawn()
-        .expect("first cmd");
-
-    let msg = "hello world! please pipe this message through";
-
-    let mut stdin = first.stdin.take().expect("first.stdin");
-    let write = async move { stdin.write_all(msg.as_bytes()).await };
-
-    let mut stdout = third.stdout.take().expect("third.stdout");
-    let read = async move {
-        let mut data = String::new();
-        stdout.read_to_string(&mut data).await.map(|_| data)
-    };
-
-    let (read, write, first_status, second_status, third_status) =
-        join!(read, write, first.wait(), second.wait(), third.wait());
-
-    assert_eq!(msg, read.expect("read result"));
-    write.expect("write result");
-
-    assert!(first_status.expect("first status").success());
-    assert!(second_status.expect("second status").success());
-    assert!(third_status.expect("third status").success());
-}
-
-#[tokio::test]
-async fn vectored_writes() {
-    use bytes::{Buf, Bytes};
-    use std::{io::IoSlice, pin::Pin};
-    use tokio::io::AsyncWrite;
-
-    let mut cat = cat().spawn().unwrap();
-    let mut stdin = cat.stdin.take().unwrap();
-    let are_writes_vectored = stdin.is_write_vectored();
-    let mut stdout = cat.stdout.take().unwrap();
-
-    let write = async {
-        let mut input = Bytes::from_static(b"hello\n").chain(Bytes::from_static(b"world!\n"));
-        let mut writes_completed = 0;
-
-        std::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))?;
-            writes_completed += 1;
-            input.advance(n);
-        })
-        .await?;
-
-        drop(stdin);
-
-        std::io::Result::Ok(writes_completed)
-    };
-
-    let read = async {
-        let mut buffer = Vec::with_capacity(6 + 7);
-        stdout.read_to_end(&mut buffer).await?;
-        std::io::Result::Ok(buffer)
-    };
-
-    let (write, read, status) = future::join3(write, read, cat.wait()).await;
-
-    assert!(status.unwrap().success());
-
-    let writes_completed = write.unwrap();
-    // on unix our small payload should always fit in whatever default sized pipe with a single
-    // syscall. if multiple are used, then the forwarding does not work, or we are on a platform
-    // for which the `std` does not support vectored writes.
-    assert_eq!(writes_completed == 1, are_writes_vectored);
-
-    assert_eq!(&read.unwrap(), b"hello\nworld!\n");
-}

tests-integration/tests/rt_yield.rs

@@ -1,41 +0,0 @@
-use tokio::sync::oneshot;
-use tokio::task;
-
-async fn spawn_send() {
-    let (tx, rx) = oneshot::channel();
-
-    let task = tokio::spawn(async {
-        for _ in 0..10 {
-            task::yield_now().await;
-        }
-
-        tx.send("done").unwrap();
-    });
-
-    assert_eq!("done", rx.await.unwrap());
-    task.await.unwrap();
-}
-
-#[tokio::main(flavor = "current_thread")]
-async fn entry_point() {
-    spawn_send().await;
-}
-
-#[tokio::test]
-async fn test_macro() {
-    spawn_send().await;
-}
-
-#[test]
-fn main_macro() {
-    entry_point();
-}
-
-#[test]
-fn manual_rt() {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    rt.block_on(async { spawn_send().await });
-}

tokio-macros/CHANGELOG.md

@@ -1,161 +1,9 @@
-# 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])
-- macros: make entrypoints more efficient ([#5621])
-
-[#5621]: https://github.com/tokio-rs/tokio/pull/5621
-[#5636]: https://github.com/tokio-rs/tokio/pull/5636
-
-# 2.0.0 (March 24th, 2023)
-
-This major release updates the dependency on the syn crate to 2.0.0, and
-increases the MSRV to 1.56.
-
-As part of this release, we are adopting a policy of depending on a specific minor
-release of tokio-macros. This prevents Tokio from being able to pull in many different
-versions of tokio-macros.
-
-- macros: update `syn` ([#5572])
-- macros: accept path as crate rename ([#5557])
-
-[#5572]: https://github.com/tokio-rs/tokio/pull/5572
-[#5557]: https://github.com/tokio-rs/tokio/pull/5557
-
-# 1.8.2 (November 30th, 2022)
-
-- fix a regression introduced in 1.8.1 ([#5244])
-
-[#5244]: https://github.com/tokio-rs/tokio/pull/5244
-
-# 1.8.1 (November 29th, 2022)
-
-(yanked)
-
-- macros: Pin Futures in `#[tokio::test]` to stack ([#5205])
-- macros: Reduce usage of last statement spans in proc-macros ([#5092])
-- macros: Improve the documentation for `#[tokio::test]` ([#4761])
-
-[#5205]: https://github.com/tokio-rs/tokio/pull/5205
-[#5092]: https://github.com/tokio-rs/tokio/pull/5092
-[#4761]: https://github.com/tokio-rs/tokio/pull/4761
-
-# 1.8.0 (June 4th, 2022)
-
-- macros: always emit return statement ([#4636])
-- macros: support setting a custom crate name for `#[tokio::main]` and `#[tokio::test]` ([#4613])
-
-[#4613]: https://github.com/tokio-rs/tokio/pull/4613
-[#4636]: https://github.com/tokio-rs/tokio/pull/4636
-
-# 1.7.0 (December 15th, 2021)
-
-- macros: address remaining `clippy::semicolon_if_nothing_returned` warning ([#4252])
-
-[#4252]: https://github.com/tokio-rs/tokio/pull/4252
-
-# 1.6.0 (November 16th, 2021)
-
-- macros: fix mut patterns in `select!` macro ([#4211])
-
-[#4211]: https://github.com/tokio-rs/tokio/pull/4211
-
-# 1.5.1 (October 29th, 2021)
-
-- macros: fix type resolution error in `#[tokio::main]` ([#4176])
-
-[#4176]: https://github.com/tokio-rs/tokio/pull/4176
-
-# 1.5.0 (October 13th, 2021)
-
-- macros: make tokio-macros attributes more IDE friendly ([#4162])
-
-[#4162]: https://github.com/tokio-rs/tokio/pull/4162
-
-# 1.4.1 (September 30th, 2021)
-
-Reverted: run `current_thread` inside `LocalSet` ([#4027])
-
-# 1.4.0 (September 29th, 2021)
-
-(yanked)
-
-### Changed
-
-- macros: run `current_thread` inside `LocalSet` ([#4027])
-- macros: explicitly relaxed clippy lint for `.expect()` in runtime entry macro ([#4030])
+# 0.3.2 (December 19, 2020)
 
 ### Fixed
 
-- macros: fix invalid error messages in functions wrapped with `#[main]` or `#[test]` ([#4067])
-
-[#4027]: https://github.com/tokio-rs/tokio/pull/4027
-[#4030]: https://github.com/tokio-rs/tokio/pull/4030
-[#4067]: https://github.com/tokio-rs/tokio/pull/4067
-
-# 1.3.0 (July 7, 2021)
-
-- macros: don't trigger `clippy::unwrap_used` ([#3926])
-
-[#3926]: https://github.com/tokio-rs/tokio/pull/3926
-
-# 1.2.0 (May 14, 2021)
-
-- macros: forward input arguments in `#[tokio::test]` ([#3691])
-- macros: improve diagnostics on type mismatch ([#3766])
-- macros: various error message improvements ([#3677])
-
-[#3677]: https://github.com/tokio-rs/tokio/pull/3677
-[#3691]: https://github.com/tokio-rs/tokio/pull/3691
-[#3766]: https://github.com/tokio-rs/tokio/pull/3766
-
-# 1.1.0 (February 5, 2021)
-
-- add `start_paused` option to macros ([#3492])
-
-# 1.0.0 (December 23, 2020)
-
-- track `tokio` 1.0 release.
+- fix outdated macro documentation ([#3180])
+- add portability note to `tokio::main` ([#3199])
 
 # 0.3.1 (October 25, 2020)
 
@@ -210,4 +58,5 @@ Reverted: run `current_thread` inside `LocalSet` ([#4027])
 [#2177]: https://github.com/tokio-rs/tokio/pull/2177
 [#2225]: https://github.com/tokio-rs/tokio/pull/2225
 [#3038]: https://github.com/tokio-rs/tokio/pull/3038
-[#3492]: https://github.com/tokio-rs/tokio/pull/3492
+[#3180]: https://github.com/tokio-rs/tokio/pull/3180
+[#3199]: https://github.com/tokio-rs/tokio/pull/3199

tokio-macros/Cargo.toml

@@ -2,15 +2,18 @@
 name = "tokio-macros"
 # When releasing to crates.io:
 # - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-x.y.z" git tag.
-version = "2.6.0"
-edition = "2021"
-rust-version = "1.71"
+# - Create "v0.3.x" git tag.
+version = "0.3.2"
+edition = "2018"
 authors = ["Tokio Contributors <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://tokio.rs"
+documentation = "https://docs.rs/tokio-macros/0.3.2/tokio_macros"
 description = """
 Tokio's proc macros.
 """
@@ -22,15 +25,12 @@ proc-macro = true
 [features]
 
 [dependencies]
-proc-macro2 = "1.0.60"
+proc-macro2 = "1.0.7"
 quote = "1"
-syn = { version = "2.0", features = ["full"] }
+syn = { version = "1.0.3", features = ["full"] }
 
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.3.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) 2019 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

@@ -1,16 +1,12 @@
-use proc_macro2::{Span, TokenStream, TokenTree};
-use quote::{quote, quote_spanned, ToTokens};
-use syn::parse::{Parse, ParseStream, Parser};
-use syn::{braced, Attribute, Ident, Path, Signature, Visibility};
-
-// syn::AttributeArgs does not implement syn::Parse
-type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![,]>;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::spanned::Spanned;
 
 #[derive(Clone, Copy, PartialEq)]
 enum RuntimeFlavor {
     CurrentThread,
     Threaded,
-    Local,
 }
 
 impl RuntimeFlavor {
@@ -18,36 +14,10 @@ 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)),
         }
     }
 }
@@ -55,29 +25,13 @@ impl UnhandledPanic {
 struct FinalConfig {
     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 {
-    flavor: RuntimeFlavor::CurrentThread,
-    worker_threads: None,
-    start_paused: None,
-    crate_name: None,
-    unhandled_panic: None,
-};
-
 struct Configuration {
     rt_multi_thread_available: bool,
     default_flavor: RuntimeFlavor,
     flavor: Option<RuntimeFlavor>,
     worker_threads: Option<(usize, Span)>,
-    start_paused: Option<(bool, Span)>,
-    is_test: bool,
-    crate_name: Option<Path>,
-    unhandled_panic: Option<(UnhandledPanic, Span)>,
 }
 
 impl Configuration {
@@ -90,10 +44,6 @@ impl Configuration {
             },
             flavor: None,
             worker_threads: None,
-            start_paused: None,
-            is_test,
-            crate_name: None,
-            unhandled_panic: None,
         }
     }
 
@@ -129,110 +79,31 @@ impl Configuration {
         Ok(())
     }
 
-    fn set_start_paused(&mut self, start_paused: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.start_paused.is_some() {
-            return Err(syn::Error::new(span, "`start_paused` set multiple times."));
-        }
-
-        let start_paused = parse_bool(start_paused, span, "start_paused")?;
-        self.start_paused = Some((start_paused, span));
-        Ok(())
-    }
-
-    fn set_crate_name(&mut self, name: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.crate_name.is_some() {
-            return Err(syn::Error::new(span, "`crate` set multiple times."));
-        }
-        let name_path = parse_path(name, span, "crate")?;
-        self.crate_name = Some(name_path);
-        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"
-        } else {
-            "tokio::main"
-        }
-    }
-
     fn build(&self) -> Result<FinalConfig, syn::Error> {
-        use RuntimeFlavor as F;
-
         let flavor = self.flavor.unwrap_or(self.default_flavor);
-
-        let worker_threads = match (flavor, self.worker_threads) {
-            (F::CurrentThread | F::Local, 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 => {
-                worker_threads.map(|(val, _span)| val)
-            }
-            (F::Threaded, _) => {
+        use RuntimeFlavor::*;
+        match (flavor, self.worker_threads) {
+            (CurrentThread, Some((_, worker_threads_span))) => Err(syn::Error::new(
+                worker_threads_span,
+                "The `worker_threads` option requires the `multi_thread` runtime flavor.",
+            )),
+            (CurrentThread, None) => Ok(FinalConfig {
+                flavor,
+                worker_threads: None,
+            }),
+            (Threaded, worker_threads) if self.rt_multi_thread_available => Ok(FinalConfig {
+                flavor,
+                worker_threads: worker_threads.map(|(val, _span)| val),
+            }),
+            (Threaded, _) => {
                 let msg = if self.flavor.is_none() {
                     "The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled."
                 } else {
                     "The runtime flavor `multi_thread` requires the `rt-multi-thread` feature."
                 };
-                return Err(syn::Error::new(Span::call_site(), msg));
+                Err(syn::Error::new(Span::call_site(), msg))
             }
-        };
-
-        let start_paused = match (flavor, self.start_paused) {
-            (F::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),
-            (_, None) => None,
-        };
-
-        Ok(FinalConfig {
-            crate_name: self.crate_name.clone(),
-            flavor,
-            worker_threads,
-            start_paused,
-            unhandled_panic,
-        })
+        }
     }
 }
 
@@ -242,12 +113,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 {} as integer: {}", field, e),
             )),
         },
         _ => Err(syn::Error::new(
             span,
-            format!("Failed to parse value of `{field}` as integer."),
+            format!("Failed to parse {} as integer.", field),
         )),
     }
 }
@@ -258,121 +129,86 @@ 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 {} as string.", field),
         )),
     }
 }
 
-fn parse_path(lit: syn::Lit, span: Span, field: &str) -> Result<Path, syn::Error> {
-    match lit {
-        syn::Lit::Str(s) => {
-            let err = syn::Error::new(
-                span,
-                format!(
-                    "Failed to parse value of `{}` as path: \"{}\"",
-                    field,
-                    s.value()
-                ),
-            );
-            s.parse::<syn::Path>().map_err(|_| err.clone())
-        }
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{field}` as path."),
-        )),
-    }
-}
-
-fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, syn::Error> {
-    match bool {
-        syn::Lit::Bool(b) => Ok(b.value),
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{field}` as bool."),
-        )),
-    }
-}
-
-fn build_config(
-    input: &ItemFn,
-    args: AttributeArgs,
+fn parse_knobs(
+    mut input: syn::ItemFn,
+    args: syn::AttributeArgs,
     is_test: bool,
     rt_multi_thread: bool,
-) -> Result<FinalConfig, syn::Error> {
-    if input.sig.asyncness.is_none() {
-        let msg = "the `async` keyword is missing from the function declaration";
-        return Err(syn::Error::new_spanned(input.sig.fn_token, msg));
+) -> Result<TokenStream, syn::Error> {
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let vis = input.vis;
+
+    if sig.asyncness.is_none() {
+        let msg = "the async keyword is missing from the function declaration";
+        return Err(syn::Error::new_spanned(sig.fn_token, msg));
     }
 
+    sig.asyncness = None;
+
+    let macro_name = if is_test {
+        "tokio::test"
+    } else {
+        "tokio::main"
+    };
     let mut config = Configuration::new(is_test, rt_multi_thread);
-    let macro_name = config.macro_name();
 
     for arg in args {
         match arg {
-            syn::Meta::NameValue(namevalue) => {
-                let ident = namevalue
-                    .path
-                    .get_ident()
-                    .ok_or_else(|| {
-                        syn::Error::new_spanned(&namevalue, "Must have specified ident")
-                    })?
-                    .to_string()
-                    .to_lowercase();
-                let lit = match &namevalue.value {
-                    syn::Expr::Lit(syn::ExprLit { lit, .. }) => lit,
-                    expr => return Err(syn::Error::new_spanned(expr, "Must be a literal")),
-                };
-                match ident.as_str() {
+            syn::NestedMeta::Meta(syn::Meta::NameValue(namevalue)) => {
+                let ident = namevalue.path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return Err(syn::Error::new_spanned(namevalue, msg));
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
                     "worker_threads" => {
-                        config.set_worker_threads(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_worker_threads(namevalue.lit.clone(), namevalue.span())?;
                     }
                     "flavor" => {
-                        config.set_flavor(lit.clone(), syn::spanned::Spanned::span(lit))?;
-                    }
-                    "start_paused" => {
-                        config.set_start_paused(lit.clone(), syn::spanned::Spanned::span(lit))?;
+                        config.set_flavor(namevalue.lit.clone(), namevalue.span())?;
                     }
                     "core_threads" => {
                         let msg = "Attribute `core_threads` is renamed to `worker_threads`";
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
-                    "crate" => {
-                        config.set_crate_name(lit.clone(), syn::spanned::Spanned::span(lit))?;
-                    }
-                    "unhandled_panic" => {
-                        config
-                            .set_unhandled_panic(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`",
-                        );
+                        let msg = format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`", name);
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
                 }
             }
-            syn::Meta::Path(path) => {
-                let name = path
-                    .get_ident()
-                    .ok_or_else(|| syn::Error::new_spanned(&path, "Must have specified ident"))?
-                    .to_string()
-                    .to_lowercase();
+            syn::NestedMeta::Meta(syn::Meta::Path(path)) => {
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return Err(syn::Error::new_spanned(path, msg));
+                }
+                let name = ident.unwrap().to_string().to_lowercase();
                 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" => {
-                        format!("The `{name}` attribute requires an argument.")
+                    "flavor" | "worker_threads" => {
+                        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`.")
+                        format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`", name)
                     }
                 };
                 return Err(syn::Error::new_spanned(path, msg));
@@ -386,338 +222,79 @@ fn build_config(
         }
     }
 
-    config.build()
-}
-
-fn parse_knobs(mut input: ItemFn, is_test: bool, config: FinalConfig) -> TokenStream {
-    input.sig.asyncness = None;
-
-    // If type mismatch occurs, the current rustc points to the last statement.
-    let (last_stmt_start_span, last_stmt_end_span) = {
-        let mut last_stmt = input.stmts.last().cloned().unwrap_or_default().into_iter();
-
-        // `Span` on stable Rust has a limitation that only points to the first
-        // token, not the whole tokens. We can work around this limitation by
-        // using the first/last span of the tokens like
-        // `syn::Error::new_spanned` does.
-        let start = last_stmt.next().map_or_else(Span::call_site, |t| t.span());
-        let end = last_stmt.last().map_or(start, |t| t.span());
-        (start, end)
-    };
-
-    let crate_path = config
-        .crate_name
-        .map(ToTokens::into_token_stream)
-        .unwrap_or_else(|| Ident::new("tokio", last_stmt_start_span).into_token_stream());
+    let config = config.build()?;
 
     let mut rt = match config.flavor {
-        RuntimeFlavor::CurrentThread | RuntimeFlavor::Local => {
-            quote_spanned! {last_stmt_start_span=>
-                #crate_path::runtime::Builder::new_current_thread()
-            }
-        }
-        RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=>
-            #crate_path::runtime::Builder::new_multi_thread()
+        RuntimeFlavor::CurrentThread => quote! {
+            tokio::runtime::Builder::new_current_thread()
+        },
+        RuntimeFlavor::Threaded => quote! {
+            tokio::runtime::Builder::new_multi_thread()
         },
     };
-
-    let mut checks = vec![];
-    let mut errors = vec![];
-
-    let build = if let RuntimeFlavor::Local = config.flavor {
-        checks.push(quote! { tokio_unstable });
-        errors.push("The local runtime flavor is only available when `tokio_unstable` is set.");
-        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) };
-    }
-    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) };
+        rt = quote! { #rt.worker_threads(#v) };
     }
 
-    let generated_attrs = if is_test {
-        quote! {
-            #[::core::prelude::v1::test]
-        }
-    } else {
-        quote! {}
-    };
-
-    let do_checks: TokenStream = checks
-        .iter()
-        .zip(&errors)
-        .map(|(check, error)| {
+    let header = {
+        if is_test {
             quote! {
-                #[cfg(not(#check))]
-                compile_error!(#error);
+                #[::core::prelude::v1::test]
             }
-        })
-        .collect();
+        } else {
+            quote! {}
+        }
+    };
 
-    let body_ident = quote! { body };
-    // This explicit `return` is intentional. See tokio-rs/tokio#4636
-    let last_block = quote_spanned! {last_stmt_end_span=>
-        #do_checks
-
-        #[cfg(all(#(#checks),*))]
-        #[allow(clippy::expect_used, clippy::diverging_sub_expression, clippy::needless_return, clippy::unwrap_in_result)]
-        {
-            return #rt
+    let result = quote! {
+        #header
+        #(#attrs)*
+        #vis #sig {
+            #rt
                 .enable_all()
-                .#build
-                .expect("Failed building the Runtime")
-                .block_on(#body_ident);
-        }
-
-        #[cfg(not(all(#(#checks),*)))]
-        {
-            panic!("fell through checks")
+                .build()
+                .unwrap()
+                .block_on(async { #body })
         }
     };
 
-    let body = input.body();
-
-    // For test functions pin the body to the stack and use `Pin<&mut dyn
-    // Future>` to reduce the amount of `Runtime::block_on` (and related
-    // functions) copies we generate during compilation due to the generic
-    // parameter `F` (the future to block on). This could have an impact on
-    // performance, but because it's only for testing it's unlikely to be very
-    // large.
-    //
-    // We don't do this for the main function as it should only be used once so
-    // there will be no benefit.
-    let body = if is_test {
-        let output_type = match &input.sig.output {
-            // For functions with no return value syn doesn't print anything,
-            // but that doesn't work as `Output` for our boxed `Future`, so
-            // default to `()` (the same type as the function output).
-            syn::ReturnType::Default => quote! { () },
-            syn::ReturnType::Type(_, ret_type) => quote! { #ret_type },
-        };
-        quote! {
-            let body = async #body;
-            #crate_path::pin!(body);
-            let body: ::core::pin::Pin<&mut dyn ::core::future::Future<Output = #output_type>> = body;
-        }
-    } else {
-        quote! {
-            let body = async #body;
-        }
-    };
-
-    input.into_tokens(generated_attrs, body, last_block)
-}
-
-fn token_stream_with_error(mut tokens: TokenStream, error: syn::Error) -> TokenStream {
-    tokens.extend(error.into_compile_error());
-    tokens
+    Ok(result.into())
 }
 
+#[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
-    // related features keep working.
-    let input: ItemFn = match syn::parse2(item.clone()) {
-        Ok(it) => it,
-        Err(e) => return token_stream_with_error(item, e),
-    };
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
-    let config = if input.sig.ident == "main" && !input.sig.inputs.is_empty() {
+    if input.sig.ident == "main" && !input.sig.inputs.is_empty() {
         let msg = "the main function cannot accept arguments";
-        Err(syn::Error::new_spanned(&input.sig.ident, msg))
-    } else {
-        AttributeArgs::parse_terminated
-            .parse2(args)
-            .and_then(|args| build_config(&input, args, false, rt_multi_thread))
-    };
-
-    match config {
-        Ok(config) => parse_knobs(input, false, config),
-        Err(e) => token_stream_with_error(parse_knobs(input, false, DEFAULT_ERROR_CONFIG), e),
+        return syn::Error::new_spanned(&input.sig.ident, msg)
+            .to_compile_error()
+            .into();
     }
-}
 
-// 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)
-        })
-    })
+    parse_knobs(input, args, false, rt_multi_thread).unwrap_or_else(|e| e.to_compile_error().into())
 }
 
 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
-    // related features keep working.
-    let input: ItemFn = match syn::parse2(item.clone()) {
-        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";
-        Err(syn::Error::new_spanned(attr, msg))
-    } else {
-        AttributeArgs::parse_terminated
-            .parse2(args)
-            .and_then(|args| build_config(&input, args, true, rt_multi_thread))
-    };
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
-    match config {
-        Ok(config) => parse_knobs(input, true, config),
-        Err(e) => token_stream_with_error(parse_knobs(input, true, DEFAULT_ERROR_CONFIG), e),
-    }
-}
-
-struct ItemFn {
-    outer_attrs: Vec<Attribute>,
-    vis: Visibility,
-    sig: Signature,
-    brace_token: syn::token::Brace,
-    inner_attrs: Vec<Attribute>,
-    stmts: Vec<proc_macro2::TokenStream>,
-}
-
-impl ItemFn {
-    /// Access all attributes of the function item.
-    fn attrs(&self) -> impl Iterator<Item = &Attribute> {
-        self.outer_attrs.iter().chain(self.inner_attrs.iter())
-    }
-
-    /// Get the body of the function item in a manner so that it can be
-    /// conveniently used with the `quote!` macro.
-    fn body(&self) -> Body<'_> {
-        Body {
-            brace_token: self.brace_token,
-            stmts: &self.stmts,
+    for attr in &input.attrs {
+        if attr.path.is_ident("test") {
+            let msg = "second test attribute is supplied";
+            return syn::Error::new_spanned(&attr, msg)
+                .to_compile_error()
+                .into();
         }
     }
 
-    /// Convert our local function item into a token stream.
-    fn into_tokens(
-        self,
-        generated_attrs: proc_macro2::TokenStream,
-        body: proc_macro2::TokenStream,
-        last_block: proc_macro2::TokenStream,
-    ) -> TokenStream {
-        let mut tokens = proc_macro2::TokenStream::new();
-        // Outer attributes are simply streamed as-is.
-        for attr in self.outer_attrs {
-            attr.to_tokens(&mut tokens);
-        }
-
-        // Inner attributes require extra care, since they're not supported on
-        // blocks (which is what we're expanded into) we instead lift them
-        // outside of the function. This matches the behavior 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);
-
-        self.brace_token.surround(&mut tokens, |tokens| {
-            body.to_tokens(tokens);
-            last_block.to_tokens(tokens);
-        });
-
-        tokens
-    }
-}
-
-impl Parse for ItemFn {
-    #[inline]
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        // This parse implementation has been largely lifted from `syn`, with
-        // the exception of:
-        // * We don't have access to the plumbing necessary to parse inner
-        //   attributes in-place.
-        // * We do our own statements parsing to avoid recursively parsing
-        //   entire statements and only look for the parts we're interested in.
-
-        let outer_attrs = input.call(Attribute::parse_outer)?;
-        let vis: Visibility = input.parse()?;
-        let sig: Signature = input.parse()?;
-
-        let content;
-        let brace_token = braced!(content in input);
-        let inner_attrs = Attribute::parse_inner(&content)?;
-
-        let mut buf = proc_macro2::TokenStream::new();
-        let mut stmts = Vec::new();
-
-        while !content.is_empty() {
-            if let Some(semi) = content.parse::<Option<syn::Token![;]>>()? {
-                semi.to_tokens(&mut buf);
-                stmts.push(buf);
-                buf = proc_macro2::TokenStream::new();
-                continue;
-            }
-
-            // Parse a single token tree and extend our current buffer with it.
-            // This avoids parsing the entire content of the sub-tree.
-            buf.extend([content.parse::<TokenTree>()?]);
-        }
-
-        if !buf.is_empty() {
-            stmts.push(buf);
-        }
-
-        Ok(Self {
-            outer_attrs,
-            vis,
-            sig,
-            brace_token,
-            inner_attrs,
-            stmts,
-        })
-    }
-}
-
-struct Body<'a> {
-    brace_token: syn::token::Brace,
-    // Statements, with terminating `;`.
-    stmts: &'a [TokenStream],
-}
-
-impl ToTokens for Body<'_> {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        self.brace_token.surround(tokens, |tokens| {
-            for stmt in self.stmts {
-                stmt.to_tokens(tokens);
-            }
-        });
+    if !input.sig.inputs.is_empty() {
+        let msg = "the test function cannot accept arguments";
+        return syn::Error::new_spanned(&input.sig.inputs, msg)
+            .to_compile_error()
+            .into();
     }
+
+    parse_knobs(input, args, true, rt_multi_thread).unwrap_or_else(|e| e.to_compile_error().into())
 }

tokio-macros/src/lib.rs

@@ -1,3 +1,4 @@
+#![doc(html_root_url = "https://docs.rs/tokio-macros/0.3.2")]
 #![allow(clippy::needless_doctest_main)]
 #![warn(
     missing_debug_implementations,
@@ -5,6 +6,7 @@
     rust_2018_idioms,
     unreachable_pub
 )]
+#![cfg_attr(docsrs, deny(broken_intra_doc_links))]
 #![doc(test(
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
@@ -22,8 +24,8 @@ mod select;
 
 use proc_macro::TokenStream;
 
-/// Marks async function to be executed by the selected runtime. This macro
-/// helps set up a `Runtime` without requiring the user to use
+/// Marks async function to be executed by the selected runtime. This macro helps
+/// set up a `Runtime` without requiring the user to use
 /// [Runtime](../tokio/runtime/struct.Runtime.html) or
 /// [Builder](../tokio/runtime/struct.Builder.html) directly.
 ///
@@ -34,24 +36,12 @@ use proc_macro::TokenStream;
 /// powerful interface.
 ///
 /// Note: This macro can be used on any function and not just the `main`
-/// 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.
+/// 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
-///
-/// Note that the async function marked with this macro does not run as a
-/// worker. The expectation is that other tasks are spawned by the function here.
-/// Awaiting on other futures from the function provided here will not
-/// perform as fast as those spawned as workers.
-///
-/// # 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
 ///
@@ -63,40 +53,23 @@ use proc_macro::TokenStream;
 /// The `worker_threads` option configures the number of worker threads, and
 /// defaults to the number of cpus on the system. This is the default flavor.
 ///
-/// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
-/// flag.
-///
-/// ## 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:
 ///
-/// [Unstable API][unstable] only.
+/// Arguments are allowed for any functions aside from `main` which is special
 ///
-/// To use the [local runtime], the macro can be configured using
+/// ## Usage
 ///
-/// ```rust
-/// # #[cfg(tokio_unstable)]
-/// #[tokio::main(flavor = "local")]
-/// # async fn main() {}
-/// # #[cfg(not(tokio_unstable))]
-/// # fn main() {}
-/// ```
-///
-/// # Function arguments
-///
-/// Arguments are allowed for any functions, aside from `main` which is special.
-///
-/// # Usage
-///
-/// ## Using the multi-threaded runtime
+/// ### Using the multi-thread runtime
 ///
 /// ```rust
 /// #[tokio::main]
@@ -119,7 +92,7 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Using the current-thread runtime
+/// ### Using current thread runtime
 ///
 /// The basic scheduler is single-threaded.
 ///
@@ -144,42 +117,7 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Using the local runtime
-///
-/// Available in the [unstable API][unstable] only.
-///
-/// The [local runtime] is similar to the current-thread runtime but
-/// supports [`task::spawn_local`](../tokio/task/fn.spawn_local.html).
-///
-/// ```rust
-/// # #[cfg(tokio_unstable)]
-/// #[tokio::main(flavor = "local")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// # #[cfg(not(tokio_unstable))]
-/// # fn main() {}
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// # #[cfg(tokio_unstable)]
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .build_local(tokio::runtime::LocalOptions::default())
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// # #[cfg(not(tokio_unstable))]
-/// # fn main() {}
-/// ```
-///
-///
-/// ## Set number of worker threads
+/// ### Set number of worker threads
 ///
 /// ```rust
 /// #[tokio::main(worker_threads = 2)]
@@ -203,113 +141,21 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ## Configure the runtime to start with time paused
+/// ### NOTE:
 ///
-/// ```rust
-/// #[tokio::main(flavor = "current_thread", start_paused = true)]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .start_paused(true)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
-/// ## Rename package
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::main(crate = "tokio1")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// fn main() {
-///     tokio1::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             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::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
+/// If you rename the tokio crate in your dependencies this macro will not work.
+/// If you must rename the 0.3 version of tokio because you're also using the
+/// 0.1 version of tokio, you _must_ make the tokio 0.3 crate available as
+/// `tokio` in the module where this macro is expanded.
 #[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::main(args.into(), item.into(), true).into()
+    entry::main(args, item, true)
 }
 
 /// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
 /// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
 /// ## Function arguments:
 ///
@@ -340,51 +186,24 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// ### Rename package
+/// ### NOTE:
 ///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::main(crate = "tokio1")]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// fn main() {
-///     tokio1::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.3 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.3 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::main(args.into(), item.into(), false).into()
+    entry::main(args, item, false)
 }
 
-/// Marks async function to be executed by runtime, suitable to test environment.
-/// This macro helps set up a `Runtime` without requiring the user to use
-/// [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// Marks async function to be executed by runtime, suitable to test environment
 ///
-/// Note: This macro is designed to be simplistic and targets applications that
-/// do not require a complex setup. If the provided functionality is not
-/// sufficient, you may be interested in using
-/// [Builder](../tokio/runtime/struct.Builder.html), which provides a more
-/// powerful interface.
+/// ## Usage
 ///
-/// # Multi-threaded runtime
-///
-/// To use the multi-threaded runtime, the macro can be configured using
+/// ### Multi-thread runtime
 ///
 /// ```no_run
 /// #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -393,16 +212,9 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// The `worker_threads` option configures the number of worker threads, and
-/// defaults to the number of cpus on the system.
+/// ### Using default
 ///
-/// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
-/// flag.
-///
-/// # Current thread runtime
-///
-/// The default test runtime is single-threaded. Each test gets a
-/// separate current-thread runtime.
+/// The default test runtime is single-threaded.
 ///
 /// ```no_run
 /// #[tokio::test]
@@ -411,168 +223,16 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// ## Usage
+/// ### NOTE:
 ///
-/// ### Using the multi-thread runtime
-///
-/// ```no_run
-/// #[tokio::test(flavor = "multi_thread")]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Using current thread runtime
-///
-/// ```no_run
-/// #[tokio::test]
-/// 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()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Set number of worker threads
-///
-/// ```no_run
-/// #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::test]`
-///
-/// ```no_run
-/// #[test]
-/// fn my_test() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .worker_threads(2)
-///         .enable_all()
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// ### Configure the runtime to start with time paused
-///
-/// ```no_run
-/// #[tokio::test(start_paused = true)]
-/// 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()
-///         .start_paused(true)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             assert!(true);
-///         })
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
-/// ### Rename package
-///
-/// ```rust
-/// use tokio as tokio1;
-///
-/// #[tokio1::test(crate = "tokio1")]
-/// async fn my_test() {
-///     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
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.3 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.3 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::test(args.into(), item.into(), true).into()
+    entry::test(args, item, true)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment
@@ -585,9 +245,17 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
 ///     assert!(true);
 /// }
 /// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.3 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.3 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::test(args.into(), item.into(), false).into()
+    entry::test(args, item, false)
 }
 
 /// Always fails with the error message below.
@@ -625,11 +293,3 @@ pub fn test_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
 pub fn select_priv_declare_output_enum(input: TokenStream) -> TokenStream {
     select::declare_output_enum(input)
 }
-
-/// Implementation detail of the `select!` macro. This macro is **not** intended
-/// to be used as part of the public API and is permitted to change.
-#[proc_macro]
-#[doc(hidden)]
-pub fn select_priv_clean_pattern(input: TokenStream) -> TokenStream {
-    select::clean_pattern_macro(input)
-}

tokio-macros/src/select.rs

@@ -1,7 +1,7 @@
 use proc_macro::{TokenStream, TokenTree};
 use proc_macro2::Span;
 use quote::quote;
-use syn::{parse::Parser, Ident};
+use syn::Ident;
 
 pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
     // passed in is: `(_ _ _)` with one `_` per branch
@@ -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
@@ -41,69 +41,3 @@ pub(crate) fn declare_output_enum(input: TokenStream) -> TokenStream {
         pub(super) type Mask = #mask;
     })
 }
-
-pub(crate) fn clean_pattern_macro(input: TokenStream) -> TokenStream {
-    // If this isn't a pattern, we return the token stream as-is. The select!
-    // macro is using it in a location requiring a pattern, so an error will be
-    // emitted there.
-    let mut input: syn::Pat = match syn::Pat::parse_single.parse(input.clone()) {
-        Ok(it) => it,
-        Err(_) => return input,
-    };
-
-    clean_pattern(&mut input);
-    quote::ToTokens::into_token_stream(input).into()
-}
-
-// Removes any occurrences of ref or mut in the provided pattern.
-fn clean_pattern(pat: &mut syn::Pat) {
-    match pat {
-        syn::Pat::Lit(_literal) => {}
-        syn::Pat::Macro(_macro) => {}
-        syn::Pat::Path(_path) => {}
-        syn::Pat::Range(_range) => {}
-        syn::Pat::Rest(_rest) => {}
-        syn::Pat::Verbatim(_tokens) => {}
-        syn::Pat::Wild(_underscore) => {}
-        syn::Pat::Ident(ident) => {
-            ident.by_ref = None;
-            ident.mutability = None;
-            if let Some((_at, pat)) = &mut ident.subpat {
-                clean_pattern(&mut *pat);
-            }
-        }
-        syn::Pat::Or(or) => {
-            for case in &mut or.cases {
-                clean_pattern(case);
-            }
-        }
-        syn::Pat::Slice(slice) => {
-            for elem in &mut slice.elems {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::Struct(struct_pat) => {
-            for field in &mut struct_pat.fields {
-                clean_pattern(&mut field.pat);
-            }
-        }
-        syn::Pat::Tuple(tuple) => {
-            for elem in &mut tuple.elems {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::TupleStruct(tuple) => {
-            for elem in &mut tuple.elems {
-                clean_pattern(elem);
-            }
-        }
-        syn::Pat::Reference(reference) => {
-            reference.mutability = None;
-            clean_pattern(&mut reference.pat);
-        }
-        syn::Pat::Type(type_pat) => {
-            clean_pattern(&mut type_pat.pat);
-        }
-        _ => {}
-    }
-}

tokio-stream/CHANGELOG.md

@@ -1,191 +0,0 @@
-# 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
-necessary for `timeout_repeating` to compile. ([#5657])
-
-[#5657]: https://github.com/tokio-rs/tokio/pull/5657
-
-# 0.1.13 (April 25th, 2023)
-
-This release bumps the MSRV of tokio-stream to 1.56.
-
-- stream: add "full" feature flag ([#5639])
-- stream: add `StreamExt::timeout_repeating` ([#5577])
-- stream: add `StreamNotifyClose` ([#4851])
-
-[#4851]: https://github.com/tokio-rs/tokio/pull/4851
-[#5577]: https://github.com/tokio-rs/tokio/pull/5577
-[#5639]: https://github.com/tokio-rs/tokio/pull/5639
-
-# 0.1.12 (January 20, 2023)
-
-- time: remove `Unpin` bound on `Throttle` methods ([#5105])
-- time: document that `throttle` operates on ms granularity ([#5101])
-- sync: add `WatchStream::from_changes` ([#5432])
-
-[#5105]: https://github.com/tokio-rs/tokio/pull/5105
-[#5101]: https://github.com/tokio-rs/tokio/pull/5101
-[#5432]: https://github.com/tokio-rs/tokio/pull/5432
-
-# 0.1.11 (October 11, 2022)
-
-- time: allow `StreamExt::chunks_timeout` outside of a runtime ([#5036])
-
-[#5036]: https://github.com/tokio-rs/tokio/pull/5036
-
-# 0.1.10 (Sept 18, 2022)
-
-- time: add `StreamExt::chunks_timeout` ([#4695])
-- stream: add track_caller to public APIs ([#4786])
-
-[#4695]: https://github.com/tokio-rs/tokio/pull/4695
-[#4786]: https://github.com/tokio-rs/tokio/pull/4786
-
-# 0.1.9 (June 4, 2022)
-
-- deps: upgrade `tokio-util` dependency to `0.7.x` ([#3762])
-- stream: add `StreamExt::map_while` ([#4351])
-- stream: add `StreamExt::then` ([#4355])
-- stream: add cancel-safety docs to `StreamExt::next` and `try_next` ([#4715])
-- stream: expose `Elapsed` error ([#4502])
-- stream: expose `Timeout` ([#4601])
-- stream: implement `Extend` for `StreamMap` ([#4272])
-- sync: add `Clone` to `RecvError` types ([#4560])
-
-[#3762]: https://github.com/tokio-rs/tokio/pull/3762
-[#4272]: https://github.com/tokio-rs/tokio/pull/4272
-[#4351]: https://github.com/tokio-rs/tokio/pull/4351
-[#4355]: https://github.com/tokio-rs/tokio/pull/4355
-[#4502]: https://github.com/tokio-rs/tokio/pull/4502
-[#4560]: https://github.com/tokio-rs/tokio/pull/4560
-[#4601]: https://github.com/tokio-rs/tokio/pull/4601
-[#4715]: https://github.com/tokio-rs/tokio/pull/4715
-
-# 0.1.8 (October 29, 2021)
-
-- stream: add `From<Receiver<T>>` impl for receiver streams ([#4080])
-- stream: impl `FromIterator` for `StreamMap` ([#4052])
-- signal: make windows docs for signal module show up on unix builds ([#3770])
-
-[#3770]: https://github.com/tokio-rs/tokio/pull/3770
-[#4052]: https://github.com/tokio-rs/tokio/pull/4052
-[#4080]: https://github.com/tokio-rs/tokio/pull/4080
-
-# 0.1.7 (July 7, 2021)
-
-### Fixed
-
-- sync: fix watch wrapper ([#3914])
-- time: fix `Timeout::size_hint` ([#3902])
-
-[#3902]: https://github.com/tokio-rs/tokio/pull/3902
-[#3914]: https://github.com/tokio-rs/tokio/pull/3914
-
-# 0.1.6 (May 14, 2021)
-
-### Added
-
-- stream: implement `Error` and `Display` for `BroadcastStreamRecvError` ([#3745])
-
-### Fixed
-
-- stream: avoid yielding in `AllFuture` and `AnyFuture` ([#3625])
-
-[#3745]: https://github.com/tokio-rs/tokio/pull/3745
-[#3625]: https://github.com/tokio-rs/tokio/pull/3625
-
-# 0.1.5 (March 20, 2021)
-
-### Fixed
-
-- stream: documentation note for throttle `Unpin` ([#3600])
-
-[#3600]: https://github.com/tokio-rs/tokio/pull/3600
-
-# 0.1.4 (March 9, 2021)
-
-Added
-
-- signal: add `Signal` wrapper ([#3510])
-
-Fixed
-
-- stream: remove duplicate `doc_cfg` declaration ([#3561])
-- sync: yield initial value in `WatchStream` ([#3576])
-
-[#3510]: https://github.com/tokio-rs/tokio/pull/3510
-[#3561]: https://github.com/tokio-rs/tokio/pull/3561
-[#3576]: https://github.com/tokio-rs/tokio/pull/3576
-
-# 0.1.3 (February 5, 2021)
-
-Added
-
- - sync: add wrapper for broadcast and watch ([#3384], [#3504])
-
-[#3384]: https://github.com/tokio-rs/tokio/pull/3384
-[#3504]: https://github.com/tokio-rs/tokio/pull/3504
-
-# 0.1.2 (January 12, 2021)
-
-Fixed
-
- - docs: fix some wrappers missing in documentation ([#3378])
-
-[#3378]: https://github.com/tokio-rs/tokio/pull/3378
-
-# 0.1.1 (January 4, 2021)
-
-Added
-
- - add `Stream` wrappers ([#3343])
-
-Fixed
-
- - move `async-stream` to `dev-dependencies` ([#3366])
-
-[#3366]: https://github.com/tokio-rs/tokio/pull/3366
-[#3343]: https://github.com/tokio-rs/tokio/pull/3343
-
-# 0.1.0 (December 23, 2020)
-
- - Initial release

tokio-stream/Cargo.toml

@@ -1,61 +0,0 @@
-[package]
-name = "tokio-stream"
-# When releasing to crates.io:
-# - Remove path dependencies
-# - Update CHANGELOG.md.
-# - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.17"
-edition = "2021"
-rust-version = "1.71"
-authors = ["Tokio Contributors <[email protected]>"]
-license = "MIT"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-description = """
-Utilities to work with `Stream` and `tokio`.
-"""
-categories = ["asynchronous"]
-
-[features]
-default = ["time"]
-
-full = [
-    "time",
-    "net",
-    "io-util",
-    "fs",
-    "sync",
-    "signal"
-]
-
-time = ["tokio/time"]
-net = ["tokio/net"]
-io-util = ["tokio/io-util"]
-fs = ["tokio/fs"]
-sync = ["tokio/sync", "tokio-util"]
-signal = ["tokio/signal"]
-
-[dependencies]
-futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.11"
-tokio = { version = "1.15.0", path = "../tokio", features = ["sync"] }
-tokio-util = { version = "0.7.0", path = "../tokio-util", optional = true }
-
-[dev-dependencies]
-tokio = { version = "1.2.0", path = "../tokio", features = ["full", "test-util"] }
-async-stream = "0.3"
-parking_lot = "0.12.0"
-tokio-test = { version = "0.4", path = "../tokio-test" }
-futures = { version = "0.3", default-features = false }
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-# Issue #3770
-#
-# 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 +0,0 @@
-MIT License
-
-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:
-
-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.