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      |                  |           |                 |
          |                 |<----------------+                  |           |                 |
          +-----------------+                 +---------------+--+           +-----------------+
                                                    ^         |
                                                    |         |
                                                    +---------+
                                                     RestartA 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§
- ArcHrTimer Handle 
- A handle for an Arc<HasHrTimer<T>>returned by a call toHrTimerPointer::start.
- BoxHrTimer Handle 
- A handle for a Box<HasHrTimer<T>>returned by a call toHrTimerPointer::start.
- HrTimer
- A timer backed by a C struct hrtimer.
- PinHrTimer Handle 
- A handle for a Pin<&HasHrTimer>. When the handle exists, the timer might be running.
- PinMutHrTimer Handle 
- A handle for a Pin<&mut HasHrTimer>. When the handle exists, the timer might be running.
Enums§
- HrTimerMode 
- Operational mode of HrTimer.
- 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.
- HrTimerHandle 
- A handle representing a potentially running timer.
- HrTimerPointer 
- Implemented by pointer types that point to structs that contain a HrTimer.
- RawHrTimer Callback 
- Implemented by HrTimerPointerimplementers to give the C timer callback a function to call.
- ScopedHrTimer Pointer 
- A trait for stack allocated timers.
- UnsafeHrTimer Pointer 
- Unsafe version of HrTimerPointerfor situations where leaking theHrTimerHandlereturned bystartwould be unsound. This is the case for stack allocated timers.