Module hrtimer

Expand description

Intrusive high resolution timers.

Allows running timer callbacks without doing allocations at the time of starting the timer. For now, only one timer per type is allowed.

§Vocabulary

States:

Stopped: initialized but not started, or cancelled, or not restarted.
Started: initialized and started or restarted.
Running: executing the callback.

Operations:

Start
Cancel
Restart

Events:

Expire

§State Diagram

                                                  Return NoRestart
                      +---------------------------------------------------------------------+
                      |                                                                     |
                      |                                                                     |
                      |                                                                     |
                      |                                         Return Restart              |
                      |                                      +------------------------+     |
                      |                                      |                        |     |
                      |                                      |                        |     |
                      v                                      v                        |     |
          +-----------------+      Start      +------------------+           +--------+-----+--+
          |                 +---------------->|                  |           |                 |
Init      |                 |                 |                  |  Expire   |                 |
--------->|    Stopped      |                 |      Started     +---------->|     Running     |
          |                 |     Cancel      |                  |           |                 |
          |                 |<----------------+                  |           |                 |
          +-----------------+                 +---------------+--+           +-----------------+
                                                    ^         |
                                                    |         |
                                                    +---------+
                                                     Restart

A timer is initialized in the stopped state. A stopped timer can be started by the start operation, with an expiry time. After the start operation, the timer is in the started state. When the timer expires, the timer enters the running state and the handler is executed. After the handler has returned, the timer may enter the *started or stopped state, depending on the return value of the handler. A timer in the started or running state may be canceled by the cancel operation. A timer that is cancelled enters the stopped state.

A cancel or restart operation on a timer in the running state takes effect after the handler has returned and the timer has transitioned out of the running state.

A restart operation on a timer in the stopped state is equivalent to a start operation.

Structs§

AbsoluteHardMode: Timer with absolute expiration, handled in hard irq context.
AbsoluteMode: Timer that expires at a fixed point in time.
AbsolutePinnedHardMode: Timer with absolute expiration, pinned to CPU and handled in hard irq context.
AbsolutePinnedMode: Timer with absolute expiration time, pinned to its current CPU.
AbsolutePinnedSoftMode: Timer with absolute expiration, pinned to CPU and handled in soft irq context.
AbsoluteSoftMode: Timer with absolute expiration, handled in soft irq context.
ArcHrTimerHandle: A handle for an Arc<HasHrTimer<T>> returned by a call to HrTimerPointer::start.
BoxHrTimerHandle: A handle for a Box<HasHrTimer<T>> returned by a call to HrTimerPointer::start.
HrTimer: A timer backed by a C struct hrtimer.
HrTimerCallbackContext: Privileged smart-pointer for a HrTimer callback context.
PinHrTimerHandle: A handle for a Pin<&HasHrTimer>. When the handle exists, the timer might be running.
PinMutHrTimerHandle: A handle for a Pin<&mut HasHrTimer>. When the handle exists, the timer might be running.
RelativeHardMode: Timer with relative expiration, handled in hard irq context.
RelativeMode: Timer that expires after a delay from now.
RelativePinnedHardMode: Timer with relative expiration, pinned to CPU and handled in hard irq context.
RelativePinnedMode: Timer with relative expiration time, pinned to its current CPU.
RelativePinnedSoftMode: Timer with absolute expiration, pinned to CPU and handled in soft irq context.
RelativeSoftMode: Timer with relative expiration, handled in soft irq context.

Enums§

HrTimerRestart: Restart policy for timers.

Traits§

HasHrTimer: Implemented by structs that contain timer nodes.
HrTimerCallback: Implemented by structs that can be the target of a timer callback.
HrTimerExpires: Time representations that can be used as expiration values in HrTimer.
HrTimerHandle: A handle representing a potentially running timer.
HrTimerMode: Operational mode of HrTimer.
HrTimerPointer: Implemented by pointer types that point to structs that contain a HrTimer.
RawHrTimerCallback: Implemented by HrTimerPointer implementers to give the C timer callback a function to call.
ScopedHrTimerPointer: A trait for stack allocated timers.
UnsafeHrTimerPointer: Unsafe version of HrTimerPointer for situations where leaking the HrTimerHandle returned by start would be unsound. This is the case for stack allocated timers.

Type Aliases§

HrTimerInstant: A type-alias to refer to the Instant<C> for a given T from HrTimer<T>.

Module hrtimerCopy item path