Add more unit tests for UdpFramed (#1522)

Signed-off-by: Lucio Franco <[email protected]>

.cirrus.yml

@@ -1,71 +1,41 @@
-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-0-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 12.0
   env:
-    RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-    RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+    LOOM_MAX_DURATION: 10
   setup_script:
-    - pkg install -y bash
+    - pkg install -y 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
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
+      # Remove any existing patch statements
+      mv Cargo.toml Cargo.toml.bck
+      sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
+  cargo_cache:
+    folder: $HOME/.cargo/registry
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --features $TOKIO_STABLE_FEATURES --target i686-unknown-freebsd
+    - cargo test --all
+    - cargo doc --all
+  i686_test_script:
+    - . $HOME/.cargo/env
+    - |
+      cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd
+  before_cache_script:
+    - rm -rf $HOME/.cargo/registry/index

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,51 @@
+<!--
+Thank you for reporting an issue.
+
+Please fill in as much of the template below as you're able.
+-->
+
+## Version
+
+<!--
+List the versions of all `tokio` crates you are using. The easiest way to get
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
+
+`cargo tree | grep tokio`
+-->
+
+## Platform
+
+<!---
+Output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
+-->
+
+## Subcrates
+
+<!--
+If known, please specify the affected Tokio sub crates. Otherwise, delete this
+section.
+-->
+
+## Description
+
+<!--
+
+Enter your issue details below this comment.
+
+One way to structure the description:
+
+<short summary of the bug>
+
+I tried this code:
+
+<code sample that causes the bug>
+
+I expected to see this happen: <explanation>
+
+Instead, this happened: <explanation>
+-->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,31 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: A-tokio, C-bug
-assignees: ''
-
----
-
-**Version**
-List the versions of all `tokio` crates you are using. The easiest way to get
-this information is using `cargo tree` subcommand:
-
-`cargo tree | grep tokio`
-
-**Platform**
-The output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
-
-**Description**
-Enter your issue details here.
-One way to structure the description:
-
-[short summary of the bug]
-
-I tried this code:
-
-[code sample that causes the bug]
-
-I expected to see this happen: [explanation]
-
-Instead, this happened: [explanation]

.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/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: A-tokio, C-feature-request
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -5,9 +5,6 @@ the requirements below.
 Bug fixes and new features should include tests.
 
 Contributors guide: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
-
-The contributors guide includes instructions for running rustfmt and building the
-documentation, which requires special commands beyond `cargo fmt` and `cargo doc`.
 -->
 
 ## Motivation

.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

@@ -1,24 +0,0 @@
-name: Security Audit
-
-on:
-  push:
-    branches:
-      - master
-    paths:
-      - '**/Cargo.toml'
-  schedule:
-    - cron: '0 2 * * *' # run at 2 AM UTC
-
-permissions:
-  contents: read
-
-jobs:
-  cargo-deny:
-    permissions:
-      checks: write
-      contents: read
-      issues: write
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v5
-    - uses: EmbarkStudios/cargo-deny-action@v2

.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

@@ -1,23 +0,0 @@
-name: Pull Request Security Audit
-
-on:
-  push:
-    paths:
-      - '**/Cargo.toml'
-  pull_request:
-    paths:
-      - '**/Cargo.toml'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v5
-    - uses: EmbarkStudios/cargo-deny-action@v2

.github/workflows/stress-test.yml

@@ -1,45 +0,0 @@
-name: Stress Test
-on:
-  pull_request:
-  push:
-    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:
-    name: Stress Test
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        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: 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 }}

.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

CODE_OF_CONDUCT.md

@@ -1,7 +0,0 @@
-# Code of Conduct
-
-The Tokio project adheres to the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct). This describes the minimum behavior expected from all contributors.
-
-## Enforcement
-
-Instances of violations of the Code of Conduct can be reported by contacting the project team at [[email protected]](mailto:[email protected]).

CONTRIBUTING.md

@@ -12,17 +12,15 @@ use your help.
 This guide will help you get started. **Do not let this guide intimidate you**.
 It should be considered a map to help you navigate the process.
 
-The [dev channel][dev] is available for any concerns not covered in this guide, please join
+You may also get help with contributing in the [dev channel][dev], please join
 us!
 
-[dev]: https://discord.gg/tokio
+[dev]: https://gitter.im/tokio-rs/dev
 
 ## Conduct
 
 The Tokio project adheres to the [Rust Code of Conduct][coc]. This describes
-the _minimum_ behavior expected from all contributors. Instances of violations of the
-Code of Conduct can be reported by contacting the project team at
-[[email protected]](mailto:[email protected]).
+the _minimum_ behavior expected from all contributors.
 
 [coc]: https://github.com/rust-lang/rust/blob/master/CODE_OF_CONDUCT.md
 
@@ -31,8 +29,8 @@ Code of Conduct can be reported by contacting the project team at
 For any issue, there are fundamentally three ways an individual can contribute:
 
 1. By opening the issue for discussion: For instance, if you believe that you
-   have discovered a bug in Tokio, creating a new issue in [the tokio-rs/tokio
-   issue tracker][issue] is the way to report it.
+   have uncovered a bug in Tokio, creating a new issue in the tokio-rs/tokio
+   issue tracker is the way to report it.
 
 2. By helping to triage the issue: This can be done by providing
    supporting details (a test case that demonstrates a bug), providing
@@ -44,25 +42,21 @@ For any issue, there are fundamentally three ways an individual can contribute:
    often, by opening a Pull Request that changes some bit of something in
    Tokio in a concrete and reviewable manner.
 
-[issue]: https://github.com/tokio-rs/tokio/issues
-
 **Anybody can participate in any stage of contribution**. We urge you to
 participate in the discussion around bugs and participate in reviewing PRs.
 
 ### Asking for General Help
 
 If you have reviewed existing documentation and still have questions or are
-having problems, you can [open a discussion] asking for help.
+having problems, you can open an issue asking for help.
 
 In exchange for receiving help, we ask that you contribute back a documentation
 PR that helps others avoid the problems that you encountered.
 
-[open a discussion]: https://github.com/tokio-rs/tokio/discussions/new
-
 ### Submitting a Bug Report
 
-When opening a new issue in the Tokio issue tracker, you will be presented
-with a basic template that should be filled in. If you believe that you have
+When opening a new issue in the Tokio issue tracker, users will be presented
+with a [basic template][template] that should be filled in. If you believe that you have
 uncovered a bug, please fill out this form, following the template to the best
 of your ability. Do not worry if you cannot answer every detail, just fill in
 what you can.
@@ -78,6 +72,7 @@ cases should be limited, as much as possible, to using only Tokio APIs.
 See [How to create a Minimal, Complete, and Verifiable example][mcve].
 
 [mcve]: https://stackoverflow.com/help/mcve
+[template]: .github/PULL_REQUEST_TEMPLATE.md
 
 ### Triaging a Bug Report
 
@@ -117,133 +112,14 @@ usually a good idea to first open an issue describing the change to solicit
 feedback and guidance. This will increase the likelihood of the PR getting
 merged.
 
-### Cargo Commands
-
-Due to the extensive use of features in Tokio, you will often need to add extra
-arguments to many common cargo commands. This section lists some commonly needed
-commands.
-
-Some commands just need the `--all-features` argument:
-
-```
-cargo build --all-features
-cargo check --all-features
-cargo test --all-features
-```
-
-Ideally, you should use the same version of clippy as the one used in CI
-(defined by `env.rust_clippy` in [ci.yml][ci.yml]), because newer versions
-might have new lints:
-
-[ci.yml]: .github/workflows/ci.yml
-
-<!--
-When updating this, also update:
-- .github/workflows/ci.yml
-- README.md
-- tokio/README.md
-- tokio/Cargo.toml
-- tokio-util/Cargo.toml
-- tokio-test/Cargo.toml
-- tokio-stream/Cargo.toml
--->
-
-```
-cargo +1.88 clippy --all --tests --all-features
-```
-
-When building documentation, a simple `cargo doc` is not sufficient. To produce
-documentation equivalent to what will be produced in docs.rs's builds of Tokio's
-docs, please use:
-
-```
-RUSTDOCFLAGS="--cfg docsrs --cfg tokio_unstable" RUSTFLAGS="--cfg docsrs --cfg tokio_unstable" cargo +nightly doc --all-features [--open]
-```
-
-This turns on indicators to display the Cargo features required for
-conditionally compiled APIs in Tokio, and it enables documentation of unstable
-Tokio features. Notice that it is necessary to pass cfg flags to both RustDoc
-*and* rustc.
-
-There is a more concise way to build docs.rs-equivalent docs by using [`cargo
-docs-rs`], which reads the above documentation flags out of Tokio's Cargo.toml
-as docs.rs itself does.
-
-[`cargo docs-rs`]: https://github.com/dtolnay/cargo-docs-rs
-
-```
-cargo install --locked cargo-docs-rs
-cargo +nightly docs-rs [--open]
-```
-
-The `cargo fmt` command does not work on the Tokio codebase. You can use the
-command below instead:
-
-```
-# Mac or Linux
-rustfmt --check --edition 2021 $(git ls-files '*.rs')
-
-# Powershell
-Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2021 $_.FullName }
-```
-The `--check` argument prints the things that need to be fixed. If you remove
-it, `rustfmt` will update your files locally instead.
-
-You can run loom tests with
-```
-cd tokio # tokio crate in workspace
-LOOM_MAX_PREEMPTIONS=1 LOOM_MAX_BRANCHES=10000 RUSTFLAGS="--cfg loom -C debug_assertions" \
-    cargo test --lib --release --features full -- --test-threads=1 --nocapture
-```
-Additionally, you can also add `--cfg tokio_unstable` to the `RUSTFLAGS` environment variable to
-run loom tests that test unstable features.
-
-You can run miri tests with
-```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-strict-provenance -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
 
 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 +130,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
@@ -302,6 +153,8 @@ The type level example for `tokio_timer::Timeout` provides a good example of a
 documentation test:
 
 ```
+/// # extern crate futures;
+/// # extern crate tokio;
 /// // import the `timeout` function, usually this is done
 /// // with `use tokio::prelude::*`
 /// use tokio::prelude::FutureExt;
