mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-27 00:00:12 +02:00
Sean McArthur
a0557840eb
This refactors I/O registration in a few ways: - Cleans up the cached readiness in `PollEvented`. This cache used to be helpful when readiness was a linked list of `*mut Node`s in `Registration`. Previous refactors have turned `Registration` into just an `AtomicUsize` holding the current readiness, so the cache is just extra work and complexity. Gone. - Polling the `Registration` for readiness now gives a `ReadyEvent`, which includes the driver tick. This event must be passed back into `clear_readiness`, so that the readiness is only cleared from `Registration` if the tick hasn't changed. Previously, it was possible to clear the readiness even though another thread had *just* polled the driver and found the socket ready again. - Registration now also contains an `async fn readiness`, which stores wakers in an instrusive linked list. This allows an unbounded number of tasks to register for readiness (previously, only 1 per direction (read and write)). By using the intrusive linked list, there is no concern of leaking the storage of the wakers, since they are stored inside the `async fn` and released when the future is dropped. - Registration retains a `poll_readiness(Direction)` method, to support `AsyncRead` and `AsyncWrite`. They aren't able to use `async fn`s, and so there are 2 reserved slots for those methods. - IO types where it makes sense to have multiple tasks waiting on them now take advantage of this new `async fn readiness`, such as `UdpSocket` and `UnixDatagram`. Additionally, this makes the `io-driver` "feature" internal-only (no longer documented, not part of public API), and adds a second internal-only feature, `io-readiness`, to group together linked list part of registration that is only used by some of the IO types. After a bit of discussion, changing stream-based transports (like `TcpStream`) to have `async fn read(&self)` is punted, since that is likely too easy of a footgun to activate. Refs: #2779, #2728
105 lines
3.0 KiB
Rust
105 lines
3.0 KiB
Rust
#![warn(rust_2018_idioms)]
|
|
#![cfg(feature = "full")]
|
|
|
|
use std::sync::Arc;
|
|
use tokio::net::UdpSocket;
|
|
|
|
const MSG: &[u8] = b"hello";
|
|
const MSG_LEN: usize = MSG.len();
|
|
|
|
#[tokio::test]
|
|
async fn send_recv() -> std::io::Result<()> {
|
|
let sender = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let receiver = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
sender.connect(receiver.local_addr()?).await?;
|
|
receiver.connect(sender.local_addr()?).await?;
|
|
|
|
sender.send(MSG).await?;
|
|
|
|
let mut recv_buf = [0u8; 32];
|
|
let len = receiver.recv(&mut recv_buf[..]).await?;
|
|
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_to_recv_from() -> std::io::Result<()> {
|
|
let sender = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let receiver = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
|
let receiver_addr = receiver.local_addr()?;
|
|
sender.send_to(MSG, &receiver_addr).await?;
|
|
|
|
let mut recv_buf = [0u8; 32];
|
|
let (len, addr) = receiver.recv_from(&mut recv_buf[..]).await?;
|
|
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
assert_eq!(addr, sender.local_addr()?);
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn split() -> std::io::Result<()> {
|
|
let socket = UdpSocket::bind("127.0.0.1:0").await?;
|
|
let s = Arc::new(socket);
|
|
let r = s.clone();
|
|
|
|
let addr = s.local_addr()?;
|
|
tokio::spawn(async move {
|
|
s.send_to(MSG, &addr).await.unwrap();
|
|
});
|
|
let mut recv_buf = [0u8; 32];
|
|
let (len, _) = r.recv_from(&mut recv_buf[..]).await?;
|
|
assert_eq!(&recv_buf[..len], MSG);
|
|
Ok(())
|
|
}
|
|
|
|
// # Note
|
|
//
|
|
// This test is purposely written such that each time `sender` sends data on
|
|
// the socket, `receiver` awaits the data. On Unix, it would be okay waiting
|
|
// until the end of the test to receive all the data. On Windows, this would
|
|
// **not** be okay because it's resources are completion based (via IOCP).
|
|
// If data is sent and not yet received, attempting to send more data will
|
|
// result in `ErrorKind::WouldBlock` until the first operation completes.
|
|
#[tokio::test]
|
|
async fn try_send_spawn() {
|
|
const MSG2: &[u8] = b"world!";
|
|
const MSG2_LEN: usize = MSG2.len();
|
|
|
|
let sender = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
let receiver = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
|
|
receiver
|
|
.connect(sender.local_addr().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let sent = &sender
|
|
.try_send_to(MSG, receiver.local_addr().unwrap())
|
|
.unwrap();
|
|
assert_eq!(sent, &MSG_LEN);
|
|
let mut buf = [0u8; 32];
|
|
let mut received = receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
sender
|
|
.connect(receiver.local_addr().unwrap())
|
|
.await
|
|
.unwrap();
|
|
let sent = &sender.try_send(MSG2).unwrap();
|
|
assert_eq!(sent, &MSG2_LEN);
|
|
received += receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
std::thread::spawn(move || {
|
|
let sent = &sender.try_send(MSG).unwrap();
|
|
assert_eq!(sent, &MSG_LEN);
|
|
})
|
|
.join()
|
|
.unwrap();
|
|
received += receiver.recv(&mut buf[..]).await.unwrap();
|
|
|
|
assert_eq!(received, MSG_LEN * 2 + MSG2_LEN);
|
|
}
|