src/timer.rs - 3p/tock/libtock-rs - Git at Google

 //! Async timer driver. Can be used for (non-busy)  sleeping.

 use crate::callback::CallbackSubscription;
 use crate::callback::Consumer;
 use crate::futures;
 use crate::result::OtherError;
 use crate::result::TockError;
 use crate::result::TockResult;
 use crate::result::EALREADY;
 use crate::syscalls;
 use core::cell::Cell;
 use core::isize;
 use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Sub};

 const DRIVER_NUMBER: usize = 0x00000;

 mod command_nr {
     pub const IS_DRIVER_AVAILABLE: usize = 0;
     pub const GET_CLOCK_FREQUENCY: usize = 1;
     pub const GET_CLOCK_VALUE: usize = 2;
     pub const STOP_ALARM: usize = 3;
     pub const SET_ALARM: usize = 4;
 }

 mod subscribe_nr {
     pub const SUBSCRIBE_CALLBACK: usize = 0;
 }

 pub struct WithCallback<'a, CB> {
     callback: CB,
     clock_frequency: ClockFrequency,
     phantom: PhantomData<&'a mut ()>,
 }

 struct TimerEventConsumer;

 impl<CB: FnMut(ClockValue, Alarm)> Consumer<WithCallback<'_, CB>> for TimerEventConsumer {
     fn consume(data: &mut WithCallback<CB>, clock_value: usize, alarm_id: usize, _: usize) {
         (data.callback)(
             ClockValue {
                 num_ticks: clock_value as isize,
                 clock_frequency: data.clock_frequency,
             },
             Alarm { alarm_id },
         );
     }
 }

 impl<'a, CB: FnMut(ClockValue, Alarm)> WithCallback<'a, CB> {
     pub fn init(&'a mut self) -> TockResult<Timer<'a>> {
         let num_notifications =
             syscalls::command(DRIVER_NUMBER, command_nr::IS_DRIVER_AVAILABLE, 0, 0)?;

         let clock_frequency =
             syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)?;

         if clock_frequency == 0 {
             return Err(OtherError::TimerDriverErroneousClockFrequency.into());
         }

         let clock_frequency = ClockFrequency {
             hz: clock_frequency,
         };

         let subscription = syscalls::subscribe::<TimerEventConsumer, _>(
             DRIVER_NUMBER,
             subscribe_nr::SUBSCRIBE_CALLBACK,
             self,
         )?;

         Ok(Timer {
             num_notifications,
             clock_frequency,
             subscription,
         })
     }
 }

 pub struct Timer<'a> {
     num_notifications: usize,
     clock_frequency: ClockFrequency,
     #[allow(dead_code)] // Used in drop
     subscription: CallbackSubscription<'a>,
 }

 impl<'a> Timer<'a> {
     pub fn num_notifications(&self) -> usize {
         self.num_notifications
     }

     pub fn clock_frequency(&self) -> ClockFrequency {
         self.clock_frequency
     }

     pub fn get_current_clock(&self) -> TockResult<ClockValue> {
         Ok(ClockValue {
             num_ticks: syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0)?
                 as isize,
             clock_frequency: self.clock_frequency,
         })
     }

     pub fn stop_alarm(&mut self, alarm: Alarm) -> TockResult<()> {
         syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, alarm.alarm_id, 0)?;
         Ok(())
     }

     pub fn set_alarm(&mut self, duration: Duration<isize>) -> TockResult<Alarm> {
         let now = self.get_current_clock()?;
         let freq = self.clock_frequency.hz();
         let duration_ms = duration.ms() as usize;
         let ticks = match duration_ms.checked_mul(freq) {
             Some(x) => x / 1000,
             None => {
                 // Divide the largest of the two operands by 1000, to improve precision of the
                 // result.
                 if duration_ms > freq {
                     match (duration_ms / 1000).checked_mul(freq) {
                         Some(y) => y,
                         None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
                     }
                 } else {
                     match (freq / 1000).checked_mul(duration_ms) {
                         Some(y) => y,
                         None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
                     }
                 }
             }
         };
         let alarm_instant = now.num_ticks() as usize + ticks;

         let alarm_id = syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, alarm_instant, 0)?;

         Ok(Alarm { alarm_id })
     }
 }

 #[derive(Copy, Clone, Debug)]
 pub struct ClockFrequency {
     hz: usize,
 }

 impl ClockFrequency {
     pub fn hz(self) -> usize {
         self.hz
     }
 }

 #[derive(Copy, Clone, Debug)]
 pub struct ClockValue {
     num_ticks: isize,
     clock_frequency: ClockFrequency,
 }

 impl ClockValue {
     pub fn num_ticks(self) -> isize {
         self.num_ticks
     }

     pub fn ms(self) -> isize {
         if self.num_ticks.abs() < isize::MAX / 1000 {
             (1000 * self.num_ticks) / self.clock_frequency.hz() as isize
         } else {
             1000 * (self.num_ticks / self.clock_frequency.hz() as isize)
         }
     }

     pub fn ms_f64(self) -> f64 {
         1000.0 * (self.num_ticks as f64) / (self.clock_frequency.hz() as f64)
     }
 }

 pub struct Alarm {
     alarm_id: usize,
 }

 impl Alarm {
     pub fn alarm_id(&self) -> usize {
         self.alarm_id
     }
 }

 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Duration<T> {
     ms: T,
 }

 impl<T> Duration<T> {
     pub const fn from_ms(ms: T) -> Duration<T> {
         Duration { ms }
     }
 }

 impl<T> Duration<T>
 where
     T: Copy,
 {
     pub fn ms(&self) -> T {
         self.ms
     }
 }

 impl<T> Sub for Duration<T>
 where
     T: Sub<Output = T>,
 {
     type Output = Duration<T>;

     fn sub(self, other: Duration<T>) -> Duration<T> {
         Duration {
             ms: self.ms - other.ms,
         }
     }
 }

 #[derive(Copy, Clone, Debug)]
 pub struct Timestamp<T> {
     ms: T,
 }

 impl<T> Timestamp<T> {
     pub const fn from_ms(ms: T) -> Timestamp<T> {
         Timestamp { ms }
     }
 }

 impl<T> Timestamp<T>
 where
     T: Copy,
 {
     pub fn ms(&self) -> T {
         self.ms
     }
 }

 impl Timestamp<isize> {
     pub fn from_clock_value(value: ClockValue) -> Timestamp<isize> {
         Timestamp { ms: value.ms() }
     }
 }

 impl Timestamp<f64> {
     pub fn from_clock_value(value: ClockValue) -> Timestamp<f64> {
         Timestamp { ms: value.ms_f64() }
     }
 }

 impl<T> Sub for Timestamp<T>
 where
     T: Sub<Output = T>,
 {
     type Output = Duration<T>;

     fn sub(self, other: Timestamp<T>) -> Duration<T> {
         Duration::from_ms(self.ms - other.ms)
     }
 }

 impl<T> Add<Duration<T>> for Timestamp<T>
 where
     T: Copy + Add<Output = T>,
 {
     type Output = Timestamp<T>;

     fn add(self, duration: Duration<T>) -> Timestamp<T> {
         Timestamp {
             ms: self.ms + duration.ms(),
         }
     }
 }

 impl<T> AddAssign<Duration<T>> for Timestamp<T>
 where
     T: Copy + AddAssign,
 {
     fn add_assign(&mut self, duration: Duration<T>) {
         self.ms += duration.ms();
     }
 }

 #[derive(Copy, Clone, Default, PartialEq, Eq)]
 pub(crate) struct ActiveTimer {
     instant: u32,
     set_at: u32,
 }

 /// Context for the time driver.
 /// You can create a context as follows:
 /// ```no_run
 /// # use libtock::result::TockResult;
 /// # async fn doc() -> TockResult<()> {
 /// let mut drivers = libtock::retrieve_drivers()?;
 /// let mut timer_context = drivers.timer;
 /// # Ok(())
 /// # }
 /// ```
 #[non_exhaustive]
 pub struct DriverContext {
     pub(crate) active_timer: Cell<Option<ActiveTimer>>,
 }

 impl DriverContext {
     /// Create a driver timer from a context.
     pub fn create_timer_driver(&mut self) -> TimerDriver {
         TimerDriver {
             callback: Callback,
             context: self,
         }
     }

     pub fn with_callback<CB>(&mut self, callback: CB) -> WithCallback<CB> {
         WithCallback {
             callback,
             clock_frequency: ClockFrequency { hz: 0 },
             phantom: PhantomData,
         }
     }
 }

 /// Timer driver instance. You can create a TimerDriver from a DriverContext as follows:
 /// ```no_run
 /// # use libtock::result::TockResult;
 /// # async fn doc() -> TockResult<()> {
 /// # let mut drivers = libtock::retrieve_drivers()?;
 /// # let mut timer_context = drivers.timer;
 /// let mut timer_driver = timer_context.create_timer_driver();
 /// let timer_driver = timer_driver.activate()?;
 /// # Ok(())
 /// # }
 /// ```
 pub struct TimerDriver<'a> {
     callback: Callback,
     context: &'a DriverContext,
 }

 struct Callback;

 struct ParallelTimerConsumer;

 impl<'a> Consumer<Callback> for ParallelTimerConsumer {
     fn consume(_: &mut Callback, _: usize, _: usize, _: usize) {}
 }

 /// Activated time driver. Updates current time in the context and manages
 /// active alarms.
 /// Example usage (sleep for 1 second):
 /// ```no_run
 /// # use libtock::result::TockResult;
 /// # use libtock::timer::Duration;
 /// # async fn doc() -> TockResult<()> {
 /// # let mut drivers = libtock::retrieve_drivers()?;
 /// # let mut timer_driver = drivers.timer.create_timer_driver();
 /// let timer_driver = timer_driver.activate()?;
 /// timer_driver.sleep(Duration::from_ms(1000)).await?;
 /// # Ok(())
 /// # }
 /// ```
 pub struct ParallelSleepDriver<'a> {
     _callback_subscription: CallbackSubscription<'a>,
     context: &'a DriverContext,
 }

 impl<'a> TimerDriver<'a> {
     /// Activate the timer driver, will return a ParallelSleepDriver which
     /// can used to sleep.
     pub fn activate(&'a mut self) -> TockResult<ParallelSleepDriver<'a>> {
         let subscription = syscalls::subscribe::<ParallelTimerConsumer, _>(
             DRIVER_NUMBER,
             subscribe_nr::SUBSCRIBE_CALLBACK,
             &mut self.callback,
         )?;
         let driver = ParallelSleepDriver {
             _callback_subscription: subscription,
             context: &self.context,
         };
         Ok(driver)
     }
 }

 impl<'a> ParallelSleepDriver<'a> {
     /// Sleep for the given duration
     pub async fn sleep(&self, duration: Duration<usize>) -> TockResult<()> {
         let now = get_current_ticks()?;
         let freq = get_clock_frequency()?;
         let alarm_instant = Self::compute_alarm_instant(duration.ms, now, freq)?;
         let this_alarm = ActiveTimer {
             instant: alarm_instant as u32,
             set_at: now as u32,
         };

         let suspended_timer: Cell<Option<ActiveTimer>> = Cell::new(None);

         futures::wait_until(|| {
             self.activate_current_timer(this_alarm, &suspended_timer)
                 .unwrap_or(false)
         })
         .await;

         Ok(())
     }

     fn activate_timer(&self, timer: ActiveTimer) -> TockResult<()> {
         set_alarm_at(timer.instant as usize)?;
         let now = get_current_ticks()?;
         if !is_over(timer, now as u32) {
             self.context.active_timer.set(Some(timer));
         } else {
             self.wakeup_soon()?;
         }
         Ok(())
     }

     fn wakeup_soon(&self) -> TockResult<()> {
         self.context.active_timer.set(None);

         for i in 0.. {
             let now = get_current_ticks()?;

             let next_timer = ActiveTimer {
                 instant: now as u32 + i,
                 set_at: now as u32,
             };
             set_alarm_at(next_timer.instant as usize)?;
             let now = get_current_ticks()?;
             if !is_over(next_timer, now as u32) {
                 break;
             } else {
                 stop_alarm_at(next_timer.instant as usize)?;
             }
         }
         Ok(())
     }

     fn compute_alarm_instant(
         duration_ms: usize,
         num_ticks: usize,
         freq: usize,
     ) -> TockResult<usize> {
         let ticks = match duration_ms.checked_mul(freq) {
             Some(x) => x / 1000,
             None => {
                 // Divide the largest of the two operands by 1000, to improve precision of the
                 // result.
                 if duration_ms > freq {
                     match (duration_ms / 1000).checked_mul(freq) {
                         Some(y) => y,
                         None => {
                             return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
                         }
                     }
                 } else {
                     match (freq / 1000).checked_mul(duration_ms) {
                         Some(y) => y,
                         None => {
                             return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
                         }
                     }
                 }
             }
         };
         let alarm_instant = num_ticks + ticks;
         Ok(alarm_instant)
     }

     fn activate_current_timer(
         &self,
         this_alarm: ActiveTimer,
         suspended_timer: &Cell<Option<ActiveTimer>>,
     ) -> TockResult<bool> {
         let now = get_current_ticks()?;

         if let Some(active) = self.context.active_timer.get() {
             if left_is_later(active, this_alarm) {
                 suspended_timer.set(Some(active));
                 self.activate_timer(this_alarm)?;
             }
         } else {
             self.activate_timer(this_alarm)?;
         }
         if is_over(this_alarm, now as u32) {
             if let Some(paused) = suspended_timer.get() {
                 self.activate_timer(paused)?;
             } else {
                 self.context.active_timer.set(None);
             }
             Ok(true)
         } else {
             Ok(false)
         }
     }
 }

 fn get_current_ticks() -> TockResult<usize> {
     syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0).map_err(|err| err.into())
 }
 fn set_alarm_at(instant: usize) -> TockResult<()> {
     syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, instant, 0)
         .map(|_| ())
         .map_err(|err| err.into())
 }

 fn stop_alarm_at(instant: usize) -> TockResult<()> {
     match syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, instant, 0) {
         Ok(_) => Ok(()),
         Err(error) => match error.return_code {
             EALREADY => Ok(()),
             _ => Err(TockError::Command(error)),
         },
     }
 }

 fn get_clock_frequency() -> TockResult<usize> {
     syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)
         .map_err(|err| err.into())
 }

 fn is_over(timer: ActiveTimer, now: u32) -> bool {
     now.wrapping_sub(timer.set_at) >= timer.instant.wrapping_sub(timer.set_at)
 }

 fn left_is_later(alarm_1: ActiveTimer, alarm_2: ActiveTimer) -> bool {
     if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
         return alarm_1.instant > alarm_2.instant;
     }
     if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
         return false;
     }
     if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
         return true;
     }
     if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
         return alarm_1.instant > alarm_2.instant;
     }
     false
 }

 #[cfg(test)]
 mod test {
     use super::*;
     #[test]
     pub fn duration_bigger_than_frequency() {
         let x = ParallelSleepDriver::compute_alarm_instant(10000, 0, 1000)
             .ok()
             .unwrap();
         assert_eq!(x, 10000);
     }

     #[test]
     pub fn frequency_bigger_than_duration() {
         let x = ParallelSleepDriver::compute_alarm_instant(1000, 0, 10000)
             .ok()
             .unwrap();
         assert_eq!(x, 10000);
     }

     #[test]
     pub fn fails_if_duration_is_too_large() {
         let x =
             ParallelSleepDriver::compute_alarm_instant(core::usize::MAX, 0, core::usize::MAX - 1);
         assert!(x.is_err());
     }

     #[test]
     pub fn fails_if_frequency_is_too_large() {
         let x =
             ParallelSleepDriver::compute_alarm_instant(core::usize::MAX - 1, 0, core::usize::MAX);
         assert!(x.is_err());
     }

     #[test]
     pub fn alarm_before_systick_wrap_expired() {
         assert_eq!(
             super::is_over(
                 super::ActiveTimer {
                     instant: 2u32,
                     set_at: 1u32
                 },
                 3u32
             ),
             true
         );
     }

     #[test]
     pub fn alarm_before_systick_wrap_not_expired() {
         assert_eq!(
             super::is_over(
                 super::ActiveTimer {
                     instant: 3u32,
                     set_at: 1u32
                 },
                 2u32
             ),
             false
         );
     }

     #[test]
     pub fn alarm_after_systick_wrap_expired() {
         assert_eq!(
             super::is_over(
                 super::ActiveTimer {
                     instant: 1u32,
                     set_at: 3u32
                 },
                 2u32
             ),
             true
         );
     }

     #[test]
     pub fn alarm_after_systick_wrap_time_before_systick_wrap_not_expired() {
         assert_eq!(
             super::is_over(
                 super::ActiveTimer {
                     instant: 1u32,
                     set_at: 3u32
                 },
                 4u32
             ),
             false
         );
     }

     #[test]
     pub fn alarm_after_systick_wrap_time_after_systick_wrap_not_expired() {
         assert_eq!(
             super::is_over(
                 super::ActiveTimer {
                     instant: 1u32,
                     set_at: 3u32
                 },
                 0u32
             ),
             false
         );
     }

     #[test]
     pub fn left_later_than_the_other_both_not_wrapped() {
         let later = super::ActiveTimer {
             instant: 3u32,
             set_at: 1u32,
         };
         let earlier = super::ActiveTimer {
             instant: 2u32,
             set_at: 1u32,
         };
         assert_eq!(super::left_is_later(later, earlier), true);
     }

     #[test]
     pub fn right_later_than_the_other_both_not_wrapped() {
         let later = super::ActiveTimer {
             instant: 2u32,
             set_at: 1u32,
         };
         let earlier = super::ActiveTimer {
             instant: 3u32,
             set_at: 1u32,
         };
         assert_eq!(super::left_is_later(later, earlier), false);
     }

     #[test]
     pub fn left_later_left_wrapped() {
         let later = super::ActiveTimer {
             instant: 1u32,
             set_at: 3u32,
         };
         let earlier = super::ActiveTimer {
             instant: 2u32,
             set_at: 1u32,
         };
         assert_eq!(super::left_is_later(later, earlier), true);
     }

     #[test]
     pub fn right_later_right_wrapped() {
         let later = super::ActiveTimer {
             instant: 3u32,
             set_at: 1u32,
         };
         let earlier = super::ActiveTimer {
             instant: 1u32,
             set_at: 3u32,
         };
         assert_eq!(super::left_is_later(later, earlier), false);
     }

     #[test]
     pub fn left_later_both_wrapped() {
         let later = super::ActiveTimer {
             instant: 2u32,
             set_at: 3u32,
         };
         let earlier = super::ActiveTimer {
             instant: 1u32,
             set_at: 3u32,
         };
         assert_eq!(super::left_is_later(later, earlier), true);
     }

     #[test]
     pub fn right_later_both_wrapped() {
         let later = super::ActiveTimer {
             instant: 1u32,
             set_at: 3u32,
         };
         let earlier = super::ActiveTimer {
             instant: 2u32,
             set_at: 3u32,
         };
         assert_eq!(super::left_is_later(later, earlier), false);
     }

     #[test]
     pub fn inequality_is_strict() {
         let later = super::ActiveTimer {
             instant: 2u32,
             set_at: 1u32,
         };
         let earlier = super::ActiveTimer {
             instant: 2u32,
             set_at: 1u32,
         };
         assert_eq!(super::left_is_later(later, earlier), false);
     }

     #[test]
     pub fn inequality_is_strict_wrapped() {
         let later = super::ActiveTimer {
             instant: 1u32,
             set_at: 2u32,
         };
         let earlier = super::ActiveTimer {
             instant: 1u32,
             set_at: 2u32,
         };
         assert_eq!(super::left_is_later(later, earlier), false);
     }
 }
	//! Async timer driver. Can be used for (non-busy) sleeping.

	use crate::callback::CallbackSubscription;
	use crate::callback::Consumer;
	use crate::futures;
	use crate::result::OtherError;
	use crate::result::TockError;
	use crate::result::TockResult;
	use crate::result::EALREADY;
	use crate::syscalls;
	use core::cell::Cell;
	use core::isize;
	use core::marker::PhantomData;
	use core::ops::{Add, AddAssign, Sub};

	const DRIVER_NUMBER: usize = 0x00000;

	mod command_nr {
	pub const IS_DRIVER_AVAILABLE: usize = 0;
	pub const GET_CLOCK_FREQUENCY: usize = 1;
	pub const GET_CLOCK_VALUE: usize = 2;
	pub const STOP_ALARM: usize = 3;
	pub const SET_ALARM: usize = 4;
	}

	mod subscribe_nr {
	pub const SUBSCRIBE_CALLBACK: usize = 0;
	}

	pub struct WithCallback<'a, CB> {
	callback: CB,
	clock_frequency: ClockFrequency,
	phantom: PhantomData<&'a mut ()>,
	}

	struct TimerEventConsumer;

	impl<CB: FnMut(ClockValue, Alarm)> Consumer<WithCallback<'_, CB>> for TimerEventConsumer {
	fn consume(data: &mut WithCallback<CB>, clock_value: usize, alarm_id: usize, _: usize) {
	(data.callback)(
	ClockValue {
	num_ticks: clock_value as isize,
	clock_frequency: data.clock_frequency,
	},
	Alarm { alarm_id },
	);
	}
	}

	impl<'a, CB: FnMut(ClockValue, Alarm)> WithCallback<'a, CB> {
	pub fn init(&'a mut self) -> TockResult<Timer<'a>> {
	let num_notifications =
	syscalls::command(DRIVER_NUMBER, command_nr::IS_DRIVER_AVAILABLE, 0, 0)?;

	let clock_frequency =
	syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)?;

	if clock_frequency == 0 {
	return Err(OtherError::TimerDriverErroneousClockFrequency.into());
	}

	let clock_frequency = ClockFrequency {
	hz: clock_frequency,
	};

	let subscription = syscalls::subscribe::<TimerEventConsumer, _>(
	DRIVER_NUMBER,
	subscribe_nr::SUBSCRIBE_CALLBACK,
	self,
	)?;

	Ok(Timer {
	num_notifications,
	clock_frequency,
	subscription,
	})
	}
	}

	pub struct Timer<'a> {
	num_notifications: usize,
	clock_frequency: ClockFrequency,
	#[allow(dead_code)] // Used in drop
	subscription: CallbackSubscription<'a>,
	}

	impl<'a> Timer<'a> {
	pub fn num_notifications(&self) -> usize {
	self.num_notifications
	}

	pub fn clock_frequency(&self) -> ClockFrequency {
	self.clock_frequency
	}

	pub fn get_current_clock(&self) -> TockResult<ClockValue> {
	Ok(ClockValue {
	num_ticks: syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0)?
	as isize,
	clock_frequency: self.clock_frequency,
	})
	}

	pub fn stop_alarm(&mut self, alarm: Alarm) -> TockResult<()> {
	syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, alarm.alarm_id, 0)?;
	Ok(())
	}

	pub fn set_alarm(&mut self, duration: Duration<isize>) -> TockResult<Alarm> {
	let now = self.get_current_clock()?;
	let freq = self.clock_frequency.hz();
	let duration_ms = duration.ms() as usize;
	let ticks = match duration_ms.checked_mul(freq) {
	Some(x) => x / 1000,
	None => {
	// Divide the largest of the two operands by 1000, to improve precision of the
	// result.
	if duration_ms > freq {
	match (duration_ms / 1000).checked_mul(freq) {
	Some(y) => y,
	None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
	}
	} else {
	match (freq / 1000).checked_mul(duration_ms) {
	Some(y) => y,
	None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
	}
	}
	}
	};
	let alarm_instant = now.num_ticks() as usize + ticks;

	let alarm_id = syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, alarm_instant, 0)?;

	Ok(Alarm { alarm_id })
	}
	}

	#[derive(Copy, Clone, Debug)]
	pub struct ClockFrequency {
	hz: usize,
	}

	impl ClockFrequency {
	pub fn hz(self) -> usize {
	self.hz
	}
	}

	#[derive(Copy, Clone, Debug)]
	pub struct ClockValue {
	num_ticks: isize,
	clock_frequency: ClockFrequency,
	}

	impl ClockValue {
	pub fn num_ticks(self) -> isize {
	self.num_ticks
	}

	pub fn ms(self) -> isize {
	if self.num_ticks.abs() < isize::MAX / 1000 {
	(1000 * self.num_ticks) / self.clock_frequency.hz() as isize
	} else {
	1000 * (self.num_ticks / self.clock_frequency.hz() as isize)
	}
	}

	pub fn ms_f64(self) -> f64 {
	1000.0 * (self.num_ticks as f64) / (self.clock_frequency.hz() as f64)
	}
	}

	pub struct Alarm {
	alarm_id: usize,
	}

	impl Alarm {
	pub fn alarm_id(&self) -> usize {
	self.alarm_id
	}
	}

	#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
	pub struct Duration<T> {
	ms: T,
	}

	impl<T> Duration<T> {
	pub const fn from_ms(ms: T) -> Duration<T> {
	Duration { ms }
	}
	}

	impl<T> Duration<T>
	where
	T: Copy,
	{
	pub fn ms(&self) -> T {
	self.ms
	}
	}

	impl<T> Sub for Duration<T>
	where
	T: Sub<Output = T>,
	{
	type Output = Duration<T>;

	fn sub(self, other: Duration<T>) -> Duration<T> {
	Duration {
	ms: self.ms - other.ms,
	}
	}
	}

	#[derive(Copy, Clone, Debug)]
	pub struct Timestamp<T> {
	ms: T,
	}

	impl<T> Timestamp<T> {
	pub const fn from_ms(ms: T) -> Timestamp<T> {
	Timestamp { ms }
	}
	}

	impl<T> Timestamp<T>
	where
	T: Copy,
	{
	pub fn ms(&self) -> T {
	self.ms
	}
	}

	impl Timestamp<isize> {
	pub fn from_clock_value(value: ClockValue) -> Timestamp<isize> {
	Timestamp { ms: value.ms() }
	}
	}

	impl Timestamp<f64> {
	pub fn from_clock_value(value: ClockValue) -> Timestamp<f64> {
	Timestamp { ms: value.ms_f64() }
	}
	}

	impl<T> Sub for Timestamp<T>
	where
	T: Sub<Output = T>,
	{
	type Output = Duration<T>;

	fn sub(self, other: Timestamp<T>) -> Duration<T> {
	Duration::from_ms(self.ms - other.ms)
	}
	}

	impl<T> Add<Duration<T>> for Timestamp<T>
	where
	T: Copy + Add<Output = T>,
	{
	type Output = Timestamp<T>;

	fn add(self, duration: Duration<T>) -> Timestamp<T> {
	Timestamp {
	ms: self.ms + duration.ms(),
	}
	}
	}

	impl<T> AddAssign<Duration<T>> for Timestamp<T>
	where
	T: Copy + AddAssign,
	{
	fn add_assign(&mut self, duration: Duration<T>) {
	self.ms += duration.ms();
	}
	}

	#[derive(Copy, Clone, Default, PartialEq, Eq)]
	pub(crate) struct ActiveTimer {
	instant: u32,
	set_at: u32,
	}

	/// Context for the time driver.
	/// You can create a context as follows:
	/// ```no_run
	/// # use libtock::result::TockResult;
	/// # async fn doc() -> TockResult<()> {
	/// let mut drivers = libtock::retrieve_drivers()?;
	/// let mut timer_context = drivers.timer;
	/// # Ok(())
	/// # }
	/// ```
	#[non_exhaustive]
	pub struct DriverContext {
	pub(crate) active_timer: Cell<Option<ActiveTimer>>,
	}

	impl DriverContext {
	/// Create a driver timer from a context.
	pub fn create_timer_driver(&mut self) -> TimerDriver {
	TimerDriver {
	callback: Callback,
	context: self,
	}
	}

	pub fn with_callback<CB>(&mut self, callback: CB) -> WithCallback<CB> {
	WithCallback {
	callback,
	clock_frequency: ClockFrequency { hz: 0 },
	phantom: PhantomData,
	}
	}
	}

	/// Timer driver instance. You can create a TimerDriver from a DriverContext as follows:
	/// ```no_run
	/// # use libtock::result::TockResult;
	/// # async fn doc() -> TockResult<()> {
	/// # let mut drivers = libtock::retrieve_drivers()?;
	/// # let mut timer_context = drivers.timer;
	/// let mut timer_driver = timer_context.create_timer_driver();
	/// let timer_driver = timer_driver.activate()?;
	/// # Ok(())
	/// # }
	/// ```
	pub struct TimerDriver<'a> {
	callback: Callback,
	context: &'a DriverContext,
	}

	struct Callback;

	struct ParallelTimerConsumer;

	impl<'a> Consumer<Callback> for ParallelTimerConsumer {
	fn consume(_: &mut Callback, _: usize, _: usize, _: usize) {}
	}

	/// Activated time driver. Updates current time in the context and manages
	/// active alarms.
	/// Example usage (sleep for 1 second):
	/// ```no_run
	/// # use libtock::result::TockResult;
	/// # use libtock::timer::Duration;
	/// # async fn doc() -> TockResult<()> {
	/// # let mut drivers = libtock::retrieve_drivers()?;
	/// # let mut timer_driver = drivers.timer.create_timer_driver();
	/// let timer_driver = timer_driver.activate()?;
	/// timer_driver.sleep(Duration::from_ms(1000)).await?;
	/// # Ok(())
	/// # }
	/// ```
	pub struct ParallelSleepDriver<'a> {
	_callback_subscription: CallbackSubscription<'a>,
	context: &'a DriverContext,
	}

	impl<'a> TimerDriver<'a> {
	/// Activate the timer driver, will return a ParallelSleepDriver which
	/// can used to sleep.
	pub fn activate(&'a mut self) -> TockResult<ParallelSleepDriver<'a>> {
	let subscription = syscalls::subscribe::<ParallelTimerConsumer, _>(
	DRIVER_NUMBER,
	subscribe_nr::SUBSCRIBE_CALLBACK,
	&mut self.callback,
	)?;
	let driver = ParallelSleepDriver {
	_callback_subscription: subscription,
	context: &self.context,
	};
	Ok(driver)
	}
	}

	impl<'a> ParallelSleepDriver<'a> {
	/// Sleep for the given duration
	pub async fn sleep(&self, duration: Duration<usize>) -> TockResult<()> {
	let now = get_current_ticks()?;
	let freq = get_clock_frequency()?;
	let alarm_instant = Self::compute_alarm_instant(duration.ms, now, freq)?;
	let this_alarm = ActiveTimer {
	instant: alarm_instant as u32,
	set_at: now as u32,
	};

	let suspended_timer: Cell<Option<ActiveTimer>> = Cell::new(None);

	futures::wait_until(\|\| {
	self.activate_current_timer(this_alarm, &suspended_timer)
	.unwrap_or(false)
	})
	.await;

	Ok(())
	}

	fn activate_timer(&self, timer: ActiveTimer) -> TockResult<()> {
	set_alarm_at(timer.instant as usize)?;
	let now = get_current_ticks()?;
	if !is_over(timer, now as u32) {
	self.context.active_timer.set(Some(timer));
	} else {
	self.wakeup_soon()?;
	}
	Ok(())
	}

	fn wakeup_soon(&self) -> TockResult<()> {
	self.context.active_timer.set(None);

	for i in 0.. {
	let now = get_current_ticks()?;

	let next_timer = ActiveTimer {
	instant: now as u32 + i,
	set_at: now as u32,
	};
	set_alarm_at(next_timer.instant as usize)?;
	let now = get_current_ticks()?;
	if !is_over(next_timer, now as u32) {
	break;
	} else {
	stop_alarm_at(next_timer.instant as usize)?;
	}
	}
	Ok(())
	}

	fn compute_alarm_instant(
	duration_ms: usize,
	num_ticks: usize,
	freq: usize,
	) -> TockResult<usize> {
	let ticks = match duration_ms.checked_mul(freq) {
	Some(x) => x / 1000,
	None => {
	// Divide the largest of the two operands by 1000, to improve precision of the
	// result.
	if duration_ms > freq {
	match (duration_ms / 1000).checked_mul(freq) {
	Some(y) => y,
	None => {
	return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
	}
	}
	} else {
	match (freq / 1000).checked_mul(duration_ms) {
	Some(y) => y,
	None => {
	return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
	}
	}
	}
	}
	};
	let alarm_instant = num_ticks + ticks;
	Ok(alarm_instant)
	}

	fn activate_current_timer(
	&self,
	this_alarm: ActiveTimer,
	suspended_timer: &Cell<Option<ActiveTimer>>,
	) -> TockResult<bool> {
	let now = get_current_ticks()?;

	if let Some(active) = self.context.active_timer.get() {
	if left_is_later(active, this_alarm) {
	suspended_timer.set(Some(active));
	self.activate_timer(this_alarm)?;
	}
	} else {
	self.activate_timer(this_alarm)?;
	}
	if is_over(this_alarm, now as u32) {
	if let Some(paused) = suspended_timer.get() {
	self.activate_timer(paused)?;
	} else {
	self.context.active_timer.set(None);
	}
	Ok(true)
	} else {
	Ok(false)
	}
	}
	}

	fn get_current_ticks() -> TockResult<usize> {
	syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0).map_err(\|err\| err.into())
	}
	fn set_alarm_at(instant: usize) -> TockResult<()> {
	syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, instant, 0)
	.map(\|_\| ())
	.map_err(\|err\| err.into())
	}

	fn stop_alarm_at(instant: usize) -> TockResult<()> {
	match syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, instant, 0) {
	Ok(_) => Ok(()),
	Err(error) => match error.return_code {
	EALREADY => Ok(()),
	_ => Err(TockError::Command(error)),
	},
	}
	}

	fn get_clock_frequency() -> TockResult<usize> {
	syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)
	.map_err(\|err\| err.into())
	}

	fn is_over(timer: ActiveTimer, now: u32) -> bool {
	now.wrapping_sub(timer.set_at) >= timer.instant.wrapping_sub(timer.set_at)
	}

	fn left_is_later(alarm_1: ActiveTimer, alarm_2: ActiveTimer) -> bool {
	if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
	return alarm_1.instant > alarm_2.instant;
	}
	if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
	return false;
	}
	if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
	return true;
	}
	if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
	return alarm_1.instant > alarm_2.instant;
	}
	false
	}

	#[cfg(test)]
	mod test {
	use super::*;
	#[test]
	pub fn duration_bigger_than_frequency() {
	let x = ParallelSleepDriver::compute_alarm_instant(10000, 0, 1000)
	.ok()
	.unwrap();
	assert_eq!(x, 10000);
	}

	#[test]
	pub fn frequency_bigger_than_duration() {
	let x = ParallelSleepDriver::compute_alarm_instant(1000, 0, 10000)
	.ok()
	.unwrap();
	assert_eq!(x, 10000);
	}

	#[test]
	pub fn fails_if_duration_is_too_large() {
	let x =
	ParallelSleepDriver::compute_alarm_instant(core::usize::MAX, 0, core::usize::MAX - 1);
	assert!(x.is_err());
	}

	#[test]
	pub fn fails_if_frequency_is_too_large() {
	let x =
	ParallelSleepDriver::compute_alarm_instant(core::usize::MAX - 1, 0, core::usize::MAX);
	assert!(x.is_err());
	}

	#[test]
	pub fn alarm_before_systick_wrap_expired() {
	assert_eq!(
	super::is_over(
	super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32
	},
	3u32
	),
	true
	);
	}

	#[test]
	pub fn alarm_before_systick_wrap_not_expired() {
	assert_eq!(
	super::is_over(
	super::ActiveTimer {
	instant: 3u32,
	set_at: 1u32
	},
	2u32
	),
	false
	);
	}

	#[test]
	pub fn alarm_after_systick_wrap_expired() {
	assert_eq!(
	super::is_over(
	super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32
	},
	2u32
	),
	true
	);
	}

	#[test]
	pub fn alarm_after_systick_wrap_time_before_systick_wrap_not_expired() {
	assert_eq!(
	super::is_over(
	super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32
	},
	4u32
	),
	false
	);
	}

	#[test]
	pub fn alarm_after_systick_wrap_time_after_systick_wrap_not_expired() {
	assert_eq!(
	super::is_over(
	super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32
	},
	0u32
	),
	false
	);
	}

	#[test]
	pub fn left_later_than_the_other_both_not_wrapped() {
	let later = super::ActiveTimer {
	instant: 3u32,
	set_at: 1u32,
	};
	let earlier = super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32,
	};
	assert_eq!(super::left_is_later(later, earlier), true);
	}

	#[test]
	pub fn right_later_than_the_other_both_not_wrapped() {
	let later = super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32,
	};
	let earlier = super::ActiveTimer {
	instant: 3u32,
	set_at: 1u32,
	};
	assert_eq!(super::left_is_later(later, earlier), false);
	}

	#[test]
	pub fn left_later_left_wrapped() {
	let later = super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32,
	};
	let earlier = super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32,
	};
	assert_eq!(super::left_is_later(later, earlier), true);
	}

	#[test]
	pub fn right_later_right_wrapped() {
	let later = super::ActiveTimer {
	instant: 3u32,
	set_at: 1u32,
	};
	let earlier = super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32,
	};
	assert_eq!(super::left_is_later(later, earlier), false);
	}

	#[test]
	pub fn left_later_both_wrapped() {
	let later = super::ActiveTimer {
	instant: 2u32,
	set_at: 3u32,
	};
	let earlier = super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32,
	};
	assert_eq!(super::left_is_later(later, earlier), true);
	}

	#[test]
	pub fn right_later_both_wrapped() {
	let later = super::ActiveTimer {
	instant: 1u32,
	set_at: 3u32,
	};
	let earlier = super::ActiveTimer {
	instant: 2u32,
	set_at: 3u32,
	};
	assert_eq!(super::left_is_later(later, earlier), false);
	}

	#[test]
	pub fn inequality_is_strict() {
	let later = super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32,
	};
	let earlier = super::ActiveTimer {
	instant: 2u32,
	set_at: 1u32,
	};
	assert_eq!(super::left_is_later(later, earlier), false);
	}

	#[test]
	pub fn inequality_is_strict_wrapped() {
	let later = super::ActiveTimer {
	instant: 1u32,
	set_at: 2u32,
	};
	let earlier = super::ActiveTimer {
	instant: 1u32,
	set_at: 2u32,
	};
	assert_eq!(super::left_is_later(later, earlier), false);
	}
	}