@@ -339,6 +192,8 @@ If this were a documentation test for the `Timeout::new` function, then the
 example would explicitly use `Timeout::new`. For example:
 
 ```
+/// # extern crate futures;
+/// # extern crate tokio;
 /// use tokio::timer::Timeout;
 /// use futures::Future;
 /// use futures::sync::oneshot;
@@ -355,29 +210,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
@@ -389,7 +221,7 @@ That said, if you have a number of commits that are "checkpoints" and don't
 represent a single logical change, please squash those together.
 
 Note that multiple commits often get squashed when they are landed (see the
-notes about [commit squashing](#commit-squashing)).
+notes about [commit squashing]).
 
 #### Commit message guidelines
 
@@ -401,16 +233,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 +257,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
@@ -462,7 +292,7 @@ in order to evaluate whether the changes are correct and necessary.
 Keep an eye out for comments from code owners to provide guidance on conflicting
 feedback.
 
-**Once the PR is open, do not rebase the commits**. See [Commit Squashing](#commit-squashing) for
+**Once the PR is open, do not rebase the commits**. See [Commit Squashing] for
 more details.
 
 ### Commit Squashing
@@ -555,180 +385,3 @@ _Adapted from the [Node.js contributing guide][node]_.
 [node]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
 [hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment
 [documentation test]: https://doc.rust-lang.org/rustdoc/documentation-tests.html
-
-## Keeping track of issues and PRs
-
-The Tokio GitHub repository has a lot of issues and PRs to keep track of. This
-section explains the meaning of various labels, as well as our [GitHub
-project][project]. The section is primarily targeted at maintainers.  Most
-contributors aren't able to set these labels.
-
-### Area
-
-The area label describes the crates relevant to this issue or PR.
-
- - **A-tokio** This issue concerns the main Tokio crate.
- - **A-tokio-util** This issue concerns the `tokio-util` crate.
- - **A-tokio-tls** This issue concerns the `tokio-tls` crate. Only used for
-   older issues, as the crate has been moved to another repository.
- - **A-tokio-test** The issue concerns the `tokio-test` crate.
- - **A-tokio-macros** This issue concerns the `tokio-macros` crate. Should only
-   be used for the procedural macros, and not `join!` or `select!`.
- - **A-ci** This issue concerns our GitHub Actions setup.
-
-### Category
-
- - **C-bug** This is a bug-report. Bug-fix PRs use `C-enhancement` instead.
- - **C-enhancement** This is a PR that adds a new features.
- - **C-maintenance** This is an issue or PR about stuff such as documentation,
-   GitHub Actions or code quality.
- - **C-feature-request** This is a feature request. Implementations of feature
-   requests use `C-enhancement` instead.
- - **C-feature-accepted** If you submit a PR for this feature request, we wont
-   close it with the reason "we don't want this". Issues with this label should
-   also have the `C-feature-request` label.
- - **C-musing** Stuff like tracking issues or roadmaps. "musings about a better
-   world"
- - **C-proposal** A proposal of some kind, and a request for comments.
- - **C-question** A user question. Large overlap with GitHub discussions.
- - **C-request** A non-feature request, e.g. "please add deprecation notices to
-   `-alpha.*` versions of crates"
-
-### Calls for participation
-
- - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
-   or `C-feature-accepted`.
- - **E-easy** This is easy, ranging from quick documentation fixes to stuff you
-   can do after reading the tutorial on our website.
- - **E-medium** This is not `E-easy` or `E-hard`.
- - **E-hard** This either involves very tricky code, is something we don't know
-   how to solve, or is difficult for some other reason.
- - **E-needs-mvce** This bug is missing a minimal complete and verifiable
-   example.
-
-The "E-" prefix is the same as used in the Rust compiler repository. Some
-issues are missing a difficulty rating, but feel free to ask on our Discord
-server if you want to know how difficult an issue likely is.
-
-### Module
-
-The module label provides a more fine grained categorization than **Area**.
-
- - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
- - **M-codec** The `tokio_util::codec` module.
- - **M-compat** The `tokio_util::compat` module.
- - **M-coop** Things relevant to coop.
- - **M-fs** The `tokio::fs` module.
- - **M-io** The `tokio::io` module.
- - **M-macros** Issues about any kind of macro.
- - **M-net** The `tokio::net` module.
- - **M-process** The `tokio::process` module.
- - **M-runtime** The `tokio::runtime` module.
- - **M-signal** The `tokio::signal` module.
- - **M-sync** The `tokio::sync` module.
- - **M-task** The `tokio::task` module.
- - **M-time** The `tokio::time` module.
- - **M-tracing** Tracing support in Tokio.
-
-### Topic
-
-Some extra information.
-
- - **T-docs** This is about documentation.
- - **T-performance** This is about performance.
- - **T-v0.1.x** This is about old Tokio.
-
-Any label not listed here is not in active use.
-
-[project]: https://github.com/orgs/tokio-rs/projects/1
-
-## LTS guarantees
-
-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
-each other, releasing new versions to crates.io can involve some complexities.
-When releasing a new version of a crate, follow these steps:
-
-1. **Ensure that the release crate has no path dependencies.** When the HEAD
-   version of a Tokio crate requires unreleased changes in another Tokio crate,
-   the crates.io dependency on the second crate will be replaced with a path
-   dependency. Crates with path dependencies cannot be published, so before
-   publishing the dependent crate, any path dependencies must also be published.
-   This should be done through a form of depth-first tree traversal:
-
-   1. Starting with the first path dependency in the crate to be released,
-      inspect the `Cargo.toml` for the dependency. If the dependency has any
-      path dependencies of its own, repeat this step with the first such
-      dependency.
-   2. Begin the release process for the path dependency.
-   3. Once the path dependency has been published to crates.io, update the
-      dependent crate to depend on the crates.io version.
-   4. When all path dependencies have been published, the dependent crate may
-      be published.
-
-   To verify that a crate is ready to publish, run:
-
-   ```bash
-   bin/publish --dry-run <CRATE NAME> <CRATE VERSION>
-   ```
-
-2. **Update Cargo metadata.** After releasing any path dependencies, update the
-   `version` field in `Cargo.toml` to the new version, and the `documentation`
-   field to the docs.rs URL of the new version.
-3. **Update other documentation links.** Update the "Documentation" link in the
-   crate's `README.md` to point to the docs.rs URL of the new version.
-4. **Update the changelog for the crate.** Each crate in the Tokio repository
-   has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
-   crate since the last release should be added to the changelog. Change
-   descriptions may be taken from the Git history, but should be edited to
-   ensure a consistent format, based on [Keep A Changelog][keep-a-changelog].
-   Other entries in that crate's changelog may also be used for reference.
-5. **Perform a final audit for breaking changes.** Compare the HEAD version of
-   crate with the Git tag for the most recent release version. If there are any
-   breaking API changes, determine if those changes can be made without breaking
-   existing APIs. If so, resolve those issues. Otherwise, if it is necessary to
-   make a breaking release, update the version numbers to reflect this.
-6. **Open a pull request with your changes.** Once that pull request has been
-   approved by a maintainer and the pull request has been merged, continue to
-   the next step.
-7. **Release the crate.** Run the following command:
-
-   ```bash
-   bin/publish <NAME OF CRATE> <VERSION>
-   ```
-
-   Your editor and prompt you to edit a message for the tag. Copy the changelog
-   entry for that release version into your editor and close the window.
-
-[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md
-[unit-tests]: https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html
-[integration-tests]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
-[documentation-tests]: https://doc.rust-lang.org/rust-by-example/testing/doc_testing.html
-[conditional-compilation]: https://doc.rust-lang.org/reference/conditional-compilation.html

Cargo.toml

@@ -1,32 +1,22 @@
 [workspace]
-resolver = "2"
+
 members = [
   "tokio",
-  "tokio-macros",
+  "tokio-buf",
+  "tokio-codec",
+  "tokio-current-thread",
+  "tokio-executor",
+  "tokio-fs",
+  "tokio-futures",
+  "tokio-io",
+  "tokio-reactor",
+  "tokio-signal",
+  "tokio-sync",
   "tokio-test",
-  "tokio-stream",
-  "tokio-util",
-
-  # Internal
-  "benches",
-  "examples",
-  "stress-test",
-  "tests-build",
-  "tests-integration",
+  "tokio-threadpool",
+  "tokio-timer",
+  "tokio-tcp",
+  "tokio-tls",
+  "tokio-udp",
+  "tokio-uds",
 ]
-
-[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

@@ -14,22 +14,26 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Build Status][actions-badge]][actions-url]
-[![Discord chat][discord-badge]][discord-url]
+[![Build Status][azure-badge]][azure-url]
+[![Gitter chat][gitter-badge]][gitter-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
-[actions-badge]: https://github.com/tokio-rs/tokio/workflows/CI/badge.svg
-[actions-url]: https://github.com/tokio-rs/tokio/actions?query=workflow%3ACI+branch%3Amaster
-[discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord&style=flat-square
-[discord-url]: https://discord.gg/tokio
+[mit-url]: LICENSE
+[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
+[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
+[gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
+[gitter-url]: https://gitter.im/tokio-rs/tokio
 
 [Website](https://tokio.rs) |
-[Guides](https://tokio.rs/tokio/tutorial) |
-[API Docs](https://docs.rs/tokio/latest/tokio) |
-[Chat](https://discord.gg/tokio)
+[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
+[API Docs](https://docs.rs/tokio/0.1.20/tokio) |
+[Chat](https://gitter.im/tokio-rs/tokio)
+
+The API docs for the master branch are published [here][master-dox].
+
+[master-dox]: https://tokio-rs.github.io/tokio/doc/tokio/
 
 ## Overview
 
@@ -38,86 +42,73 @@ asynchronous applications with the Rust programming language. At a high
 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.).
+* A [reactor] backed by the operating system's event queue (epoll, kqueue,
+  IOCP, etc...).
 * Asynchronous [TCP and UDP][net] sockets.
 
 These components provide the runtime components necessary for building
 an asynchronous application.
 
-[net]: https://docs.rs/tokio/latest/tokio/net/index.html
-[scheduler]: https://docs.rs/tokio/latest/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/0.1.20/tokio/net/index.html
+[reactor]: https://docs.rs/tokio/0.1.20/tokio/reactor/index.html
+[scheduler]: https://docs.rs/tokio/0.1.20/tokio/runtime/index.html
 
 ## Example
 
-A basic TCP echo server with Tokio.
+A basic TCP echo server with Tokio:
 
-Make sure you activated the full features of the tokio crate on Cargo.toml:
+```rust
+extern crate tokio;
 
-```toml
-[dependencies]
-tokio = { version = "1.47.1", features = ["full"] }
-```
-Then, on your main.rs:
-
-```rust,no_run
+use tokio::prelude::*;
+use tokio::io::copy;
 use tokio::net::TcpListener;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+fn main() {
+    // Bind the server's socket.
+    let addr = "127.0.0.1:12345".parse().unwrap();
+    let listener = TcpListener::bind(&addr)
+        .expect("unable to bind TCP listener");
 
-    loop {
-        let (mut socket, _) = listener.accept().await?;
+    // Pull out a stream of sockets for incoming connections
+    let server = listener.incoming()
+        .map_err(|e| eprintln!("accept failed = {:?}", e))
+        .for_each(|sock| {
+            // Split up the reading and writing parts of the
+            // socket.
+            let (reader, writer) = sock.split();
 
-        tokio::spawn(async move {
-            let mut buf = [0; 1024];
+            // A future that echos the data and returns how
+            // many bytes were copied...
+            let bytes_copied = copy(reader, writer);
 
-            // In a loop, read data from the socket and write the data back.
-            loop {
-                let n = match socket.read(&mut buf).await {
-                    // socket closed
-                    Ok(0) => return,
-                    Ok(n) => n,
-                    Err(e) => {
-                        eprintln!("failed to read from socket; err = {:?}", e);
-                        return;
-                    }
-                };
+            // ... after which we'll print what happened.
+            let handle_conn = bytes_copied.map(|amt| {
+                println!("wrote {:?} bytes", amt)
+            }).map_err(|err| {
+                eprintln!("IO error {:?}", err)
+            });
 
-                // Write the data back
-                if let Err(e) = socket.write_all(&buf[0..n]).await {
-                    eprintln!("failed to write to socket; err = {:?}", e);
-                    return;
-                }
-            }
+            // Spawn the future as a concurrent task.
+            tokio::spawn(handle_conn)
         });
-    }
+
+    // Start the Tokio runtime
+    tokio::run(server);
 }
 ```
 
-More examples can be found [here][examples]. For a larger "real world" example, see the
-[mini-redis] repository.
-
-[examples]: https://github.com/tokio-rs/tokio/tree/master/examples
-[mini-redis]: https://github.com/tokio-rs/mini-redis/
-
-To see a list of the available features flags that can be enabled, check our
-[docs][feature-flag-docs].
+More examples can be found [here](tokio/examples).
 
 ## Getting Help
 
 First, see if the answer to your question can be found in the [Guides] or the
 [API documentation]. If the answer is not there, there is an active community in
-the [Tokio Discord server][chat]. We would be happy to try to answer your
-question. You can also ask your question on [the discussions page][discussions].
+the [Tokio Gitter channel][chat]. We would be happy to try to answer your
+question.  Last, if that doesn't work, try opening an [issue] with the question.
 
-[Guides]: https://tokio.rs/tokio/tutorial
-[API documentation]: https://docs.rs/tokio/latest/tokio
-[chat]: https://discord.gg/tokio
-[discussions]: https://github.com/tokio-rs/tokio/discussions
-[feature-flag-docs]: https://docs.rs/tokio/#feature-flags
+[chat]: https://gitter.im/tokio-rs/tokio
+[issue]: https://github.com/tokio-rs/tokio/issues/new
 
 ## Contributing
 
@@ -125,128 +116,88 @@ question. You can also ask your question on [the discussions page][discussions].
 you! We have a [contributing guide][guide] to help you get involved in the Tokio
 project.
 
