Struct tarantool::time::Instant

pub struct Instant(/* private fields */);

A measurement of a monotonically nondecreasing clock. Opaque and useful only with Duration.

Instants are guaranteed to be no less than any previously measured instant when created, and are often useful for tasks such as measuring benchmarks or timing how long an operation takes.

Note, however, that instants are not guaranteed to be steady. In other words, each tick of the underlying clock might not be the same length (e.g. some seconds may be longer than others). An instant may jump forwards or experience time dilation (slow down or speed up), but it will never go backwards.

Instants should generally be condsidered as opaque types that can only be compared to one another. Though there is a method to get “the number of seconds” from an instant it is implementation dependent and should be used with knowledge of how this particular Instant was constructed. Instead, prefer using other operations, such as measuring the duration between two instants, comparing two instants, adding and subtracting Duration.

This struct is almost identical to std::time::Instant but provides some additional saturating methods. And it can also be constructed with fiber::clock, in which case it behaves in a tarantool specific way.

Implementations

impl Instant

pub fn now() -> Self

👎Deprecated: use now_fiber or now_accurate instead

Equivalent to Self::now_accurate.

pub fn now_accurate() -> Self

Returns an instant corresponding to “now”. Uses monotonic clock.

Use this function when duration accuracy is required, for example when timing the execution of different parts of your program (benchmarking).

If you need to compute timeouts for yielding operations you should use Self::now_fiber instead.

Examples

use tarantool::time::Instant;

let start = Instant::now_accurate();
expensive_computation();
println!("expensive_computation took {:?}", start.elapsed());

pub fn now_fiber() -> Self

Returns an instant corresponding to event loop iteration begin time. Uses monotonic clock.

Use this function when computing timeouts for tasks which may result in fiber yields. It is important that this function is used, because the tarantool uses this value for it’s internal event loop timers, and using Self::now_accurate may result in unexpected results.

If instead you’re timing how long things execute, use Self::now_accurate.

Examples

use tarantool::time::Instant;
use std::time::Duration;

let timeout = Duration::from_secs(3);
let deadline = Instant::now_fiber().saturating_add(timeout);
while Instant::now_fiber() < deadline {
    do_some_yielding_task();
}

pub fn elapsed(&self) -> Duration

Returns the amount of time elapsed since this instant was created.

Uses Self::now_accurate to determine the instant of “now”.

Examples

use std::time::Duration;
use tarantool::time::Instant;
use tarantool::fiber;

let instant = Instant::now_accurate();
let three_secs = Duration::from_secs(3);
fiber::sleep(three_secs);
assert!(instant.elapsed() >= three_secs);

pub fn checked_add(&self, duration: Duration) -> Option<Instant>

Returns Some(t) where t is the time self + duration if t can be represented as Instant (which means it’s inside the bounds of the underlying representation), None otherwise.

pub fn checked_sub(&self, duration: Duration) -> Option<Instant>

Returns Some(t) where t is the time self - duration if t can be represented as Instant (which means it’s inside the bounds of the underlying representation), None otherwise.

pub fn saturating_add(&self, duration: Duration) -> Instant

Saturating addition. Computes self + duration, returning maximal possible instant (allowed by the underlying representaion) if overflow occurred.

pub fn saturating_sub(&self, duration: Duration) -> Instant

Saturating subtraction. Computes self - duration, returning minimal possible instant (allowed by the underlying representaion) if overflow occurred.

pub fn checked_duration_since(&self, earlier: Instant) -> Option<Duration>

Returns the amount of time elapsed from another instant to this one, or None if that instant is later than this one.

Examples

use std::time::Duration;
use std::thread::sleep;
use tarantool::time::Instant;

let now = Instant::now();
sleep(Duration::new(1, 0));
let new_now = Instant::now();
println!("{:?}", new_now.checked_duration_since(now));
println!("{:?}", now.checked_duration_since(new_now)); // None

pub fn duration_since(&self, earlier: Instant) -> Duration

Returns the amount of time elapsed from another instant to this one, or zero duration if that instant is later than this one.

Examples

use std::time::Duration;
use std::thread::sleep;
use tarantool::time::Instant;

let now = Instant::now();
sleep(Duration::new(1, 0));
let new_now = Instant::now();
println!("{:?}", new_now.duration_since(now));
println!("{:?}", now.duration_since(new_now)); // 0ns

pub fn as_secs(&self) -> u64

Get the inner representation of an Instant.

Warning

The inner representation of an instant is implementation dependent and should be used with knowledge of how this particular Instant was constructed.

If possible prefer working with Instant and Duration directly without getting its inner representation.

pub fn as_secs_f64(&self) -> f64

Get the inner representation of an Instant.

Warning

The inner representation of an instant is implementation dependent and should be used with knowledge of how this particular Instant was constructed.

If possible prefer working with Instant and Duration directly without getting its inner representation.

pub fn as_secs_f32(&self) -> f32

Get the inner representation of an Instant.

Warning

The inner representation of an instant is implementation dependent and should be used with knowledge of how this particular Instant was constructed.

If possible prefer working with Instant and Duration directly without getting its inner representation.

Trait Implementations

impl Add<Duration> for Instant

fn add(self, other: Duration) -> Instant

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See Instant::checked_add for a version without panic.

type Output = Instant

The resulting type after applying the + operator.

impl AddAssign<Duration> for Instant

fn add_assign(&mut self, other: Duration)

Performs the += operation.

impl Clone for Instant

fn clone(&self) -> Instant

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instant

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Instant

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Instant

fn cmp(&self, other: &Instant) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Instant

fn eq(&self, other: &Instant) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Instant

fn partial_cmp(&self, other: &Instant) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Duration> for Instant

type Output = Instant

The resulting type after applying the - operator.

fn sub(self, other: Duration) -> Instant

Performs the - operation.

impl Sub for Instant

fn sub(self, other: Instant) -> Duration

Returns the amount of time elapsed from another instant to this one, or zero duration if that instant is later than this one.

type Output = Duration

The resulting type after applying the - operator.

impl SubAssign<Duration> for Instant

fn sub_assign(&mut self, other: Duration)

Performs the -= operation.

impl Copy for Instant

impl Eq for Instant

impl StructuralPartialEq for Instant