mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-21 00:00:10 +02:00
Carl Lerche
cf184eb326
* Remove `counted` field on `timer::Entry`. It turns out that a better indicator of whether or not the number of active timeouts should be decremented is if the `Entry` has been associated with a timer. In other words, if `Entry::inner` can be upgraded, then the count should be decremented on drop. * timer: Tweak link between `Delay` and the driver This tweaks the struct layout / details regarding how a `Delay` instance is linked to a driver (timer instance). Instead of lazily allocating the `Entry` (node shared between `Delay` and the timer), `Entry` is allocated immediately when `Delay` is created. This allows using the entry store data used by `Delay`. This is in anticipation of further timer improvements that would otherwise require the size of `Delay` to grow further. Since an allocation is already made, the idea is to shrink the size of the `Delay` struct.
85 lines
2.5 KiB
Rust
85 lines
2.5 KiB
Rust
use Error;
|
|
use timer::{Registration, HandlePriv};
|
|
|
|
use futures::{Future, Poll};
|
|
|
|
use std::time::Instant;
|
|
|
|
/// A future that completes at a specified instant in time.
|
|
///
|
|
/// Instances of `Delay` perform no work and complete with `()` once the
|
|
/// specified deadline has been reached.
|
|
///
|
|
/// `Delay` has a resolution of one millisecond and should not be used for tasks
|
|
/// that require high-resolution timers.
|
|
///
|
|
/// [`new`]: #method.new
|
|
#[derive(Debug)]
|
|
pub struct Delay {
|
|
/// The link between the `Delay` instance at the timer that drives it.
|
|
///
|
|
/// This also stores the `deadline` value.
|
|
registration: Registration,
|
|
}
|
|
|
|
impl Delay {
|
|
/// Create a new `Delay` instance that elapses at `deadline`.
|
|
///
|
|
/// Only millisecond level resolution is guaranteed. There is no guarantee
|
|
/// as to how the sub-millisecond portion of `deadline` will be handled.
|
|
/// `Delay` should not be used for high-resolution timer use cases.
|
|
pub fn new(deadline: Instant) -> Delay {
|
|
let registration = Registration::new(deadline);
|
|
|
|
Delay { registration }
|
|
}
|
|
|
|
pub(crate) fn new_with_handle(deadline: Instant, handle: HandlePriv) -> Delay {
|
|
let mut registration = Registration::new(deadline);
|
|
registration.register_with(handle);
|
|
|
|
Delay { registration }
|
|
}
|
|
|
|
/// Returns the instant at which the future will complete.
|
|
pub fn deadline(&self) -> Instant {
|
|
self.registration.deadline()
|
|
}
|
|
|
|
/// Returns true if the `Delay` has elapsed
|
|
///
|
|
/// A `Delay` is elapsed when the requested duration has elapsed.
|
|
pub fn is_elapsed(&self) -> bool {
|
|
self.registration.is_elapsed()
|
|
}
|
|
|
|
/// Reset the `Delay` instance to a new deadline.
|
|
///
|
|
/// Calling this function allows changing the instant at which the `Delay`
|
|
/// future completes without having to create new associated state.
|
|
///
|
|
/// This function can be called both before and after the future has
|
|
/// completed.
|
|
pub fn reset(&mut self, deadline: Instant) {
|
|
self.registration.reset(deadline);
|
|
}
|
|
|
|
/// Register the delay with the timer instance for the current execution
|
|
/// context.
|
|
fn register(&mut self) {
|
|
self.registration.register();
|
|
}
|
|
}
|
|
|
|
impl Future for Delay {
|
|
type Item = ();
|
|
type Error = Error;
|
|
|
|
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
|
|
// Ensure the `Delay` instance is associated with a timer.
|
|
self.register();
|
|
|
|
self.registration.poll_elapsed()
|
|
}
|
|
}
|