-[guide]: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
+[guide]: CONTRIBUTING.md
+
+## Project layout
+
+The `tokio` crate, found at the root, is primarily intended for use by
+application developers.  Library authors should depend on the sub crates, which
+have greater guarantees of stability.
+
+The crates included as part of Tokio are:
+
+* [`tokio-current-thread`]: Schedule the execution of futures on the current
+  thread.
+
+* [`tokio-executor`]: Task execution related traits and utilities.
+
+* [`tokio-fs`]: Filesystem (and standard in / out) APIs.
+
+* [`tokio-futures`]: Experimental `std::future::Future` and `async` / `await` support.
+
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
+* [`tokio-io`]: Asynchronous I/O related traits and utilities.
+
+* [`tokio-macros`]: Macros for usage with Tokio.
+
+* [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
+  sockets).
+
+* [`tokio-tcp`]: TCP bindings for use with `tokio-io` and `tokio-reactor`.
+
+* [`tokio-threadpool`]: Schedules the execution of futures across a pool of
+  threads.
+
+* [ `tokio-timer`]: Time related APIs.
+
+* [`tokio-udp`]: UDP bindings for use with `tokio-io` and `tokio-reactor`.
+
+* [`tokio-uds`]: Unix Domain Socket bindings for use with `tokio-io` and
+  `tokio-reactor`.
+
+[`tokio-codec`]: tokio-codec
+[`tokio-current-thread`]: tokio-current-thread
+[`tokio-executor`]: tokio-executor
+[`tokio-fs`]: tokio-fs
+[`tokio-futures`]: tokio-futures
+[`tokio-io`]: tokio-io
+[`tokio-macros`]: tokio-macros
+[`tokio-reactor`]: tokio-reactor
+[`tokio-tcp`]: tokio-tcp
+[`tokio-threadpool`]: tokio-threadpool
+[`tokio-timer`]: tokio-timer
+[`tokio-udp`]: tokio-udp
+[`tokio-uds`]: tokio-uds
 
 ## Related Projects
 
 In addition to the crates in this repository, the Tokio project also maintains
 several other libraries, including:
 
-* [`axum`]: A web application framework that focuses on ergonomics and modularity.
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
 
-* [`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.
-
-* [`warp`]: A super-easy, composable, web server framework for warp speeds.
-
-* [`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.
-
-* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers `tokio`.
+* [`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.
-
-[`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
 [`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, nightly, and beta Rust releases. The
+minimum version supported is the stable release from three months before the
+current stable release version. For example, if the latest stable Rust is 1.29,
+the minimum version supported is 1.26. The current Tokio version is not
+guaranteed to build on Rust versions earlier than the minimum supported version.
 
 ## License
 
-This project is licensed under the [MIT license].
-
-[MIT license]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
+This project is licensed under the [MIT license](LICENSE).
 
 ### Contribution
 

SECURITY.md

@@ -1,13 +0,0 @@
-## 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.
-
-## 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.
-
-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`).

async-await/.cargo/config

@@ -0,0 +1,2 @@
+[build]
+target-dir = "../target"

async-await/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "examples"
+edition = "2018"
+version = "0.1.0"
+authors = ["Carl Lerche <[email protected]>"]
+license = "MIT"
+
+# Break out of the parent workspace
+[workspace]
+
+[[bin]]
+name = "chat"
+path = "src/chat.rs"
+
+[[bin]]
+name = "echo_client"
+path = "src/echo_client.rs"
+
+[[bin]]
+name = "echo_server"
+path = "src/echo_server.rs"
+
+[[bin]]
+name = "hyper"
+path = "src/hyper.rs"
+
+[dependencies]
+tokio = { version = "0.1.18", features = ["async-await-preview"] }
+futures = "0.1.23"
+bytes = "0.4.9"
+hyper = "0.12.8"
+
+# Avoid using crates.io for Tokio dependencies
+[patch.crates-io]
+tokio = { path = "../tokio" }
+tokio-codec = { path = "../tokio-codec" }
+tokio-current-thread = { path = "../tokio-current-thread" }
+tokio-executor = { path = "../tokio-executor" }
+tokio-fs = { path = "../tokio-fs" }
+tokio-futures  = { path = "../tokio-futures" }
+tokio-io = { path = "../tokio-io" }
+tokio-reactor = { path = "../tokio-reactor" }
+tokio-signal = { path = "../tokio-signal" }
+tokio-tcp = { path = "../tokio-tcp" }
+tokio-threadpool = { path = "../tokio-threadpool" }
+tokio-timer = { path = "../tokio-timer" }
+tokio-tls = { path = "../tokio-tls" }
+tokio-udp = { path = "../tokio-udp" }
+tokio-uds = { path = "../tokio-uds" }

async-await/README.md

@@ -0,0 +1,5 @@
+# Tokio async/await examples
+
+These are a separate crate in order to work around some cargo bugs. It also
+allows `[patch]` to be used in `Cargo.toml` to ensure the correct lib versions
+are being pulled in.

async-await/src/chat.rs

@@ -0,0 +1,131 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::codec::{LinesCodec, Decoder};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::prelude::*;
+
+use futures::sync::mpsc;
+
+use std::collections::HashMap;
+use std::io;
+use std::net::SocketAddr;
+use std::sync::{Arc, Mutex};
+
+/// Shorthand for the transmit half of the message channel.
+type Tx = mpsc::UnboundedSender<String>;
+
+struct Shared {
+    peers: HashMap<SocketAddr, Tx>,
+}
+
+impl Shared {
+    /// Create a new, empty, instance of `Shared`.
+    fn new() -> Self {
+        Shared {
+            peers: HashMap::new(),
+        }
+    }
+}
+
+async fn process(stream: TcpStream, state: Arc<Mutex<Shared>>) -> io::Result<()> {
+    let addr = stream.peer_addr().unwrap();
+    let mut lines = LinesCodec::new().framed(stream);
+
+    // Extract the peer's name
+    let name = match await!(lines.next()) {
+        Some(name) => name?,
+        None => {
+            // Disconnected early
+            return Ok(());
+        }
+    };
+
+    println!("`{}` is joining the chat", name);
+
+    let (tx, mut rx) = mpsc::unbounded();
+
+    // Register the socket
+    state.lock().unwrap()
+        .peers.insert(addr, tx);
+
+    // Split the `lines` handle into send and recv handles. This allows spawning
+    // separate tasks.
+    let (mut lines_tx, mut lines_rx) = lines.split();
+
+    // Spawn a task that receives all lines broadcasted to us from other peers
+    // and writes it to the client.
+    tokio::spawn_async(async move {
+        while let Some(line) = await!(rx.next()) {
+            let line = line.unwrap();
+            await!(lines_tx.send_async(line)).unwrap();
+        }
+    });
+
+    // Use the current task to read lines from the socket and broadcast them to
+    // other peers.
+    while let Some(message) = await!(lines_rx.next()) {
+        // TODO: Error handling
+        let message = message.unwrap();
+
+        let mut line = name.clone();
+        line.push_str(": ");
+        line.push_str(&message);
+        line.push_str("\r\n");
+
+        let state = state.lock().unwrap();
+
+        for (peer_addr, tx) in &state.peers {
+            if *peer_addr != addr {
+                // TODO: Error handling
+                tx.unbounded_send(line.clone()).unwrap();
+            }
+        }
+    }
+
+    // Remove the client from the shared state. Doing so will also result in the
+    // tx task to terminate.
+    state.lock().unwrap()
+        .peers.remove(&addr)
+        .expect("bug");
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    // Create the shared state. This is how all the peers communicate.
+    //
+    // The server task will hold a handle to this. For every new client, the
+    // `state` handle is cloned and passed into the task that processes the
+    // client connection.
+    let state = Arc::new(Mutex::new(Shared::new()));
+
+    let addr = "127.0.0.1:6142".parse().unwrap();
+
+    // Bind a TCP listener to the socket address.
+    //
+    // Note that this is the Tokio TcpListener, which is fully async.
+    let listener = TcpListener::bind(&addr).unwrap();
+
+    println!("server running on localhost:6142");
+
+    // Start the Tokio runtime.
+    let mut incoming = listener.incoming();
+
+    while let Some(stream) = await!(incoming.next()) {
+        let stream = match stream {
+            Ok(stream) => stream,
+            Err(_) => continue,
+        };
+
+        let state = state.clone();
+
+        tokio::spawn_async(async move {
+            if let Err(_) = await!(process(stream, state)) {
+                eprintln!("failed to process connection");
+            }
+        });
+    }
+}
+

async-await/src/echo_client.rs

@@ -0,0 +1,50 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::net::TcpStream;
+use tokio::prelude::*;
+
+use std::io;
+use std::net::SocketAddr;
+
+const MESSAGES: &[&str] = &[
+    "hello",
+    "world",
+    "one two three",
+];
+
+async fn run_client(addr: &SocketAddr) -> io::Result<()> {
+    let mut stream = await!(TcpStream::connect(addr))?;
+
+    // Buffer to read into
+    let mut buf = [0; 128];
+
+    for msg in MESSAGES {
+        println!(" > write = {:?}", msg);
+
+        // Write the message to the server
+        await!(stream.write_all_async(msg.as_bytes()))?;
+
+        // Read the message back from the server
+        await!(stream.read_exact_async(&mut buf[..msg.len()]))?;
+
+        assert_eq!(&buf[..msg.len()], msg.as_bytes());
+    }
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    use std::env;
+
+    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
+    let addr = addr.parse::<SocketAddr>().unwrap();
+
+    // Connect to the echo serveer
+
+    match await!(run_client(&addr)) {
+        Ok(_) => println!("done."),
+        Err(e) => eprintln!("echo client failed; error = {:?}", e),
+    }
+}

async-await/src/echo_server.rs

@@ -0,0 +1,42 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::prelude::*;
+
+use std::net::SocketAddr;
+
+fn handle(mut stream: TcpStream) {
+    tokio::spawn_async(async move {
+        let mut buf = [0; 1024];
+
+        loop {
+            match await!(stream.read_async(&mut buf)).unwrap() {
+                0 => break, // Socket closed
+                n => {
+                    // Send the data back
+                    await!(stream.write_all_async(&buf[0..n])).unwrap();
+                }
+            }
+        }
+    });
+}
+
+#[tokio::main]
+async fn main() {
+    use std::env;
+
+    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
+    let addr = addr.parse::<SocketAddr>().unwrap();
+
+    // Bind the TCP listener
+    let listener = TcpListener::bind(&addr).unwrap();
+    println!("Listening on: {}", addr);
+
+    let mut incoming = listener.incoming();
+
+    while let Some(stream) = await!(incoming.next()) {
+        let stream = stream.unwrap();
+        handle(stream);
+    }
+}

async-await/src/hyper.rs

@@ -0,0 +1,29 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::prelude::*;
+use hyper::Client;
+
+use std::time::Duration;
+use std::str;
+
+#[tokio::main]
+async fn main() {
+    let client = Client::new();
+
+    let uri = "http://httpbin.org/ip".parse().unwrap();
+
+    let response = await!({
+        client.get(uri)
+            .timeout(Duration::from_secs(10))
+    }).unwrap();
+
+    println!("Response: {}", response.status());
+
+    let mut body = response.into_body();
+
+    while let Some(chunk) = await!(body.next()) {
+        let chunk = chunk.unwrap();
+        println!("chunk = {}", str::from_utf8(&chunk[..]).unwrap());
+    }
+}

async-await/tests/macros.rs

@@ -0,0 +1,22 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::timer::Delay;
+use std::time::{Duration, Instant};
+
+#[tokio::test]
+async fn success_no_async() {
+    assert!(true);
+}
+
+#[tokio::test]
+#[should_panic]
+async fn fail_no_async() {
+    assert!(false);
+}
+
+#[tokio::test]
+async fn use_timer() {
+    let when = Instant::now() + Duration::from_millis(10);
+    await!(Delay::new(when));
+}

azure-pipelines.yml

@@ -0,0 +1,111 @@
+trigger: ["master", "v0.1.x"]
+pr: ["master", "v0.1.x"]
+
+jobs:
+# Check formatting
+- template: ci/azure-rustfmt.yml
+  parameters:
+    name: rustfmt
+
+# Test top level crate
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_tokio
+    displayName: Test tokio
+    cross: true
+    crates:
+      - tokio
+
+# Test crates that are platform specific
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_sub_cross
+    displayName: Test sub crates -
+    cross: true
+    crates:
+      - tokio-fs
+      - tokio-reactor
+      - tokio-signal
+      - tokio-tcp
+      - tokio-tls
+      - tokio-udp
+      - tokio-uds
+
+# Test crates that are NOT platform specific
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_linux
+    displayName: Test sub crates -
+    crates:
+      - tokio-buf
+      - tokio-codec
+      - tokio-current-thread
+      - tokio-executor
+      - tokio-io
+      - tokio-sync
+      - tokio-threadpool
+      - tokio-timer
+      - tokio-test
+
+- template: ci/azure-cargo-check.yml
+  parameters:
+    name: features
+    displayName: Check feature permtuations
+    rust: stable
+    crates:
+      tokio:
+        - codec
+        - fs
+        - io
+        - reactor
+        - rt-full
+        - tcp
+        - timer
+        - udp
+        - uds
+        - sync
+        - experimental-tracing
+      tokio-buf:
+        - util
+
+# Run async-await tests
+- template: ci/azure-test-nightly.yml
+  parameters:
+    name: test_nightly
+    displayName: Test Async / Await
+    rust: nightly-2019-04-25
+
+# Try cross compiling
+- template: ci/azure-cross-compile.yml
+  parameters:
+    name: cross_32bit_linux
+    target: i686-unknown-linux-gnu
+
+# This represents the minimum Rust version supported by
+# Tokio. Updating this should be done in a dedicated PR and
+# cannot be greater than two 0.x releases prior to the
+# current stable.
+#
+# Tests are not run as tests may require newer versions of
+# rust.
+- template: ci/azure-check-minrust.yml
+  parameters:
+    name: minrust
+    rust_version: 1.28.0
+
+- template: ci/azure-tsan.yml
+  parameters:
+    name: tsan
+
+- template: ci/azure-deploy-docs.yml
+  parameters:
+    dependsOn:
+      - rustfmt
+      - test_tokio
+      - test_sub_cross
+      - test_linux
+      - features
+      - test_nightly
+      - cross_32bit_linux
+      - minrust
+      - tsan

benches/Cargo.toml

@@ -1,100 +0,0 @@
-[package]
-name = "benches"
-version = "0.0.0"
-publish = false
-edition = "2021"
-license = "MIT"
-
-[features]
-test-util = ["tokio/test-util"]
-
-[dependencies]
-tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-criterion = "0.5.1"
-rand = "0.9"
-rand_chacha = "0.9"
-
-[dev-dependencies]
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-
-[target.'cfg(unix)'.dependencies]
-libc = "0.2.42"
-
-[[bench]]
-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"
-path = "sync_rwlock.rs"
-harness = false
-
-[[bench]]
-name = "sync_semaphore"
-path = "sync_semaphore.rs"
-harness = false
-
-[[bench]]
-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/latency.rs

@@ -0,0 +1,115 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+#[macro_use]
+extern crate futures;
+extern crate tokio;
+
+use std::io;
+use std::net::SocketAddr;
+use std::thread;
+
+use futures::sync::mpsc;
+use futures::sync::oneshot;
+use futures::{Future, Poll, Sink, Stream};
+use test::Bencher;
+use tokio::net::UdpSocket;
+
+/// UDP echo server
+struct EchoServer {
+    socket: UdpSocket,
+    buf: Vec<u8>,
+    to_send: Option<(usize, SocketAddr)>,
+}
+
+impl EchoServer {
+    fn new(s: UdpSocket) -> Self {
+        EchoServer {
+            socket: s,
+            to_send: None,
+            buf: vec![0u8; 1600],
+        }
+    }
+}
+
+impl Future for EchoServer {
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<(), io::Error> {
+        loop {
+            if let Some(&(size, peer)) = self.to_send.as_ref() {
+                try_ready!(self.socket.poll_send_to(&self.buf[..size], &peer));
+                self.to_send = None;
+            }
+            self.to_send = Some(try_ready!(self.socket.poll_recv_from(&mut self.buf)));
+        }
+    }
+}
+
+#[bench]
+fn udp_echo_latency(b: &mut Bencher) {
+    let any_addr = "127.0.0.1:0".to_string();
+    let any_addr = any_addr.parse::<SocketAddr>().unwrap();
+
+    let (stop_c, stop_p) = oneshot::channel::<()>();
+    let (tx, rx) = oneshot::channel();
+
+    let child = thread::spawn(move || {
+        let socket = tokio::net::UdpSocket::bind(&any_addr).unwrap();
+        tx.send(socket.local_addr().unwrap()).unwrap();
+
+        let server = EchoServer::new(socket);
+        let server = server.select(stop_p.map_err(|_| panic!()));
+        let server = server.map_err(|_| ());
+        server.wait().unwrap();
+    });
+
+    let client = std::net::UdpSocket::bind(&any_addr).unwrap();
+
+    let server_addr = rx.wait().unwrap();
+    let mut buf = [0u8; 1000];
+
+    // warmup phase; for some reason initial couple of
+    // runs are much slower
+    //
+    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
+    for _ in 0..8 {
+        client.send_to(&buf, &server_addr).unwrap();
+        let _ = client.recv_from(&mut buf).unwrap();
+    }
+
+    b.iter(|| {
+        client.send_to(&buf, &server_addr).unwrap();
+        let _ = client.recv_from(&mut buf).unwrap();
+    });
+
+    stop_c.send(()).unwrap();
+    child.join().unwrap();
+}
+
+#[bench]
+fn futures_channel_latency(b: &mut Bencher) {
+    let (mut in_tx, in_rx) = mpsc::channel(32);
+    let (out_tx, out_rx) = mpsc::channel::<_>(32);
+
+    let child = thread::spawn(|| out_tx.send_all(in_rx.then(|r| r.unwrap())).wait());
+    let mut rx_iter = out_rx.wait();
+
+    // warmup phase; for some reason initial couple of runs are much slower
+    //
+    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
+    for _ in 0..8 {
+        in_tx.start_send(Ok(1usize)).unwrap();
+        let _ = rx_iter.next();
+    }
+
+    b.iter(|| {
+        in_tx.start_send(Ok(1usize)).unwrap();
+        let _ = rx_iter.next();
+    });
+
+    drop(in_tx);
+    child.join().unwrap().unwrap();
+}

benches/mio-ops.rs

@@ -0,0 +1,57 @@
+// Measure cost of different operations
+// to get a sense of performance tradeoffs
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate mio;
+extern crate test;
+
+use test::Bencher;
+
+use mio::tcp::TcpListener;
+use mio::{PollOpt, Ready, Token};
+
+#[bench]
+fn mio_register_deregister(b: &mut Bencher) {
+    let addr = "127.0.0.1:0".parse().unwrap();
+    // Setup the server socket
+    let sock = TcpListener::bind(&addr).unwrap();
+    let poll = mio::Poll::new().unwrap();
+
+    const CLIENT: Token = Token(1);
+
+    b.iter(|| {
+        poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
+        poll.deregister(&sock).unwrap();
+    });
+}
+
+#[bench]
+fn mio_reregister(b: &mut Bencher) {
+    let addr = "127.0.0.1:0".parse().unwrap();
+    // Setup the server socket
+    let sock = TcpListener::bind(&addr).unwrap();
+    let poll = mio::Poll::new().unwrap();
+
+    const CLIENT: Token = Token(1);
+    poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+        .unwrap();
+
+    b.iter(|| {
+        poll.reregister(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
+    });
+    poll.deregister(&sock).unwrap();
+}
+
+#[bench]
+fn mio_poll(b: &mut Bencher) {
+    let poll = mio::Poll::new().unwrap();
+    let timeout = std::time::Duration::new(0, 0);
+    let mut events = mio::Events::with_capacity(1024);
+
+    b.iter(|| {
+        poll.poll(&mut events, Some(timeout)).unwrap();
+    });
+}

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,276 +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 tokio::sync::oneshot;
-
-use std::sync::atomic::Ordering::Relaxed;
-use std::sync::atomic::{AtomicBool, AtomicUsize};
-use std::sync::{mpsc, Arc};
-use std::time::{Duration, Instant};
-
-use criterion::{criterion_group, criterion_main, Criterion};
-
-const NUM_WORKERS: usize = 4;
-const NUM_SPAWN: usize = 10_000;
-const STALL_DUR: Duration = Duration::from_micros(10);
-
-fn rt_multi_spawn_many_local(c: &mut Criterion) {
-    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);
-
-            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(|| {
-            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();
-
-                rt.spawn(async move {
-                    for _ in 0..NUM_YIELD {
-                        tokio::task::yield_now().await;
-                    }
-
-                    tx.send(()).unwrap();
-                });
-            }
-
-            for _ in 0..TASKS {
-                rx.recv().unwrap();
-            }
-        })
-    });
-}
-
-fn rt_multi_ping_pong(c: &mut Criterion) {
-    const NUM_PINGS: usize = 1_000;
-
-    let rt = rt();
-
-    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);
-
-            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 {
-                                rx1.await.unwrap();
-                                tx2.send(()).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) {
-    const ITER: usize = 1_000;
-
-    fn iter(done_tx: mpsc::SyncSender<()>, n: usize) {
-        if n == 0 {
-            done_tx.send(()).unwrap();
-        } else {
-            tokio::spawn(async move {
-                iter(done_tx, n - 1);
-            });
-        }
-    }
-
-    c.bench_function("chained_spawn", |b| {
-        let rt = rt();
-        let (done_tx, done_rx) = mpsc::sync_channel(1000);
-
-        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();
-            });
-        })
-    });
-}
-
-fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread()
-        .worker_threads(NUM_WORKERS)
-        .enable_all()
-        .build()
-        .unwrap()
-}
-
-fn stall() {
-    let now = Instant::now();
-    while now.elapsed() < STALL_DUR {
-        std::thread::yield_now();
-    }
-}
-
-criterion_group!(
-    rt_multi_scheduler,
-    rt_multi_spawn_many_local,
-    rt_multi_spawn_many_remote_idle,
-    rt_multi_spawn_many_remote_busy1,
-    rt_multi_spawn_many_remote_busy2,
-    rt_multi_ping_pong,
-    rt_multi_yield_many,
-    rt_multi_chained_spawn,
-);
-
-criterion_main!(rt_multi_scheduler);

