componentized/directory

wasi:clocks

interface dependency

WASI clock interfaces for monotonic and system clocks

interface monotonic-clock wasi:clocks/monotonic-clock@0.2.12 since 0.2.0

WASI Monotonic Clock is a clock API intended to let users measure elapsed time.

It is intended to be portable at least between Unix-family platforms and Windows.

A monotonic clock is a clock which has an unspecified initial value, and successive reads of the clock will produce non-decreasing values.

Types

use resource pollablesince 0.2.0

from wasi:io/poll@0.2.12

pollable represents a single I/O event which may be ready, or not.

  • ready: func() -> boolsince 0.2.0

    Return the readiness of a pollable. This function never blocks.

    Returns true when the pollable is ready, and false otherwise.

  • block: func()since 0.2.0

    block returns immediately if the pollable is ready, and otherwise blocks until ready.

    This function is equivalent to calling poll.poll on a list containing only this pollable.

type instantsince 0.2.0

An instant in time, in nanoseconds. An instant is relative to an unspecified initial value, and can only be compared to instances from the same monotonic-clock.

  • u64

type durationsince 0.2.0

A duration of time, in nanoseconds.

  • u64

Functions

now: func() -> instantsince 0.2.0

Read the current value of the clock.

The clock is monotonic, therefore calling this function repeatedly will produce a sequence of non-decreasing values.

For completeness, this function traps if it's not possible to represent the value of the clock in an instant. Consequently, implementations should ensure that the starting time is low enough to avoid the possibility of overflow in practice.

resolution: func() -> durationsince 0.2.0

Query the resolution of the clock. Returns the duration of time corresponding to a clock tick.

subscribe-instant: func(when: instant) -> pollablesince 0.2.0

Create a pollable which will resolve once the specified instant has occurred.

subscribe-duration: func(when: duration) -> pollablesince 0.2.0

Create a pollable that will resolve after the specified duration has elapsed from the time this function is invoked.

WIT

/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
/// time.
///
/// It is intended to be portable at least between Unix-family platforms and
/// Windows.
///
/// A monotonic clock is a clock which has an unspecified initial value, and
/// successive reads of the clock will produce non-decreasing values.
@since(version = 0.2.0)
interface monotonic-clock {
  @since(version = 0.2.0)
  use wasi:io/poll@0.2.12.{pollable};

  /// An instant in time, in nanoseconds. An instant is relative to an
  /// unspecified initial value, and can only be compared to instances from
  /// the same monotonic-clock.
  @since(version = 0.2.0)
  type instant = u64;

  /// A duration of time, in nanoseconds.
  @since(version = 0.2.0)
  type duration = u64;

  /// Read the current value of the clock.
  ///
  /// The clock is monotonic, therefore calling this function repeatedly will
  /// produce a sequence of non-decreasing values.
  ///
  /// For completeness, this function traps if it's not possible to represent
  /// the value of the clock in an `instant`. Consequently, implementations
  /// should ensure that the starting time is low enough to avoid the
  /// possibility of overflow in practice.
  @since(version = 0.2.0)
  now: func() -> instant;

  /// Query the resolution of the clock. Returns the duration of time
  /// corresponding to a clock tick.
  @since(version = 0.2.0)
  resolution: func() -> duration;

  /// Create a `pollable` which will resolve once the specified instant
  /// has occurred.
  @since(version = 0.2.0)
  subscribe-instant: func(when: instant) -> pollable;

  /// Create a `pollable` that will resolve after the specified duration has
  /// elapsed from the time this function is invoked.
  @since(version = 0.2.0)
  subscribe-duration: func(when: duration) -> pollable;
}