repo
stringclasses
7 values
lang
stringclasses
2 values
aspect
stringclasses
7 values
file
stringlengths
5
48
content
stringlengths
283
144k
tokio
rust
async_runtime
sync_wrapper.rs
use std::any::Any; pub(crate) struct SyncWrapper<T> { value: T, } // safety: The SyncWrapper being send allows you to send the inner value across // thread boundaries. unsafe impl<T: Send> Send for SyncWrapper<T> {} // safety: An immutable reference to a SyncWrapper is useless, so moving such an // immutable ref...
tokio
rust
async_runtime
rt.rs
use super::{FastRand, RngSeed}; use std::collections::hash_map::DefaultHasher; use std::hash::Hasher; use std::sync::Mutex; impl RngSeed { /// Generates a seed from the provided byte slice. /// /// # Example /// /// ``` /// # #[cfg(tokio_unstable)] /// # { /// # use tokio::runtime::Rng...
tokio
rust
async_runtime
async_fd.rs
use crate::io::{Interest, Ready}; use crate::runtime::io::{ReadyEvent, Registration}; use crate::runtime::scheduler; use mio::unix::SourceFd; use std::error::Error; use std::fmt; use std::io; use std::os::unix::io::{AsRawFd, RawFd}; use std::task::{ready, Context, Poll}; /// Associates an IO object backed by a Unix f...
tokio
rust
async_runtime
join.rs
use crate::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf}; use std::io; use std::pin::Pin; use std::task::{Context, Poll}; /// Join two values implementing `AsyncRead` and `AsyncWrite` into a /// single handle. pub fn join<R, W>(reader: R, writer: W) -> Join<R, W> where R: AsyncRead, W: AsyncWrite, { ...
tokio
rust
async_runtime
interest.rs
#![cfg_attr(not(feature = "net"), allow(dead_code, unreachable_pub))] use crate::io::ready::Ready; use std::fmt; use std::ops; // These must be unique. // same as mio const READABLE: usize = 0b0001; const WRITABLE: usize = 0b0010; // The following are not available on all platforms. #[cfg(target_os = "freebsd")] con...
tokio
rust
async_runtime
stderr.rs
use crate::io::blocking::Blocking; use crate::io::stdio_common::SplitByUtf8BoundaryIfWindows; use crate::io::AsyncWrite; use std::io; use std::pin::Pin; use std::task::Context; use std::task::Poll; cfg_io_std! { /// A handle to the standard error stream of a process. /// /// Concurrent writes to stderr mu...
tokio
rust
async_runtime
mod.rs
#![cfg_attr( not(all(feature = "rt", feature = "net")), allow(dead_code, unused_imports) )] cfg_io_blocking! { pub(crate) mod blocking; } mod async_buf_read; pub use self::async_buf_read::AsyncBufRead; mod async_read; pub use self::async_read::AsyncRead; mod async_seek; pub use self::async_seek::AsyncSe...
tokio
rust
async_runtime
stdin.rs
use crate::io::blocking::Blocking; use crate::io::{AsyncRead, ReadBuf}; use std::io; use std::pin::Pin; use std::task::Context; use std::task::Poll; cfg_io_std! { /// A handle to the standard input stream of a process. /// /// The handle implements the [`AsyncRead`] trait, but beware that concurrent /...
tokio
rust
async_runtime
seek.rs
use crate::io::AsyncSeek; use pin_project_lite::pin_project; use std::future::Future; use std::io::{self, SeekFrom}; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Future for the [`seek`](crate::io::AsyncSeekExt::seek) method. #[derive(Debug)] ...
tokio
rust
async_runtime
poll_evented.rs
use crate::io::interest::Interest; use crate::runtime::io::Registration; use crate::runtime::scheduler; use mio::event::Source; use std::fmt; use std::io; use std::ops::Deref; use std::panic::{RefUnwindSafe, UnwindSafe}; use std::task::ready; cfg_io_driver! { /// Associates an I/O resource that implements the [`s...
tokio
rust
async_runtime
async_seek.rs
use std::io::{self, SeekFrom}; use std::ops::DerefMut; use std::pin::Pin; use std::task::{Context, Poll}; /// Seek bytes asynchronously. /// /// This trait is analogous to the [`std::io::Seek`] trait, but integrates /// with the asynchronous task system. In particular, the `start_seek` /// method, unlike [`Seek::seek`...
tokio
rust
async_runtime
stdio_common.rs
use crate::io::AsyncWrite; use std::pin::Pin; use std::task::{Context, Poll}; /// # Windows /// [`AsyncWrite`] adapter that finds last char boundary in given buffer and does not write the rest, /// if buffer contents seems to be `utf8`. Otherwise it only trims buffer down to `DEFAULT_MAX_BUF_SIZE`. /// That's why, wrap...
tokio
rust
async_runtime
async_buf_read.rs
use crate::io::AsyncRead; use std::io; use std::ops::DerefMut; use std::pin::Pin; use std::task::{Context, Poll}; /// Reads bytes asynchronously. /// /// This trait is analogous to [`std::io::BufRead`], but integrates with /// the asynchronous task system. In particular, the [`poll_fill_buf`] method, /// unlike [`Buf...
tokio
rust
async_runtime
blocking.rs
use crate::io::sys; use crate::io::{AsyncRead, AsyncWrite, ReadBuf}; use std::cmp; use std::future::Future; use std::io; use std::io::prelude::*; use std::mem::MaybeUninit; use std::pin::Pin; use std::task::{ready, Context, Poll}; /// `T` should not implement _both_ Read and Write. #[derive(Debug)] pub(crate) struct ...
tokio
rust
async_runtime
async_read.rs
use super::ReadBuf; use std::io; use std::ops::DerefMut; use std::pin::Pin; use std::task::{Context, Poll}; /// Reads bytes from a source. /// /// This trait is analogous to the [`std::io::Read`] trait, but integrates with /// the asynchronous task system. In particular, the [`poll_read`] method, /// unlike [`Read::re...
tokio
rust
async_runtime
read_buf.rs
use std::fmt; use std::mem::MaybeUninit; /// A wrapper around a byte buffer that is incrementally filled and initialized. /// /// This type is a sort of "double cursor". It tracks three regions in the /// buffer: a region at the beginning of the buffer that has been logically /// filled with data, a region that has be...
tokio
rust
async_runtime
stdout.rs
use crate::io::blocking::Blocking; use crate::io::stdio_common::SplitByUtf8BoundaryIfWindows; use crate::io::AsyncWrite; use std::io; use std::pin::Pin; use std::task::Context; use std::task::Poll; cfg_io_std! { /// A handle to the standard output stream of a process. /// /// Concurrent writes to stdout mu...
tokio
rust
async_runtime
ready.rs
#![cfg_attr(not(feature = "net"), allow(unreachable_pub))] use crate::io::interest::Interest; use std::fmt; use std::ops; const READABLE: usize = 0b0_01; const WRITABLE: usize = 0b0_10; const READ_CLOSED: usize = 0b0_0100; const WRITE_CLOSED: usize = 0b0_1000; #[cfg(any(target_os = "linux", target_os = "android"))] ...
tokio
rust
async_runtime
split.rs
use crate::io::{AsyncRead, AsyncWrite, ReadBuf}; use std::fmt; use std::io; use std::pin::Pin; use std::sync::Arc; use std::sync::Mutex; use std::task::{Context, Poll}; cfg_io_util! { /// The readable half of a value returned from [`split`](split()). pub struct ReadHalf<T> { inner: Arc<Inner<T>>, ...
tokio
rust
async_runtime
async_write.rs
use std::io::{self, IoSlice}; use std::ops::DerefMut; use std::pin::Pin; use std::task::{Context, Poll}; /// Writes bytes asynchronously. /// /// This trait is analogous to the [`std::io::Write`] trait, but integrates with /// the asynchronous task system. In particular, the [`poll_write`] method, /// unlike [`Write::...
tokio
rust
async_runtime
copy.rs
use crate::io::{AsyncRead, AsyncWrite, ReadBuf}; use std::future::Future; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; #[derive(Debug)] pub(super) struct CopyBuffer { read_done: bool, need_flush: bool, pos: usize, cap: usize, amt: u64, buf: Box<[u8]>, } impl CopyBuff...
tokio
rust
async_runtime
shutdown.rs
use crate::io::AsyncWrite; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// A future used to shutdown an I/O object. /// /// Created by the [`AsyncWriteExt::shutdown`][shutdown] fu...
tokio
rust
async_runtime
read_int.rs
use crate::io::{AsyncRead, ReadBuf}; use bytes::Buf; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::io::ErrorKind::UnexpectedEof; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; macro_rules! reader { ($name:ident, $ty:ty, $reader:ident) => { ...
tokio
rust
async_runtime
read_to_end.rs
use crate::io::util::vec_with_initialized::{into_read_buf_parts, VecU8, VecWithInitialized}; use crate::io::{AsyncRead, ReadBuf}; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::mem::{self, MaybeUninit}; use std::pin::Pin; use std::task::{ready, Context...
tokio
rust
async_runtime
write_all.rs
use crate::io::AsyncWrite; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::mem; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { #[derive(Debug)] #[must_use = "futures do nothing unless you `.await` or poll them"] pu...
tokio
rust
async_runtime
chain.rs
use crate::io::{AsyncBufRead, AsyncRead, ReadBuf}; use pin_project_lite::pin_project; use std::fmt; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Stream for the [`chain`](super::AsyncReadExt::chain) method. #[must_use = "streams do nothing unless polled"] #[cfg_...
tokio
rust
async_runtime
write_vectored.rs
use crate::io::AsyncWrite; use pin_project_lite::pin_project; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; use std::{future::Future, io::IoSlice}; pin_project! { /// A future to write a slice of buffers to an `AsyncWrite`. #[derive(Debug)] #[must_use = "f...
tokio
rust
async_runtime
empty.rs
use crate::io::util::poll_proceed_and_make_progress; use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf}; use std::fmt; use std::io::{self, SeekFrom}; use std::pin::Pin; use std::task::{ready, Context, Poll}; cfg_io_util! { /// `Empty` ignores any data written via [`AsyncWrite`], and will alw...
tokio
rust
async_runtime
async_write_ext.rs
use crate::io::util::flush::{flush, Flush}; use crate::io::util::shutdown::{shutdown, Shutdown}; use crate::io::util::write::{write, Write}; use crate::io::util::write_all::{write_all, WriteAll}; use crate::io::util::write_all_buf::{write_all_buf, WriteAllBuf}; use crate::io::util::write_buf::{write_buf, WriteBuf}; use...
tokio
rust
async_runtime
buf_stream.rs
use crate::io::util::{BufReader, BufWriter}; use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf}; use pin_project_lite::pin_project; use std::io::{self, IoSlice, SeekFrom}; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// Wraps a type that is [`AsyncWrite`] and [`AsyncRea...
tokio
rust
async_runtime
sink.rs
use crate::io::util::poll_proceed_and_make_progress; use crate::io::AsyncWrite; use std::fmt; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; cfg_io_util! { /// An async writer which will move data into the void. /// /// This struct is generally created by calling [`sink`][sink]. Pl...
tokio
rust
async_runtime
async_read_ext.rs
use crate::io::util::chain::{chain, Chain}; use crate::io::util::read::{read, Read}; use crate::io::util::read_buf::{read_buf, ReadBuf}; use crate::io::util::read_exact::{read_exact, ReadExact}; use crate::io::util::read_int::{ReadF32, ReadF32Le, ReadF64, ReadF64Le}; use crate::io::util::read_int::{ ReadI128, ReadI...
tokio
rust
async_runtime
write.rs
use crate::io::AsyncWrite; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// A future to write some of the buffer to an `AsyncWrite`. #[derive(Debug)] #[must_use = "futures do nothi...
tokio
rust
async_runtime
copy_buf.rs
use crate::io::{AsyncBufRead, AsyncWrite}; use std::future::Future; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; cfg_io_util! { /// A future that asynchronously copies the entire contents of a reader into a /// writer. /// /// This struct is generally created by calling [`copy...
tokio
rust
async_runtime
fill_buf.rs
use crate::io::AsyncBufRead; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// Future for the [`fill_buf`](crate::io::AsyncBufReadExt::fill_buf) method. #[derive(Debug)] #[must_use ...
tokio
rust
async_runtime
copy_bidirectional.rs
use super::copy::CopyBuffer; use crate::io::{AsyncRead, AsyncWrite}; use std::future::poll_fn; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; enum TransferState { Running(CopyBuffer), ShuttingDown(u64), Done(u64), } fn transfer_one_direction<A, B>( cx: &mut Context<'_>, s...
tokio
rust
async_runtime
read_line.rs
use crate::io::util::read_until::read_until_internal; use crate::io::AsyncBufRead; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::mem; use std::pin::Pin; use std::str; use std::string::FromUtf8Error; use std::task::{ready, Context, Poll}; pin_project!...
tokio
rust
async_runtime
async_seek_ext.rs
use crate::io::seek::{seek, Seek}; use crate::io::AsyncSeek; use std::io::SeekFrom; cfg_io_util! { /// An extension trait that adds utility methods to [`AsyncSeek`] types. /// /// # Examples /// /// ``` /// use std::io::{self, Cursor, SeekFrom}; /// use tokio::io::{AsyncSeekExt, AsyncReadEx...
tokio
rust
async_runtime
write_buf.rs
use crate::io::AsyncWrite; use bytes::Buf; use pin_project_lite::pin_project; use std::future::Future; use std::io::{self, IoSlice}; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// A future to write some of the buffer to an `AsyncWrite`. #[derive(De...
tokio
rust
async_runtime
write_all_buf.rs
use crate::io::AsyncWrite; use bytes::Buf; use pin_project_lite::pin_project; use std::future::Future; use std::io::{self, IoSlice}; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// A future to write some of the buffer to an `AsyncWrite`. #[derive(De...
tokio
rust
async_runtime
buf_writer.rs
use crate::io::util::DEFAULT_BUF_SIZE; use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf}; use pin_project_lite::pin_project; use std::fmt; use std::io::{self, IoSlice, SeekFrom, Write}; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Wraps a writer and buffers i...
tokio
rust
async_runtime
mod.rs
#![allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411 cfg_io_util! { mod async_buf_read_ext; pub use async_buf_read_ext::AsyncBufReadExt; mod async_read_ext; pub use async_read_ext::AsyncReadExt; mod async_seek_ext; pub use async_seek_ext::AsyncSeekExt; mod async_w...
tokio
rust
async_runtime
read_to_string.rs
use crate::io::util::read_line::finish_string_read; use crate::io::util::read_to_end::read_to_end_internal; use crate::io::util::vec_with_initialized::VecWithInitialized; use crate::io::AsyncRead; use pin_project_lite::pin_project; use std::future::Future; use std::marker::PhantomPinned; use std::pin::Pin; use std::ta...
tokio
rust
async_runtime
read.rs
use crate::io::{AsyncRead, ReadBuf}; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::marker::Unpin; use std::pin::Pin; use std::task::{ready, Context, Poll}; /// Tries to read some bytes directly into the given `buf` in asynchronous /// manner, returni...
tokio
rust
async_runtime
read_exact.rs
use crate::io::{AsyncRead, ReadBuf}; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::marker::Unpin; use std::pin::Pin; use std::task::{ready, Context, Poll}; /// A future which can be used to easily read exactly enough bytes to fill /// a buffer. /// /...
tokio
rust
async_runtime
read_until.rs
use crate::io::AsyncBufRead; use crate::util::memchr; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::mem; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Future for the [`read_until`](crate::io::AsyncBufReadExt::read_u...
tokio
rust
async_runtime
buf_reader.rs
use crate::io::util::DEFAULT_BUF_SIZE; use crate::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, ReadBuf}; use pin_project_lite::pin_project; use std::io::{self, IoSlice, SeekFrom}; use std::pin::Pin; use std::task::{ready, Context, Poll}; use std::{cmp, fmt, mem}; pin_project! { /// The `BufReader` struct ...
tokio
rust
async_runtime
write_int.rs
use crate::io::AsyncWrite; use bytes::BufMut; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; macro_rules! writer { ($name:ident, $ty:ty, $writer:ident) => { writer!($name, $ty, $writer, std::mem::s...
tokio
rust
async_runtime
take.rs
use crate::io::{AsyncBufRead, AsyncRead, ReadBuf}; use pin_project_lite::pin_project; use std::convert::TryFrom; use std::pin::Pin; use std::task::{ready, Context, Poll}; use std::{cmp, io}; pin_project! { /// Stream for the [`take`](super::AsyncReadExt::take) method. #[derive(Debug)] #[must_use = "stream...
tokio
rust
async_runtime
read_buf.rs
use crate::io::AsyncRead; use bytes::BufMut; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{ready, Context, Poll}; pub(crate) fn read_buf<'a, R, B>(reader: &'a mut R, buf: &'a mut B) -> ReadBuf<'a, R, B> where R: AsyncRea...
tokio
rust
async_runtime
vec_with_initialized.rs
use crate::io::ReadBuf; use std::mem::MaybeUninit; /// Something that looks like a `Vec<u8>`. /// /// # Safety /// /// The implementer must guarantee that the vector returned by the /// `as_mut` and `as_mut` methods do not change from one call to /// another. pub(crate) unsafe trait VecU8: AsRef<Vec<u8>> + AsMut<Vec<u...
tokio
rust
async_runtime
async_buf_read_ext.rs
use crate::io::util::fill_buf::{fill_buf, FillBuf}; use crate::io::util::lines::{lines, Lines}; use crate::io::util::read_line::{read_line, ReadLine}; use crate::io::util::read_until::{read_until, ReadUntil}; use crate::io::util::split::{split, Split}; use crate::io::AsyncBufRead; cfg_io_util! { /// An extension t...
tokio
rust
async_runtime
lines.rs
use crate::io::util::read_until::read_until_internal; use crate::io::AsyncBufRead; use pin_project_lite::pin_project; use std::io; use std::mem; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Reads lines from an [`AsyncBufRead`]. /// /// A `Lines` can be turned into a `Stream...
tokio
rust
async_runtime
flush.rs
use crate::io::AsyncWrite; use pin_project_lite::pin_project; use std::future::Future; use std::io; use std::marker::PhantomPinned; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// A future used to fully flush an I/O object. /// /// Created by the [`AsyncWriteExt::flush`][flush] funct...
tokio
rust
async_runtime
split.rs
use crate::io::util::read_until::read_until_internal; use crate::io::AsyncBufRead; use pin_project_lite::pin_project; use std::io; use std::mem; use std::pin::Pin; use std::task::{ready, Context, Poll}; pin_project! { /// Splitter for the [`split`](crate::io::AsyncBufReadExt::split) method. /// /// A `Spl...
tokio
rust
async_runtime
mem.rs
use crate::io::{split, AsyncRead, AsyncWrite, ReadBuf, ReadHalf, WriteHalf}; use crate::loom::sync::Mutex; use bytes::{Buf, BytesMut}; use std::{ pin::Pin, sync::Arc, task::{self, ready, Poll, Waker}, }; /// A bidirectional pipe to read and write bytes in memory. /// /// A pair of `DuplexStream`s are crea...
tokio
rust
async_runtime
repeat.rs
use bytes::BufMut; use crate::io::util::poll_proceed_and_make_progress; use crate::io::{AsyncRead, ReadBuf}; use std::io; use std::pin::Pin; use std::task::{ready, Context, Poll}; cfg_io_util! { /// An async reader which yields one byte over and over and over and over and /// over and... /// /// This...
tokio
rust
async_runtime
rename.rs
use super::utils::cstr; use crate::runtime::driver::op::{CancelData, Cancellable, Completable, CqeResult, Op}; use io_uring::{opcode, types}; use std::ffi::CString; use std::io; use std::path::Path; #[derive(Debug)] pub(crate) struct Rename { /// This field will be read by the kernel during the operation, so we ...
tokio
rust
async_runtime
write.rs
use crate::runtime::driver::op::{CancelData, Cancellable, Completable, CqeResult, Op}; use crate::util::as_ref::OwnedBuf; use io_uring::{opcode, types}; use std::io::{self, Error}; use std::os::fd::{AsRawFd, OwnedFd}; #[derive(Debug)] pub(crate) struct Write { buf: OwnedBuf, fd: OwnedFd, } impl Completable f...
tokio
rust
async_runtime
read.rs
use crate::io::blocking::Buf; use crate::io::uring::utils::{ArcFd, UringFd}; use crate::runtime::driver::op::{CancelData, Cancellable, Completable, CqeResult, Op}; use io_uring::{opcode, types}; use std::fmt; use std::io::{self, Error}; use std::os::fd::OwnedFd; /// Trait for buffers that can be used with io-uring re...
tokio
rust
async_runtime
statx.rs
#![cfg(all( tokio_unstable, feature = "io-uring", feature = "rt", feature = "fs", // libc::statx is only supported on these platforms // FIXME: Add musl target env when our minimum supported // rust version is 1.93. To clarify, statx support is // introduced to musl in 1.25 as mentioned ...
tokio
rust
async_runtime
open.rs
use super::utils::cstr; use crate::fs::UringOpenOptions; use crate::runtime::driver::op::{CancelData, Cancellable, Completable, CqeResult, Op}; use io_uring::{opcode, types}; use std::ffi::CString; use std::io::{self, Error}; use std::os::fd::FromRawFd; use std::path::Path; #[derive(Debug)] pub(crate) struct Open { ...
tokio
rust
async_runtime
utils.rs
use std::os::fd::{AsRawFd, OwnedFd, RawFd}; use std::os::unix::ffi::OsStrExt; use std::sync::Arc; use std::{ffi::CString, io, path::Path}; pub(crate) type ArcFd = Arc<dyn AsRawFd + Send + Sync + 'static>; /// Raw file descriptor trait for io-uring operations. /// /// `Arc<dyn AsRawFd>` does not satisfy `AsRawFd` beca...
tokio
rust
async_runtime
poll_aio.rs
use crate::io::interest::Interest; use crate::runtime::io::{ReadyEvent, Registration}; use crate::runtime::scheduler; use mio::event::Source; use mio::Registry; use mio::Token; use std::fmt; use std::io; use std::ops::{Deref, DerefMut}; use std::os::fd::{AsFd, BorrowedFd}; use std::os::unix::io::{AsRawFd, RawFd}; use s...
tokio
rust
async_runtime
runtime.rs
use super::AutoBox; use crate::runtime::blocking::BlockingPool; use crate::runtime::scheduler::CurrentThread; use crate::runtime::{context, EnterGuard, Handle}; use crate::task::JoinHandle; use crate::util::error::RUNTIME_SHUTTING_DOWN_ERROR; use crate::util::trace::SpawnMeta; use std::future::Future; use std::io; use...
tokio
rust
async_runtime
handle.rs
use crate::runtime; use crate::runtime::{context, scheduler, RuntimeFlavor, RuntimeMetrics}; /// Handle to the runtime. /// /// The handle is internally reference-counted and can be freely cloned. A handle can be /// obtained using the [`Runtime::handle`] method. /// /// [`Runtime::handle`]: crate::runtime::Runtime::h...
tokio
rust
async_runtime
thread_id.rs
use std::num::NonZeroU64; #[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)] pub(crate) struct ThreadId(NonZeroU64); impl ThreadId { pub(crate) fn next() -> Self { use crate::loom::sync::atomic::{AtomicU64, Ordering::Relaxed}; #[cfg(all(test, loom))] crate::loom::lazy_static! { ...
tokio
rust
async_runtime
id.rs
use std::fmt; use std::num::NonZeroU64; /// An opaque ID that uniquely identifies a runtime relative to all other currently /// running runtimes. /// /// # Notes /// /// - Runtime IDs are unique relative to other *currently running* runtimes. /// When a runtime completes, the same ID may be used for another runtime....
tokio
rust
async_runtime
config.rs
#![cfg_attr( any(not(all(tokio_unstable, feature = "full")), target_family = "wasm"), allow(dead_code) )] use crate::runtime::{Callback, TaskCallback}; use crate::util::RngSeedGenerator; pub(crate) struct Config { /// How many ticks before pulling a task from the global/remote queue? pub(crate) global_...
tokio
rust
async_runtime
park.rs
#![cfg_attr(not(feature = "full"), allow(dead_code))] use crate::loom::sync::atomic::AtomicUsize; use crate::loom::sync::{Arc, Condvar, Mutex}; use std::sync::atomic::Ordering::SeqCst; use std::time::Duration; #[derive(Debug)] pub(crate) struct ParkThread { inner: Arc<Inner>, } /// Unblocks a thread that was bl...
tokio
rust
async_runtime
task_hooks.rs
use super::Config; use std::marker::PhantomData; #[cfg(all(tokio_unstable, feature = "schedule-latency"))] use std::time::Duration; impl TaskHooks { pub(crate) fn spawn(&self, meta: &TaskMeta<'_>) { if let Some(f) = self.task_spawn_callback.as_ref() { f(meta) } } #[allow(dead_c...
tokio
rust
async_runtime
mod.rs
// At the top due to macros #[cfg(test)] #[cfg(not(target_family = "wasm"))] #[macro_use] mod tests; pub(crate) mod context; pub(crate) mod park; #[cfg(all(target_os = "emscripten", not(target_feature = "atomics")))] pub(crate) mod jspi; pub(crate) mod driver; pub(crate) mod scheduler; cfg_io_driver_impl! { p...
tokio
rust
async_runtime
jspi.rs
use std::ffi::c_void; use std::ptr; use std::sync::atomic::{AtomicPtr, Ordering::SeqCst}; use std::sync::OnceLock; use std::time::Duration; /// `em_promise_t`: an index into the host's promise table, never null. type Promise = *mut c_void; const EM_PROMISE_FULFILL: i32 = 0; /// Minimum Emscripten version required fo...
tokio
rust
async_runtime
driver.rs
// Eventually, this file will see significant refactoring / cleanup. For now, we // don't need to worry much about dead code with certain feature permutations. #![cfg_attr( any(not(all(tokio_unstable, feature = "full")), target_family = "wasm"), allow(dead_code) )] use crate::runtime::park::{ParkThread, Unpark...
tokio
rust
async_runtime
process.rs
#![cfg_attr(not(feature = "rt"), allow(dead_code))] use crate::process::unix::GlobalOrphanQueue; use crate::runtime::driver; use crate::runtime::signal::{Driver as SignalDriver, Handle as SignalHandle}; use std::time::Duration; /// Responsible for cleaning up orphaned child processes on Unix platforms. #[derive(Deb...
tokio
rust
async_runtime
dump.rs
use crate::task::Id; use std::{fmt, future::Future, path::Path}; pub use crate::runtime::task::trace::{trace_with, Root, TraceMeta}; /// A snapshot of a runtime's state. /// /// See [`Handle::dump`][crate::runtime::Handle::dump]. #[derive(Debug)] pub struct Dump { tasks: Tasks, } /// Snapshots of tasks. /// /// ...
tokio
rust
async_runtime
builder.rs
#![cfg_attr(loom, allow(unused_imports))] use crate::runtime::handle::Handle; use crate::runtime::{ blocking, driver, Callback, HistogramBuilder, Runtime, TaskCallback, TimerFlavor, }; #[cfg(tokio_unstable)] use crate::runtime::{metrics::HistogramConfiguration, TaskMeta}; use crate::runtime::{LocalOptions, LocalR...
tokio
rust
async_runtime
context.rs
use crate::loom::thread::AccessError; use crate::task::coop; use std::cell::Cell; #[cfg(any(feature = "rt", feature = "macros"))] use crate::util::rand::FastRand; cfg_rt! { mod blocking; pub(crate) use blocking::{disallow_block_in_place, try_enter_blocking_region, BlockingRegionGuard}; mod current; ...
tokio
rust
async_runtime
runtime.rs
use crate::runtime::Handle; use std::time::Duration; cfg_64bit_metrics! { use std::sync::atomic::Ordering::Relaxed; } cfg_unstable_metrics! { use std::ops::Range; use std::thread::ThreadId; } /// Handle to the runtime's metrics. /// /// This handle is internally reference-counted and can be freely cloned...
tokio
rust
async_runtime
schedule_latency.rs
use std::num::NonZeroU64; use std::time::Instant; /// `ScheduleLatencyInstant` tracks the time a task was scheduled. /// /// The time a task was scheduled is stored as the number of nanoseconds /// since startup of the task's scheduler. /// /// **Note**: This is an [unstable API][unstable]. The public API of this type...
tokio
rust
async_runtime
histogram.rs
mod h2_histogram; pub use h2_histogram::{InvalidHistogramConfiguration, LogHistogram, LogHistogramBuilder}; use crate::util::metric_atomics::MetricAtomicU64; use std::sync::atomic::Ordering::Relaxed; use crate::runtime::metrics::batch::duration_as_u64; use std::cmp; use std::ops::Range; use std::time::Duration; #[d...
tokio
rust
async_runtime
io.rs
#![cfg_attr(not(feature = "net"), allow(dead_code))] use crate::util::metric_atomics::MetricAtomicU64; use std::sync::atomic::Ordering::Relaxed; #[derive(Default)] pub(crate) struct IoDriverMetrics { pub(super) fd_registered_count: MetricAtomicU64, pub(super) fd_deregistered_count: MetricAtomicU64, pub(su...
tokio
rust
async_runtime
batch.rs
use crate::runtime::metrics::WorkerMetrics; cfg_unstable_metrics! { use crate::runtime::metrics::HistogramBatch; } use crate::runtime::metrics::ScheduleLatencyContext; use std::sync::atomic::Ordering::Relaxed; use std::time::{Duration, Instant}; pub(crate) struct MetricsBatch { /// The total busy duration in...
tokio
rust
async_runtime
worker.rs
use crate::runtime::Config; use crate::util::metric_atomics::{MetricAtomicU64, MetricAtomicUsize}; use std::sync::atomic::Ordering::Relaxed; use std::sync::Mutex; use std::thread::ThreadId; cfg_unstable_metrics! { use crate::runtime::metrics::Histogram; } /// Retrieve runtime worker metrics. /// /// **Note**: Thi...
tokio
rust
async_runtime
mod.rs
#![allow(clippy::module_inception)] mod runtime; pub use runtime::RuntimeMetrics; mod batch; pub(crate) use batch::MetricsBatch; mod worker; pub(crate) use worker::WorkerMetrics; cfg_unstable_metrics! { mod histogram; pub(crate) use histogram::{Histogram, HistogramBatch, HistogramBuilder}; #[allow(unr...
tokio
rust
async_runtime
scheduler.rs
use crate::loom::sync::atomic::Ordering::Relaxed; use crate::util::metric_atomics::MetricAtomicU64; /// Retrieves metrics from the Tokio runtime. /// /// **Note**: This is an [unstable API][unstable]. The public API of this type /// may break in 1.x releases. See [the documentation on unstable /// features][unstable] ...
tokio
rust
async_runtime
h2_histogram.rs
use crate::runtime::metrics::batch::duration_as_u64; use std::cmp; use std::error::Error; use std::fmt::{Display, Formatter}; use std::time::Duration; const DEFAULT_MIN_VALUE: Duration = Duration::from_nanos(100); const DEFAULT_MAX_VALUE: Duration = Duration::from_secs(60); /// Default precision is 2^-2 = 25% max err...
tokio
rust
async_runtime
current.rs
use super::{Context, CONTEXT}; use crate::runtime::{scheduler, TryCurrentError}; use crate::util::markers::SyncNotSend; use std::cell::{Cell, RefCell}; use std::marker::PhantomData; #[derive(Debug)] #[must_use] pub(crate) struct SetCurrentGuard { // The previous handle prev: Option<scheduler::Handle>, /...
tokio
rust
async_runtime
scoped.rs
use std::cell::Cell; use std::ptr; /// Scoped thread-local storage pub(super) struct Scoped<T> { pub(super) inner: Cell<*const T>, } impl<T> Scoped<T> { pub(super) const fn new() -> Scoped<T> { Scoped { inner: Cell::new(ptr::null()), } } /// Inserts a value into the scoped...
tokio
rust
async_runtime
runtime.rs
use super::{BlockingRegionGuard, SetCurrentGuard, CONTEXT}; use crate::runtime::scheduler; use crate::util::rand::{FastRand, RngSeed}; use std::fmt; #[derive(Debug, Clone, Copy)] #[must_use] pub(crate) enum EnterRuntime { /// Currently in a runtime context. #[cfg_attr(not(feature = "rt"), allow(dead_code))] ...
tokio
rust
async_runtime
runtime_mt.rs
use super::{EnterRuntime, CONTEXT}; /// Returns true if in a runtime context. pub(crate) fn current_enter_context() -> EnterRuntime { CONTEXT.with(|c| c.runtime.get()) } /// Forces the current "entered" state to be cleared while the closure /// is executed. pub(crate) fn exit_runtime<F: FnOnce() -> R, R>(f: F) ->...
tokio
rust
async_runtime
blocking.rs
use super::{EnterRuntime, CONTEXT}; use crate::loom::thread::AccessError; use crate::util::markers::NotSendOrSync; use std::marker::PhantomData; use std::time::Duration; /// Guard tracking that a caller has entered a blocking region. #[must_use] pub(crate) struct BlockingRegionGuard { _p: PhantomData<NotSendOrSy...
tokio
rust
async_runtime
shutdown.rs
use crate::loom::sync::Arc; use crate::sync::oneshot; use std::time::Duration; #[derive(Debug, Clone)] pub(super) struct Sender { _tx: Arc<oneshot::Sender<()>>, } #[derive(Debug)] pub(super) struct Receiver { rx: oneshot::Receiver<()>, } pub(super) fn channel() -> (Sender, Receiver) { let (tx, rx) = one...
tokio
rust
async_runtime
sharded.rs
use crate::loom::sync::atomic::{AtomicBool, AtomicUsize}; use crate::loom::sync::{Condvar, Mutex}; use crate::loom::thread; use crate::util::rand::{FastRand, RngSeed}; use std::collections::VecDeque; use std::sync::atomic::Ordering; use std::time::Duration; use super::pool::{ShutdownHandles, SpawnError, SpawnerMetric...
tokio
rust
async_runtime
task.rs
use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; /// Converts a function to a future that completes on poll. pub(crate) struct BlockingTask<T> { func: Option<T>, } impl<T> BlockingTask<T> { /// Initializes a new blocking task from the given function. pub(crate) fn new(func: T) -...
tokio
rust
async_runtime
mod.rs
mod pool; #[allow(unused_imports)] pub(crate) use pool::{spawn_blocking, BlockingPool, Mandatory, Spawner}; mod sharded; cfg_io_blocking! { pub(crate) use pool::spawn_mandatory_blocking; } mod schedule; mod shutdown; mod task; pub(crate) use task::BlockingTask; use crate::runtime::Builder; pub(crate) fn create...
tokio
rust
async_runtime
schedule.rs
#[cfg(feature = "test-util")] use crate::runtime::scheduler; use crate::runtime::task::{self, Task, TaskHarnessScheduleHooks}; use crate::runtime::Handle; /// `task::Schedule` implementation that does nothing (except some bookkeeping /// in test-util builds). This is unique to the blocking scheduler as tasks /// sched...
tokio
rust
async_runtime
pool.rs
use crate::loom::sync::{Arc, Condvar, Mutex}; use crate::loom::thread; use crate::runtime::blocking::schedule::BlockingSchedule; use crate::runtime::blocking::sharded::ShardedImpl; use crate::runtime::blocking::{shutdown, BlockingTask}; use crate::runtime::builder::ThreadNameFn; use crate::runtime::task::{self, JoinHan...
tokio
rust
async_runtime
runtime.rs
#![allow(irrefutable_let_patterns)] use crate::runtime::blocking::BlockingPool; use crate::runtime::scheduler::CurrentThread; use crate::runtime::{context, AutoBox, Builder, EnterGuard, Handle}; use crate::task::JoinHandle; use crate::util::trace::SpawnMeta; use std::future::Future; use std::marker::PhantomData; use ...
tokio
rust
async_runtime
options.rs
use std::marker::PhantomData; /// [`LocalRuntime`]-only config options /// /// Currently, there are no such options, but in the future, things like `!Send + !Sync` hooks may /// be added. /// /// Use `LocalOptions::default()` to create the default set of options. This type is used with /// [`Builder::build_local`]. //...