benches/signal.rs

@@ -1,97 +0,0 @@
-//! Benchmark the delay in propagating OS signals to any listeners.
-#![cfg(unix)]
-
-use criterion::{criterion_group, criterion_main, Criterion};
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::runtime;
-use tokio::signal::unix::{signal, SignalKind};
-use tokio::sync::mpsc;
-
-struct Spinner {
-    count: usize,
-}
-
-impl Future for Spinner {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if self.count > 3 {
-            Poll::Ready(())
-        } else {
-            self.count += 1;
-            cx.waker().wake_by_ref();
-            Poll::Pending
-        }
-    }
-}
-
-impl Spinner {
-    fn new() -> Self {
-        Self { count: 0 }
-    }
-}
-
-pub fn send_signal(signal: libc::c_int) {
-    use libc::{getpid, kill};
-
-    unsafe {
-        assert_eq!(kill(getpid(), signal), 0);
-    }
-}
-
-fn many_signals(c: &mut Criterion) {
-    let num_signals = 10;
-    let (tx, mut rx) = mpsc::channel(num_signals);
-
-    // Intentionally single threaded to measure delays in propagating wakes
-    let rt = runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap();
-
-    let spawn_signal = |kind| {
-        let tx = tx.clone();
-        rt.spawn(async move {
-            let mut signal = signal(kind).expect("failed to create signal");
-
-            while signal.recv().await.is_some() {
-                if tx.send(()).await.is_err() {
-                    break;
-                }
-            }
-        });
-    };
-
-    for _ in 0..num_signals {
-        // Pick some random signals which don't terminate the test harness
-        spawn_signal(SignalKind::child());
-        spawn_signal(SignalKind::io());
-    }
-    drop(tx);
-
-    // Turn the runtime for a while to ensure that all the spawned
-    // 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");
-                }
-
-                send_signal(libc::SIGIO);
-                for _ in 0..num_signals {
-                    rx.recv().await.expect("channel closed");
-                }
-            });
-        })
-    });
-}
-
-criterion_group!(signal_group, many_signals);
-
-criterion_main!(signal_group);

