Struct Instant 

pub struct Instant { /* private fields */ }

Available on crate feature full only.

A measurement of the current system time. Opaque and useful only with [Duration].

Instants are opaque types that should usually only be compared to one another. [get()] can be used to get the internal value, but no guarantees are made about the meaning of the value. The meaning of the result of get() varies by system and may even change at runtime during a single boot. A best-attempt value of the time since system boot can be retrieved with [nanos_since_boot()].

The size of an Instant struct may vary depending on the target platform.

Example:

use core::time::Duration;
use kernel_api::time::Instant;
use kernel_api::threading::sleep;
use kernel_api::executor::block_on;

fn main() {
   let now = Instant::now();

   // we sleep for 2 seconds
   block_on(sleep(Duration::new(2, 0)));
   // it prints '2'
   sprintln!("{}", now.elapsed().as_secs());
}

Underlying system

The following mechanisms are currently being used by now() to find out the current time:

Platform	Mechanism
x86_64	rdtsc instruction

These mechanisms might change over time.

Note: mathematical operations like add() may panic if the underlying structure cannot represent the new point in time.

Implementations

impl Instant

pub fn now() -> Self

The current system time.

Examples

use kernel_api::time::Instant;

let now = Instant::now();

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

Returns the amount of time elapsed from another instant to this one.

Panics

This method may panic if self is earlier than earlier.

Examples

use core::time::Duration;
use kernel_api::time::Instant;
use kernel_api::threading::sleep;
use kernel_api::executor::block_on;

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

pub fn checked_duration_since(&self, earlier: Self) -> 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 core::time::Duration;
use kernel_api::time::Instant;
use kernel_api::threading::sleep;
use kernel_api::executor::block_on;

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

pub fn saturating_duration_since(&self, earlier: Self) -> 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 core::time::Duration;
use kernel_api::time::Instant;
use kernel_api::threading::sleep;
use kernel_api::executor::block_on;

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

pub fn elapsed(&self) -> Duration

Returns the amount of time elapsed since this instant.

Panics

This method may panic if the current time is earlier than self.

Examples

use core::time::Duration;
use kernel_api::time::Instant;
use kernel_api::threading::sleep;
use kernel_api::executor::block_on;

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

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

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 data structure), None otherwise.

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

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 data structure), None otherwise.

pub fn nanos_since_boot(&self) -> u128

The number of nanoseconds since the system booted.

No guarantees are provided on time before overflow.

pub const fn get(&self) -> u128

Returns the opaque numeric value of the instant.

The meaning of the returned value is architecture dependant, see the struct level documentation for more information.

Trait Implementations

impl Add<Duration> for Instant

fn add(self, rhs: Duration) -> Self::Output

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, rhs: Duration)

Performs the += operation.

impl Clone for Instant

fn clone(&self) -> Instant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Instant

impl Debug for Instant

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

Formats the value using the given formatter.

impl Eq for Instant

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,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Instant

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

Equality operator ==.

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

Inequality operator !=.

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 StructuralPartialEq for Instant

impl Sub for Instant

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Sub<Duration> for Instant

fn sub(self, rhs: Duration) -> Self::Output

Panics

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

type Output = Instant

The resulting type after applying the - operator.

impl SubAssign<Duration> for Instant

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.