benches/spawn.rs

@@ -1,96 +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};
-
-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()
-        .build()
-        .unwrap()
-}
-
-fn multi_rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap()
-}
-
-fn basic_scheduler_spawn(c: &mut Criterion) {
-    let runtime = single_rt();
-
-    c.bench_function("basic_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
-    });
-}
-
-fn basic_scheduler_spawn10(c: &mut Criterion) {
-    let runtime = single_rt();
-
-    c.bench_function("basic_scheduler_spawn10", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let mut handles = Vec::with_capacity(10);
-                for _ in 0..10 {
-                    handles.push(tokio::spawn(work()));
-                }
-                for handle in handles {
-                    assert_eq!(handle.await.unwrap(), 2);
-                }
-            });
-        })
-    });
-}
-
-fn threaded_scheduler_spawn(c: &mut Criterion) {
-    let runtime = multi_rt();
-
-    c.bench_function("threaded_scheduler_spawn", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let h = tokio::spawn(work());
-                assert_eq!(h.await.unwrap(), 2);
-            });
-        })
-    });
-}
-
-fn threaded_scheduler_spawn10(c: &mut Criterion) {
-    let runtime = multi_rt();
-
-    c.bench_function("threaded_scheduler_spawn10", |b| {
-        b.iter(|| {
-            runtime.block_on(async {
-                let mut handles = Vec::with_capacity(10);
-                for _ in 0..10 {
-                    handles.push(tokio::spawn(work()));
-                }
-                for handle in handles {
-                    assert_eq!(handle.await.unwrap(), 2);
-                }
-            });
-        })
-    });
-}
-
-criterion_group!(
-    spawn,
-    basic_scheduler_spawn,
-    basic_scheduler_spawn10,
-    threaded_scheduler_spawn,
-    threaded_scheduler_spawn10,
-);
-
-criterion_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,331 +0,0 @@
-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])
-    }
-}
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .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 send_data<T: Default, const SIZE: usize>(g: &mut BenchmarkGroup<WallTime>, prefix: &str) {
-    let rt = rt();
-
-    g.bench_function(format!("{prefix}_{SIZE}"), |b| {
-        b.iter(|| {
-            let (tx, mut rx) = mpsc::channel::<T>(SIZE);
-
-            let _ = rt.block_on(tx.send(T::default()));
-
-            rt.block_on(rx.recv()).unwrap();
-        })
-    });
-}
-
-fn contention_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 _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
-
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_bounded_full(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded_full", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(100);
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
-
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_bounded_full_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded_full_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(100);
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).await.unwrap();
-                        }
-                    });
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_unbounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).unwrap();
-                        }
-                    });
-                }
-
-                for _ in 0..1_000 * 5 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn contention_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for _ in 0..5 {
-                    let tx = tx.clone();
-                    tokio::spawn(async move {
-                        for i in 0..1000 {
-                            tx.send(i).unwrap();
-                        }
-                    });
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_bounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-                for i in 0..5000 {
-                    tx.send(i).await.unwrap();
-                }
-
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_bounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("bounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-                for i in 0..5000 {
-                    tx.send(i).await.unwrap();
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_unbounded(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for i in 0..5000 {
-                    tx.send(i).unwrap();
-                }
-
-                for _ in 0..5_000 {
-                    let _ = rx.recv().await;
-                }
-            })
-        })
-    });
-}
-
-fn uncontented_unbounded_recv_many(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = rt();
-
-    g.bench_function("unbounded_recv_many", |b| {
-        b.iter(|| {
-            rt.block_on(async move {
-                let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-                for i in 0..5000 {
-                    tx.send(i).unwrap();
-                }
-
-                let mut buffer = Vec::<usize>::with_capacity(5_000);
-                let mut total = 0;
-                while total < 1_000 * 5 {
-                    total += rx.recv_many(&mut buffer, 5_000).await;
-                }
-            })
-        })
-    });
-}
-
-fn bench_create_medium(c: &mut Criterion) {
-    let mut group = c.benchmark_group("create_medium");
-    create_medium::<1>(&mut group);
-    create_medium::<100>(&mut group);
-    create_medium::<100_000>(&mut group);
-    group.finish();
-}
-
-fn bench_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);

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,163 +0,0 @@
-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>) {
-    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);
-                }
-            })
-        })
-    });
-}
-
-fn read_concurrent_uncontended_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        let _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();
-            })
-        })
-    });
-}
-
-fn read_concurrent_uncontended(g: &mut BenchmarkGroup<WallTime>) {
-    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);
-    }
-
-    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())
-                };
-            })
-        })
-    });
-}
-
-fn read_concurrent_contended_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        let _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();
-            })
-        })
-    });
-}
-
-fn read_concurrent_contended(g: &mut BenchmarkGroup<WallTime>) {
-    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);
-    }
-
-    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()),
-                };
-            })
-        })
-    });
-}
-
-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();
-}
-
-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);

benches/sync_semaphore.rs

@@ -1,147 +0,0 @@
-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()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
-fn uncontended(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
-
-    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);
-                }
-            })
-        })
-    });
-}
-
-async fn task(s: Arc<Semaphore>) {
-    let permit = s.acquire().await;
-    drop(permit);
-}
-
-fn uncontended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
-
-    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();
-            })
-        })
-    });
-}
-
-fn uncontended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = single_rt();
-
-    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())
-                };
-            })
-        })
-    });
-}
-
-fn contended_concurrent_multi(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = multi_rt();
-
-    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();
-            })
-        })
-    });
-}
-
-fn contended_concurrent_single(g: &mut BenchmarkGroup<WallTime>) {
-    let rt = single_rt();
-
-    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())
-                };
-            })
-        })
-    });
-}
-
-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();
-}
-
-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);

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/tcp.rs

@@ -0,0 +1,261 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate futures;
+extern crate tokio;
+
+#[macro_use]
+extern crate tokio_io;
+
+pub extern crate test;
+
+mod prelude {
+    pub use futures::*;
+    pub use tokio::net::{TcpListener, TcpStream};
+    pub use tokio::reactor::Reactor;
+    pub use tokio_io::io::read_to_end;
+
+    pub use std::io::{self, Read, Write};
+    pub use std::thread;
+    pub use std::time::Duration;
+    pub use test::{self, Bencher};
+}
+
+mod connect_churn {
+    use prelude::*;
+
+    const NUM: usize = 300;
+    const CONCURRENT: usize = 8;
+
+    #[bench]
+    fn one_thread(b: &mut Bencher) {
+        let addr = "127.0.0.1:0".parse().unwrap();
+
+        b.iter(move || {
+            let listener = TcpListener::bind(&addr).unwrap();
+            let addr = listener.local_addr().unwrap();
+
+            // Spawn a single future that accepts & drops connections
+            let serve_incomings = listener
+                .incoming()
+                .map_err(|e| panic!("server err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            let connects = stream::iter_result((0..NUM).map(|_| {
+                Ok(TcpStream::connect(&addr).and_then(|sock| {
+                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                    read_to_end(sock, vec![])
+                }))
+            }));
+
+            let connects_concurrent = connects
+                .buffer_unordered(CONCURRENT)
+                .map_err(|e| panic!("client err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            serve_incomings
+                .select(connects_concurrent)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
+        });
+    }
+
+    fn n_workers(n: usize, b: &mut Bencher) {
+        let (shutdown_tx, shutdown_rx) = sync::oneshot::channel();
+        let (addr_tx, addr_rx) = sync::oneshot::channel();
+
+        // Spawn reactor thread
+        let server_thread = thread::spawn(move || {
+            // Bind the TCP listener
+            let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
+
+            // Get the address being listened on.
+            let addr = listener.local_addr().unwrap();
+
+            // Send the remote & address back to the main thread
+            addr_tx.send(addr).unwrap();
+
+            // Spawn a single future that accepts & drops connections
+            let serve_incomings = listener
+                .incoming()
+                .map_err(|e| panic!("server err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            // Run server
+            serve_incomings
+                .select(shutdown_rx)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
+        });
+
+        // Get the bind addr of the server
+        let addr = addr_rx.wait().unwrap();
+
+        b.iter(move || {
+            use std::sync::{Arc, Barrier};
+
+            // Create a barrier to coordinate threads
+            let barrier = Arc::new(Barrier::new(n + 1));
+
+            // Spawn worker threads
+            let threads: Vec<_> = (0..n)
+                .map(|_| {
+                    let barrier = barrier.clone();
+                    let addr = addr.clone();
+
+                    thread::spawn(move || {
+                        let connects = stream::iter_result((0..(NUM / n)).map(|_| {
+                            Ok(TcpStream::connect(&addr)
+                                .map_err(|e| panic!("connect err: {:?}", e))
+                                .and_then(|sock| {
+                                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                                    read_to_end(sock, vec![])
+                                }))
+                        }));
+
+                        barrier.wait();
+
+                        connects
+                            .buffer_unordered(CONCURRENT)
+                            .map_err(|e| panic!("client err: {:?}", e))
+                            .for_each(|_| Ok(()))
+                            .wait()
+                            .unwrap();
+                    })
+                })
+                .collect();
+
+            barrier.wait();
+
+            for th in threads {
+                th.join().unwrap();
+            }
+        });
+
+        // Shutdown the server
+        shutdown_tx.send(()).unwrap();
+        server_thread.join().unwrap();
+    }
+
+    #[bench]
+    fn two_threads(b: &mut Bencher) {
+        n_workers(1, b);
+    }
+
+    #[bench]
+    fn multi_threads(b: &mut Bencher) {
+        n_workers(4, b);
+    }
+}
+
+mod transfer {
+    use prelude::*;
+    use std::{cmp, mem};
+
+    const MB: usize = 3 * 1024 * 1024;
+
+    struct Drain {
+        sock: TcpStream,
+        chunk: usize,
+    }
+
+    impl Future for Drain {
+        type Item = ();
+        type Error = io::Error;
+
+        fn poll(&mut self) -> Poll<(), io::Error> {
+            let mut buf: [u8; 1024] = unsafe { mem::uninitialized() };
+
+            loop {
+                match try_nb!(self.sock.read(&mut buf[..self.chunk])) {
+                    0 => return Ok(Async::Ready(())),
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    struct Transfer {
+        sock: TcpStream,
+        rem: usize,
+        chunk: usize,
+    }
+
+    impl Future for Transfer {
+        type Item = ();
+        type Error = io::Error;
+
+        fn poll(&mut self) -> Poll<(), io::Error> {
+            while self.rem > 0 {
+                let len = cmp::min(self.rem, self.chunk);
+                let buf = &DATA[..len];
+
+                let n = try_nb!(self.sock.write(&buf));
+                self.rem -= n;
+            }
+
+            Ok(Async::Ready(()))
+        }
+    }
+
+    static DATA: [u8; 1024] = [0; 1024];
+
+    fn one_thread(b: &mut Bencher, read_size: usize, write_size: usize) {
+        let addr = "127.0.0.1:0".parse().unwrap();
+
+        b.iter(move || {
+            let listener = TcpListener::bind(&addr).unwrap();
+            let addr = listener.local_addr().unwrap();
+
+            // Spawn a single future that accepts 1 connection, Drain it and drops
+            let server = listener
+                .incoming()
+                .into_future() // take the first connection
+                .map_err(|(e, _other_incomings)| e)
+                .map(|(connection, _other_incomings)| connection.unwrap())
+                .and_then(|sock| {
+                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                    let drain = Drain {
+                        sock: sock,
+                        chunk: read_size,
+                    };
+                    drain
+                        .map(|_| ())
+                        .map_err(|e| panic!("server error: {:?}", e))
+                })
+                .map_err(|e| panic!("server err: {:?}", e));
+
+            let client = TcpStream::connect(&addr)
+                .and_then(move |sock| Transfer {
+                    sock: sock,
+                    rem: MB,
+                    chunk: write_size,
+                })
+                .map_err(|e| panic!("client err: {:?}", e));
+
+            server.join(client).wait().unwrap();
+        });
+    }
+
+    mod small_chunks {
+        use prelude::*;
+
+        #[bench]
+        fn one_thread(b: &mut Bencher) {
+            super::one_thread(b, 32, 32);
+        }
+    }
+
+    mod big_chunks {
+        use prelude::*;
+
+        #[bench]
+        fn one_thread(b: &mut Bencher) {
+            super::one_thread(b, 1_024, 1_024);
+        }
+    }
+}

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);

ci/azure-cargo-check.yml

@@ -0,0 +1,29 @@
+parameters:
+  noDefaultFeatures: '--no-default-features'
+
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-is-release.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - ${{ each feature in crate.value }}:
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+        condition: and(succeeded(), not(variables['isRelease']))
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - ${{ each feature in crate.value }}:
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}

ci/azure-check-minrust.yml

@@ -0,0 +1,14 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Min supported Rust version
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust_version }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all
+    displayName: cargo check --all

ci/azure-cross-compile.yml

@@ -0,0 +1,27 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+
+  - script: sudo apt-get update
+    displayName: "apt-get update"
+
+  - script: sudo apt-get install gcc-multilib
+    displayName: "Install gcc-multilib"
+
+  - script: rustup target add ${{ parameters.target }}
+    displayName: "Add target"
+
+  # Always patch
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all --exclude tokio-tls --target ${{ parameters.target }}
+    displayName: Check source
+
+  - script: cargo check --tests --all --exclude tokio-tls --target ${{ parameters.target }}
+    displayName: Check tests

ci/azure-deploy-docs.yml

@@ -0,0 +1,38 @@
+parameters:
+  dependsOn: []
+
+jobs:
+- job: documentation
+  displayName: 'Deploy API Documentation'
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+  pool:
+    vmImage: 'Ubuntu 16.04'
+  dependsOn:
+    - ${{ parameters.dependsOn }}
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+  - script: |
+      cargo doc --all --no-deps
+      cp -R target/doc '$(Build.BinariesDirectory)'
+    displayName: 'Generate Documentation'
+  - script: |
+      set -e
+
+      git --version
+      ls -la
+      git init
+      git config user.name 'Deployment Bot (from Azure Pipelines)'
+      git config user.email '[email protected]'
+      git config --global credential.helper 'store --file ~/.my-credentials'
+      printf "protocol=https\nhost=github.com\nusername=carllerche\npassword=%s\n\n" "$GITHUB_TOKEN" | git credential-store --file ~/.my-credentials store
+      git remote add origin https://github.com/tokio-rs/tokio
+      git checkout -b gh-pages
+      git add .
+      git commit -m 'Deploy Tokio API documentation'
+      git push -f origin gh-pages
+    env:
+      GITHUB_TOKEN: $(githubPersonalToken)
+    workingDirectory: '$(Build.BinariesDirectory)'
+    displayName: 'Deploy Documentation'

ci/azure-install-rust.yml

@@ -0,0 +1,33 @@
+steps:
+  # Linux and macOS.
+  - script: |
+      set -e
+      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+      export PATH=$PATH:$HOME/.cargo/bin
+      rustup toolchain install $RUSTUP_TOOLCHAIN
+      rustup default $RUSTUP_TOOLCHAIN
+      echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: "Install rust (*nix)"
+    condition: not(eq(variables['Agent.OS'], 'Windows_NT'))
+
+  # Windows.
+  - script: |
+      echo "windows"
+      curl -sSf -o rustup-init.exe https://win.rustup.rs
+      rustup-init.exe -y --default-toolchain none
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustup toolchain install %RUSTUP_TOOLCHAIN%
+      rustup default %RUSTUP_TOOLCHAIN%
+      echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: Install rust (windows)
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # All platforms.
+  - script: |
+        rustc -Vv
+        cargo -V
+    displayName: Query rust and cargo versions

ci/azure-is-release.yml

@@ -0,0 +1,9 @@
+steps:
+  - bash: |
+      set -e
+
+      if git log --no-merges -1 --format='%B' | grep -qF '[ci-release]'; then
+        echo "##vso[task.setvariable variable=isRelease]true"
+      fi
+    failOnStderr: true
+    displayName: Check if release commit

ci/azure-patch-crates.yml

@@ -0,0 +1,16 @@
+steps:
+  - script: |
+      set -e
+
+      # Remove any existing patch statements
+      mv Cargo.toml Cargo.toml.bck
+      sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
+    displayName: Patch Cargo.toml

ci/azure-rustfmt.yml

@@ -0,0 +1,16 @@
+jobs:
+# Check formatting
+- job: ${{ parameters.name }}
+  displayName: Check rustfmt
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+    - template: azure-install-rust.yml
+      parameters:
+        rust_version: stable
+    - script: |
+        rustup component add rustfmt
+      displayName: Install rustfmt
+    - script: |
+        cargo fmt --all -- --check
+      displayName: Check formatting

ci/azure-test-nightly.yml

@@ -0,0 +1,19 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all
+    displayName: cargo check --all
+
+  # Check benches
+  - script: cargo check --benches --all
+    displayName: Check benchmarks

ci/azure-test-stable.yml

@@ -0,0 +1,41 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  strategy:
+    matrix:
+      Linux:
+        vmImage: ubuntu-16.04
+
+      ${{ if parameters.cross }}:
+        MacOS:
+          vmImage: macOS-10.13
+        Windows:
+          vmImage: vs2017-win2016
+  pool:
+    vmImage: $(vmImage)
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+
+  - template: azure-is-release.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - script: cargo test
+      env:
+        LOOM_MAX_DURATION: 10
+        CI: 'True'
+      displayName: cargo test -p ${{ crate }}
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}
+      condition: and(succeeded(), ne(variables['isRelease'], 'true'))
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - script: cargo test
+      env:
+        LOOM_MAX_DURATION: 10
+        CI: 'True'
+      displayName: cargo test -p ${{ crate }} (PATCHED)
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}

ci/azure-tsan.yml

@@ -0,0 +1,36 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: TSAN
+  strategy:
+    matrix:
+      Timer:
+        cmd: cargo test -p tokio-timer --test hammer
+      Threadpool:
+        cmd: cargo test -p tokio-threadpool --tests
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: nightly-2018-11-18
+
+  - template: azure-patch-crates.yml
+  - script: |
+        set -e
+
+        # Make sure the benchmarks compile
+        export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0"
+        export TSAN_OPTIONS="suppressions=`pwd`/ci/tsan"
+        export RUST_BACKTRACE=1
+
+        # Run address sanitizer
+        RUSTFLAGS="-Z sanitizer=address" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+
+        # Run thread sanitizer
+        RUSTFLAGS="-Z sanitizer=thread" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+    displayName: TSAN / MSAN
+    env:
+      TSAN: yes
+

ci/patch.toml

@@ -0,0 +1,20 @@
+# Patch dependencies to run all tests against versions of the crate in the
+# repository.
+[patch.crates-io]
+tokio = { path = "tokio" }
+tokio-buf = { path = "tokio-buf" }
+tokio-codec = { path = "tokio-codec" }
+tokio-current-thread = { path = "tokio-current-thread" }
+tokio-executor = { path = "tokio-executor" }
+tokio-fs = { path = "tokio-fs" }
+tokio-futures = { path = "tokio-futures" }
+tokio-io = { path = "tokio-io" }
+tokio-reactor = { path = "tokio-reactor" }
+tokio-signal = { path = "tokio-signal" }
+tokio-sync = { path = "tokio-sync" }
+tokio-threadpool = { path = "tokio-threadpool" }
+tokio-timer = { path = "tokio-timer" }
+tokio-tcp = { path = "tokio-tcp" }
+tokio-tls = { path = "tokio-tls" }
+tokio-udp = { path = "tokio-udp" }
+tokio-uds = { path = "tokio-uds" }

ci/tsan

@@ -0,0 +1,37 @@
+# TSAN suppressions file for Tokio
+
+# TSAN does not understand fences and `Arc::drop` is implemented using a fence.
+# This causes many false positives.
+race:Arc*drop
+race:Weak*drop
+
+# `std` mpsc is not used in any Tokio code base. This race is triggered by some
+# rust runtime logic.
+race:std*mpsc_queue
+
+# Probably more fences in std.
+race:__call_tls_dtors
+
+# The epoch-based GC uses fences.
+race:crossbeam_epoch
+
+# Push and steal operations in crossbeam-deque may cause data races, but such
+# data races are safe. If a data race happens, the value read by `steal` is
+# forgotten and the steal operation is then retried.
+race:crossbeam_deque*push
+race:crossbeam_deque*steal
+
+# This filters out expected data race in the Treiber stack implementations.
+# Treiber stacks are inherently racy. The pop operation will attempt to access
+# the "next" pointer on the node it is attempting to pop. However, at this
+# point it has not gained ownership of the node and another thread might beat
+# it and take ownership of the node first (touching the next pointer). The
+# original pop operation will fail due to the ABA guard, but tsan still picks
+# up the access on the next pointer.
+race:Backup::next_sleeper
+race:Backup::set_next_sleeper
+race:WorkerEntry::set_next_sleeper
+
+# This ignores a false positive caused by `thread::park()`/`thread::unpark()`.
+# See: https://github.com/rust-lang/rust/pull/54806#issuecomment-436193353
+race:pthread_cond_destroy

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

@@ -1,106 +0,0 @@
-[package]
-name = "examples"
-version = "0.0.0"
-publish = false
-edition = "2021"
-license = "MIT"
-
-# If you copy one of the examples into a new project, you should be using
-# [dependencies] instead, and delete the **path**.
-[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" }
-
-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"
-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"
-
-[[example]]
-name = "chat"
-path = "chat.rs"
-
-[[example]]
-name = "connect-tcp"
-path = "connect-tcp.rs"
-
-[[example]]
-name = "connect-udp"
-path = "connect-udp.rs"
-
-[[example]]
-name = "echo-tcp"
-path = "echo-tcp.rs"
-
-[[example]]
-name = "echo-udp"
-path = "echo-udp.rs"
-
-[[example]]
-name = "hello_world"
-path = "hello_world.rs"
-
-[[example]]
-name = "print_each_packet"
-path = "print_each_packet.rs"
-
-[[example]]
-name = "proxy"
-path = "proxy.rs"
-
-[[example]]
-name = "tinydb"
-path = "tinydb.rs"
-
-[[example]]
-name = "udp-client"
-path = "udp-client.rs"
-
-[[example]]
-name = "udp-codec"
-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

@@ -1,23 +0,0 @@
-## Examples of how to use Tokio
-
-This directory contains a number of examples showcasing various capabilities of
-the `tokio` crate.
-
-All examples can be executed with:
-
-```
-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
-additional guides for some of the examples.
-
-For a larger "real world" example, see the [`mini-redis`][redis] repository.
-
-If you've got an example you'd like to see here, please feel free to open an
-issue. Otherwise if you've got an example you'd like to add, please feel free
-to make a PR!
-
-[tokioweb]: https://tokio.rs/tokio/tutorial
-[redis]: https://github.com/tokio-rs/mini-redis

examples/chat.rs

@@ -1,243 +0,0 @@
-//! A chat server that broadcasts a message to all connections.
-//!
-//! This example is explicitly more verbose than it has to be. This is to
-//! illustrate more concepts.
-//!
-//! A chat server for telnet clients. After a telnet client connects, the first
-//! line should contain the client's name. After that, all lines sent by a
-//! client are broadcasted to all other connected clients.
-//!
-//! Because the client is telnet, lines are delimited by "\r\n".
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example chat
-//!
-//! And then in another terminal run:
-//!
-//!     telnet localhost 6142
-//!
-//! You can run the `telnet` command in any number of additional windows.
-//!
-//! You can run the second command in multiple windows and then chat between the
-//! two, seeing the messages from the other client as they're received. For all
-//! connected clients they'll all join the same room and see everyone else's
-//! messages.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::{mpsc, Mutex};
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
-
-use futures::SinkExt;
-use std::collections::HashMap;
-use std::env;
-use std::error::Error;
-use std::io;
-use std::net::SocketAddr;
-use std::sync::Arc;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
-    // Configure a `tracing` subscriber that logs traces emitted by the chat
-    // server.
-    tracing_subscriber::fmt()
-        // Filter what traces are displayed based on the RUST_LOG environment
-        // variable.
-        //
-        // Traces emitted by the example code will always be displayed. You
-        // can set `RUST_LOG=tokio=trace` to enable additional traces emitted by
-        // Tokio itself.
-        .with_env_filter(EnvFilter::from_default_env().add_directive("chat=info".parse()?))
-        // Log events when `tracing` spans are created, entered, exited, or
-        // closed. When Tokio's internal tracing support is enabled (as
-        // described above), this can be used to track the lifecycle of spawned
-        // tasks on the Tokio runtime.
-        .with_span_events(FmtSpan::FULL)
-        // Set this subscriber as the default, to collect all traces emitted by
-        // the program.
-        .init();
-
-    // Create the shared state. This is how all the peers communicate.
-    //
-    // The server task will hold a handle to this. For every new client, the
-    // `state` handle is cloned and passed into the task that processes the
-    // client connection.
-    let state = Arc::new(Mutex::new(Shared::new()));
-
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:6142".to_string());
-
-    // Bind a TCP listener to the socket address.
-    //
-    // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr).await?;
-
-    tracing::info!("server running on {}", addr);
-
-    loop {
-        // Asynchronously wait for an inbound TcpStream.
-        let (stream, addr) = listener.accept().await?;
-
-        // Clone a handle to the `Shared` state for the new connection.
-        let state = Arc::clone(&state);
-
-        // Spawn our handler to be run asynchronously.
-        tokio::spawn(async move {
-            tracing::debug!("accepted connection");
-            if let Err(e) = process(state, stream, addr).await {
-                tracing::info!("an error occurred; error = {:?}", e);
-            }
-        });
-    }
-}
-
-/// Shorthand for the transmit half of the message channel.
-type Tx = mpsc::UnboundedSender<String>;
-
-/// Shorthand for the receive half of the message channel.
-type Rx = mpsc::UnboundedReceiver<String>;
-
-/// Data that is shared between all peers in the chat server.
-///
-/// This is the set of `Tx` handles for all connected clients. Whenever a
-/// message is received from a client, it is broadcasted to all peers by
-/// iterating over the `peers` entries and sending a copy of the message on each
-/// `Tx`.
-struct Shared {
-    peers: HashMap<SocketAddr, Tx>,
-}
-
-/// The state for each connected client.
-struct Peer {
-    /// The TCP socket wrapped with the `Lines` codec, defined below.
-    ///
-    /// This handles sending and receiving data on the socket. When using
-    /// `Lines`, we can work at the line level instead of having to manage the
-    /// raw byte operations.
-    lines: Framed<TcpStream, LinesCodec>,
-
-    /// Receive half of the message channel.
-    ///
-    /// This is used to receive messages from peers. When a message is received
-    /// off of this `Rx`, it will be written to the socket.
-    rx: Rx,
-}
-
-impl Shared {
-    /// Create a new, empty, instance of `Shared`.
-    fn new() -> Self {
-        Shared {
-            peers: HashMap::new(),
-        }
-    }
-
-    /// Send a `LineCodec` encoded message to every peer, except
-    /// for the sender.
-    async fn broadcast(&mut self, sender: SocketAddr, message: &str) {
-        for peer in self.peers.iter_mut() {
-            if *peer.0 != sender {
-                let _ = peer.1.send(message.into());
-            }
-        }
-    }
-}
-
-impl Peer {
-    /// Create a new instance of `Peer`.
-    async fn new(
-        state: Arc<Mutex<Shared>>,
-        lines: Framed<TcpStream, LinesCodec>,
-    ) -> io::Result<Peer> {
-        // Get the client socket address
-        let addr = lines.get_ref().peer_addr()?;
-
-        // Create a channel for this peer
-        let (tx, rx) = mpsc::unbounded_channel();
-
-        // Add an entry for this `Peer` in the shared state map.
-        state.lock().await.peers.insert(addr, tx);
-
-        Ok(Peer { lines, rx })
-    }
-}
-
-/// Process an individual chat client
-async fn process(
-    state: Arc<Mutex<Shared>>,
-    stream: TcpStream,
-    addr: SocketAddr,
-) -> Result<(), Box<dyn Error>> {
-    let mut lines = Framed::new(stream, LinesCodec::new());
-
-    // Send a prompt to the client to enter their username.
-    lines.send("Please enter your username:").await?;
-
-    // Read the first line from the `LineCodec` stream to get the username.
-    let username = match lines.next().await {
-        Some(Ok(line)) => line,
-        // We didn't get a line so we return early here.
-        _ => {
-            tracing::error!("Failed to get username from {}. Client disconnected.", addr);
-            return Ok(());
-        }
-    };
-
-    // Register our peer with state which internally sets up some channels.
-    let mut peer = Peer::new(state.clone(), lines).await?;
-
-    // A client has connected, let's let everyone know.
-    {
-        let mut state = state.lock().await;
-        let msg = format!("{username} has joined the chat");
-        tracing::info!("{}", msg);
-        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() => {
-                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,
-            },
-        }
-    }
-
-    // If this section is reached it means that the client was disconnected!
-    // Let's let everyone still connected know about it.
-    {
-        let mut state = state.lock().await;
-        state.peers.remove(&addr);
-
-        let msg = format!("{username} has left the chat");
-        tracing::info!("{}", msg);
-        state.broadcast(addr, &msg).await;
-    }
-
-    Ok(())
-}

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/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-tcp.rs

@@ -1,78 +0,0 @@
-//! A "hello world" echo server with Tokio
-//!
-//! This server will create a TCP listener, accept connections in a loop, and
-//! write back everything that's read off of each TCP connection.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example echo-tcp
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect-tcp 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
-//! should be able to see them all make progress simultaneously.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
-
-use std::env;
-use std::error::Error;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Allow passing an address to listen on as the first argument of this
-    // program, but otherwise we'll just set up our TCP listener on
-    // 127.0.0.1:8080 for connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    // Next up we create a TCP listener which will listen for incoming
-    // connections. This TCP listener is bound to the address we determined
-    // above and must be associated with an event loop.
-    let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {addr}");
-
-    loop {
-        // Asynchronously wait for an inbound socket.
-        let (mut socket, _) = listener.accept().await?;
-
-        // And this is where much of the magic of this server happens. We
-        // crucially want all clients to make progress concurrently, rather than
-        // blocking one on completion of another. To achieve this we use the
-        // `tokio::spawn` function to execute the work in the background.
-        //
-        // Essentially here we're executing a new task to run concurrently,
-        // which will allow all of our clients to be processed concurrently.
-
-        tokio::spawn(async move {
-            let mut buf = vec![0; 1024];
-
-            // In a loop, read data from the socket and write the data back.
-            loop {
-                let n = socket
-                    .read(&mut buf)
-                    .await
-                    .expect("failed to read data from socket");
-
-                if n == 0 {
-                    return;
-                }
-
-                socket
-                    .write_all(&buf[0..n])
-                    .await
-                    .expect("failed to write data to socket");
-            }
-        });
-    }
-}

examples/echo-udp.rs

@@ -1,70 +0,0 @@
-//! An UDP echo server that just sends back everything that it receives.
-//!
-//! If you're on Unix you can test this out by in one terminal executing:
-//!
-//!     cargo run --example echo-udp
-//!
-//! and in another terminal you can run:
-//!
-//!     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!
-
-#![warn(rust_2018_idioms)]
-
-use std::error::Error;
-use std::net::SocketAddr;
-use std::{env, io};
-use tokio::net::UdpSocket;
-
-struct Server {
-    socket: UdpSocket,
-    buf: Vec<u8>,
-    to_send: Option<(usize, SocketAddr)>,
-}
-
-impl Server {
-    async fn run(self) -> Result<(), io::Error> {
-        let Server {
-            socket,
-            mut buf,
-            mut to_send,
-        } = self;
-
-        loop {
-            // First we check to see if there's a message we need to echo back.
-            // If so then we try to send it back to the original source, waiting
-            // until it's writable and we're able to do so.
-            if let Some((size, peer)) = to_send {
-                let amt = socket.send_to(&buf[..size], &peer).await?;
-
-                println!("Echoed {amt}/{size} bytes to {peer}");
-            }
-
-            // If we're here then `to_send` is `None`, so we take a look for the
-            // next message we're going to echo back.
-            to_send = Some(socket.recv_from(&mut buf).await?);
-        }
-    }
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    let socket = UdpSocket::bind(&addr).await?;
-    println!("Listening on: {}", socket.local_addr()?);
-
-    let server = Server {
-        socket,
-        buf: vec![0; 1024],
-        to_send: None,
-    };
-
-    // This starts the server task.
-    server.run().await?;
-
-    Ok(())
-}

examples/hello_world.rs

@@ -1,31 +0,0 @@
-//! 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:
-//!
-//!     ncat -l 6142
-//!
-//! And then in another terminal run:
-//!
-//!     cargo run --example hello_world
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-
-use std::error::Error;
-
-#[tokio::main]
-pub async fn main() -> Result<(), Box<dyn Error>> {
-    // Open a TCP stream to the socket address.
-    //
-    // Note that this is the Tokio TcpStream, which is fully async.
-    let mut stream = TcpStream::connect("127.0.0.1:6142").await?;
-    println!("created stream");
-
-    let result = stream.write_all(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

@@ -1,106 +0,0 @@
-//! A "print-each-packet" server with Tokio
-//!
-//! This server will create a TCP listener, accept connections in a loop, and
-//! put down in the stdout everything that's read off of each TCP connection.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example print\_each\_packet
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect-tcp 127.0.0.1:8080
-//!
-//! Each line you type in to the `connect-tcp` terminal should be written to terminal!
-//!
-//! Minimal js example:
-//!
-//! ```js
-//! var net = require("net");
-//!
-//! var listenPort = 8080;
-//!
-//! var server = net.createServer(function (socket) {
-//!     socket.on("data", function (bytes) {
-//!         console.log("bytes", bytes);
-//!     });
-//!
-//!     socket.on("end", function() {
-//!         console.log("Socket received FIN packet and closed connection");
-//!     });
-//!     socket.on("error", function (error) {
-//!         console.log("Socket closed with error", error);
-//!     });
-//!
-//!     socket.on("close", function (with_error) {
-//!         if (with_error) {
-//!             console.log("Socket closed with result: Err(SomeError)");
-//!         } else {
-//!             console.log("Socket closed with result: Ok(())");
-//!         }
-//!     });
-//!
-//! });
-//!
-//! server.listen(listenPort);
-//!
-//! console.log("Listening on:", listenPort);
-//! ```
-//!
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
-use tokio_util::codec::{BytesCodec, Decoder};
-
-use std::env;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Allow passing an address to listen on as the first argument of this
-    // program, but otherwise we'll just set up our TCP listener on
-    // 127.0.0.1:8080 for connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    // Next up we create a TCP listener which will listen for incoming
-    // connections. This TCP listener is bound to the address we determined
-    // above and must be associated with an event loop, so we pass in a handle
-    // 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}");
-
-    loop {
-        // Asynchronously wait for an inbound socket.
-        let (socket, _) = listener.accept().await?;
-
-        // And this is where much of the magic of this server happens. We
-        // crucially want all clients to make progress concurrently, rather than
-        // blocking one on completion of another. To achieve this we use the
-        // `tokio::spawn` function to execute the work in the background.
-        //
-        // Essentially here we're executing a new task to run concurrently,
-        // which will allow all of our clients to be processed concurrently.
-        tokio::spawn(async move {
-            // We're parsing each socket with the `BytesCodec` included in `tokio::codec`.
-            let mut framed = BytesCodec::new().framed(socket);
-
-            // We loop while there are messages coming from the Stream `framed`.
-            // 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:?}"),
-                }
-            }
-            println!("Socket received FIN packet and closed connection");
-        });
-    }
-}

examples/proxy.rs

@@ -1,61 +0,0 @@
-//! A proxy that forwards data to another server and forwards that server's
-//! responses back to clients.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! You can showcase this by running this in one terminal:
-//!
-//!     cargo run --example proxy
-//!
-//! This in another terminal
-//!
-//!     cargo run --example echo-tcp
-//!
-//! And finally this in another terminal
-//!
-//!     cargo run --example connect-tcp 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::net::{TcpListener, TcpStream};
-
-use futures::FutureExt;
-use std::env;
-use std::error::Error;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let listen_addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8081".to_string());
-    let server_addr = env::args()
-        .nth(2)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    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
-        });
-    }
-
-    Ok(())
-}

examples/tinydb.rs

@@ -1,224 +0,0 @@
-//! A "tiny database" and accompanying protocol
-//!
-//! This example shows the usage of shared state amongst all connected clients,
-//! namely a database of key/value pairs. Each connected client can send a
-//! series of GET/SET commands to query the current value of a key or set the
-//! value of a key.
-//!
-//! This example has a simple protocol you can use to interact with the server.
-//! To run, first run this in one terminal window:
-//!
-//!     cargo run --example tinydb
-//!
-//! and next in another windows run:
-//!
-//!     cargo run --example connect-tcp 127.0.0.1:8080
-//!
-//! In the `connect-tcp` 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
-//!     GET foo
-//!     foo = bar
-//!     GET FOOBAR
-//!     error: no key FOOBAR
-//!     SET FOOBAR my awesome string
-//!     set FOOBAR = `my awesome string`, previous: None
-//!     SET foo tokio
-//!     set foo = `tokio`, previous: Some("bar")
-//!     GET foo
-//!     foo = tokio
-//!
-//! Namely you can issue two forms of commands:
-//!
-//! * `GET $key` - this will fetch the value of `$key` from the database and
-//!   return it. The server's database is initially populated with the key `foo`
-//!   set to the value `bar`
-//! * `SET $key $value` - this will set the value of `$key` to `$value`,
-//!   returning the previous value, if any.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
-
-use futures::SinkExt;
-use std::collections::HashMap;
-use std::env;
-use std::error::Error;
-use std::sync::{Arc, Mutex};
-
-/// The in-memory database shared amongst all clients.
-///
-/// This database will be shared via `Arc`, so to mutate the internal map we're
-/// going to use a `Mutex` for interior mutability.
-struct Database {
-    map: Mutex<HashMap<String, String>>,
-}
-
-/// Possible requests our clients can send us
-enum Request {
-    Get { key: String },
-    Set { key: String, value: String },
-}
-
-/// Responses to the `Request` commands above
-enum Response {
-    Value {
-        key: String,
-        value: String,
-    },
-    Set {
-        key: String,
-        value: String,
-        previous: Option<String>,
-    },
-    Error {
-        msg: String,
-    },
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Parse the address we're going to run this server on
-    // and set up our TCP listener to accept connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    let listener = TcpListener::bind(&addr).await?;
-    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`
-    // structure. Note the usage of `Arc` here which will be used to ensure that
-    // each independently spawned client will have a reference to the in-memory
-    // database.
-    let mut initial_db = HashMap::new();
-    initial_db.insert("foo".to_string(), "bar".to_string());
-    let db = Arc::new(Database {
-        map: Mutex::new(initial_db),
-    });
-
-    loop {
-        match listener.accept().await {
-            Ok((socket, _)) => {
-                // After getting a new connection first we see a clone of the database
-                // being created, which is creating a new reference for this connected
-                // client to use.
-                let db = db.clone();
-
-                // Like with other small servers, we'll `spawn` this client to ensure it
-                // runs concurrently with all other clients. The `move` keyword is used
-                // here to move ownership of our db handle into the async closure.
-                tokio::spawn(async move {
-                    // Since our protocol is line-based we use `tokio_codecs`'s `LineCodec`
-                    // to convert our stream of bytes, `socket`, into a `Stream` of lines
-                    // as well as convert our line based responses into a stream of bytes.
-                    let mut lines = Framed::new(socket, LinesCodec::new());
-
-                    // Here for every line we get back from the `Framed` decoder,
-                    // we parse the request, and if it's valid we generate a response
-                    // based on the values in the database.
-                    while let Some(result) = lines.next().await {
-                        match result {
-                            Ok(line) => {
-                                let response = handle_request(&line, &db);
-
-                                let response = response.serialize();
-
-                                if let Err(e) = lines.send(response.as_str()).await {
-                                    println!("error on sending response; error = {e:?}");
-                                }
-                            }
-                            Err(e) => {
-                                println!("error on decoding from socket; error = {e:?}");
-                            }
-                        }
-                    }
-
-                    // The connection will be closed at this point as `lines.next()` has returned `None`.
-                });
-            }
-            Err(e) => println!("error accepting socket; error = {e:?}"),
-        }
-    }
-}
-
-fn handle_request(line: &str, db: &Arc<Database>) -> Response {
-    let request = match Request::parse(line) {
-        Ok(req) => req,
-        Err(e) => return Response::Error { msg: e },
-    };
-
-    let mut db = db.map.lock().unwrap();
-    match request {
-        Request::Get { key } => match db.get(&key) {
-            Some(value) => Response::Value {
-                key,
-                value: value.clone(),
-            },
-            None => Response::Error {
-                msg: format!("no key {key}"),
-            },
-        },
-        Request::Set { key, value } => {
-            let previous = db.insert(key.clone(), value.clone());
-            Response::Set {
-                key,
-                value,
-                previous,
-            }
-        }
-    }
-}
-
-impl Request {
-    fn parse(input: &str) -> Result<Request, String> {
-        let mut parts = input.splitn(3, ' ');
-        match parts.next() {
-            Some("GET") => {
-                let key = parts.next().ok_or("GET must be followed by a key")?;
-                if parts.next().is_some() {
-                    return Err("GET's key must not be followed by anything".into());
-                }
-                Ok(Request::Get {
-                    key: key.to_string(),
-                })
-            }
-            Some("SET") => {
-                let key = match parts.next() {
-                    Some(key) => key,
-                    None => return Err("SET must be followed by a key".into()),
-                };
-                let value = match parts.next() {
-                    Some(value) => value,
-                    None => return Err("SET needs a value".into()),
-                };
-                Ok(Request::Set {
-                    key: key.to_string(),
-                    value: value.to_string(),
-                })
-            }
-            Some(cmd) => Err(format!("unknown command: {cmd}")),
-            None => Err("empty input".into()),
-        }
-    }
-}
-
-impl Response {
-    fn serialize(&self) -> String {
-        match *self {
-            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}"),
-        }
-    }
-}

examples/udp-codec.rs

@@ -1,80 +0,0 @@
-//! This example leverages `BytesCodec` to create a UDP client and server which
-//! speak a custom protocol.
-//!
-//! Here we're using the codec from `tokio-codec` to convert a UDP socket to a stream of
-//! client messages. These messages are then processed and returned back as a
-//! new message with a new destination. Overall, we then use this to construct a
-//! "ping pong" pair where two sockets are sending messages back and forth.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::UdpSocket;
-use tokio::{io, time};
-use tokio_stream::StreamExt;
-use tokio_util::codec::BytesCodec;
-use tokio_util::udp::UdpFramed;
-
-use bytes::Bytes;
-use futures::{FutureExt, SinkExt};
-use std::env;
-use std::error::Error;
-use std::net::SocketAddr;
-use std::time::Duration;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:0".to_string());
-
-    // Bind both our sockets and then figure out what ports we got.
-    let a = UdpSocket::bind(&addr).await?;
-    let b = UdpSocket::bind(&addr).await?;
-
-    let b_addr = b.local_addr()?;
-
-    let mut a = UdpFramed::new(a, BytesCodec::new());
-    let mut b = UdpFramed::new(b, BytesCodec::new());
-
-    // Start off by sending a ping from a to b, afterwards we just print out
-    // what they send us and continually send pings
-    let a = ping(&mut a, b_addr);
-
-    // The second client we have will receive the pings from `a` and then send
-    // back pongs.
-    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:?}"),
-        _ => println!("done!"),
-    }
-
-    Ok(())
-}
-
-async fn ping(socket: &mut UdpFramed<BytesCodec>, b_addr: SocketAddr) -> Result<(), io::Error> {
-    socket.send((Bytes::from(&b"PING"[..]), b_addr)).await?;
-
-    for _ in 0..4usize {
-        let (bytes, addr) = socket.next().map(|e| e.unwrap()).await?;
-
-        println!("[a] recv: {}", String::from_utf8_lossy(&bytes));
-
-        socket.send((Bytes::from(&b"PING"[..]), addr)).await?;
-    }
-
-    Ok(())
-}
-
-async fn pong(socket: &mut UdpFramed<BytesCodec>) -> Result<(), io::Error> {
-    let timeout = Duration::from_millis(200);
-
-    while let Ok(Some(Ok((bytes, addr)))) = time::timeout(timeout, socket.next()).await {
-        println!("[b] recv: {}", String::from_utf8_lossy(&bytes));
-
-        socket.send((Bytes::from(&b"PONG"[..]), addr)).await?;
-    }
-
-    Ok(())
-}

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

@@ -1,18 +0,0 @@
-[package]
-name = "stress-test"
-version = "0.1.0"
-authors = ["Tokio Contributors <[email protected]>"]
-edition = "2021"
-license = "MIT"
-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"] }
-
-[dev-dependencies]
-rand = "0.9"
-
-[lints]
-workspace = true

stress-test/examples/simple_echo_tcp.rs

@@ -1,58 +0,0 @@
-//! Simple TCP echo server to check memory leaks using Valgrind.
-use std::{thread::sleep, time::Duration};
-
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::{TcpListener, TcpSocket},
-    runtime::Builder,
-    sync::oneshot,
-};
-
-const TCP_ENDPOINT: &str = "127.0.0.1:8080";
-const NUM_MSGS: usize = 100;
-const MSG_SIZE: usize = 1024;
-
-fn main() {
-    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
-    let rt2 = Builder::new_multi_thread().enable_io().build().unwrap();
-
-    rt.spawn(async {
-        let listener = TcpListener::bind(TCP_ENDPOINT).await.unwrap();
-        let (mut socket, _) = listener.accept().await.unwrap();
-        let (mut rd, mut wr) = socket.split();
-        while tokio::io::copy(&mut rd, &mut wr).await.is_ok() {}
-    });
-
-    // wait a bit so that the listener binds.
-    sleep(Duration::from_millis(100));
-
-    // create a channel to let the main thread know that all the messages were sent and received.
-    let (tx, mut rx) = oneshot::channel();
-
-    rt2.spawn(async {
-        let addr = TCP_ENDPOINT.parse().unwrap();
-        let socket = TcpSocket::new_v4().unwrap();
-        let mut stream = socket.connect(addr).await.unwrap();
-
-        let mut buff = [0; MSG_SIZE];
-        for _ in 0..NUM_MSGS {
-            let one_mega_random_bytes: Vec<u8> =
-                (0..MSG_SIZE).map(|_| rand::random::<u8>()).collect();
-            stream
-                .write_all(one_mega_random_bytes.as_slice())
-                .await
-                .unwrap();
-            let _ = stream.read(&mut buff).await.unwrap();
-        }
-        tx.send(()).unwrap();
-    });
-
-    loop {
-        // check that we're done.
-        match rx.try_recv() {
-            Err(oneshot::error::TryRecvError::Empty) => (),
-            Err(oneshot::error::TryRecvError::Closed) => panic!("channel got closed..."),
-            Ok(()) => break,
-        }
-    }
-}

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

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

tests-build/README.md

@@ -1,10 +0,0 @@
-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/src/lib.rs

@@ -1,2 +0,0 @@
-#[cfg(feature = "tokio")]
-pub use tokio;

tests-build/tests/fail/macros_core_no_default.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn my_fn() {}
-
-fn main() {}

tests-build/tests/fail/macros_core_no_default.stderr

@@ -1,7 +0,0 @@
-error: The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled.
- --> $DIR/macros_core_no_default.rs:3:1
-  |
-3 | #[tokio::main]
-  | ^^^^^^^^^^^^^^
-  |
-  = note: this error originates in the attribute macro `tokio::main` (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,71 +0,0 @@
-#![deny(duplicate_macro_attributes)]
-
-use tests_build::tokio;
-
-#[tokio::main]
-fn main_is_not_async() {}
-
-#[tokio::main(foo)]
-async fn main_attr_has_unknown_args() {}
-
-#[tokio::main(threadpool::bar)]
-async fn main_attr_has_path_args() {}
-
-#[tokio::test]
-fn test_is_not_async() {}
-
-#[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() {}