use std::sync::Arc;
use std::time::Duration;
use std::time::Instant;
use sync::Mutex;
use super::Event;
use super::EventWaitResult;
use super::FakeClock;
use super::RawDescriptor;
use super::Result;
use crate::descriptor::AsRawDescriptor;
use crate::descriptor::FromRawDescriptor;
use crate::descriptor::IntoRawDescriptor;
use crate::descriptor::SafeDescriptor;
pub trait TimerTrait: AsRawDescriptor + IntoRawDescriptor + Send {
fn reset(&mut self, dur: Duration, interval: Option<Duration>) -> Result<()>;
fn wait(&mut self) -> Result<()>;
fn mark_waited(&mut self) -> Result<bool>;
fn clear(&mut self) -> Result<()>;
fn resolution(&self) -> Result<Duration>;
}
pub struct Timer {
pub(crate) handle: SafeDescriptor,
pub(crate) interval: Option<Duration>,
}
impl Timer {
pub fn try_clone(&self) -> std::result::Result<Timer, std::io::Error> {
self.handle
.try_clone()
.map(|handle| Timer {
handle,
interval: self.interval,
})
.map_err(|err| std::io::Error::from_raw_os_error(err.errno()))
}
}
#[derive(PartialEq, Eq, Debug)]
enum WaitResult {
Expired,
Timeout,
}
impl AsRawDescriptor for Timer {
fn as_raw_descriptor(&self) -> RawDescriptor {
self.handle.as_raw_descriptor()
}
}
impl FromRawDescriptor for Timer {
unsafe fn from_raw_descriptor(handle: RawDescriptor) -> Self {
Timer {
handle: SafeDescriptor::from_raw_descriptor(handle),
interval: None,
}
}
}
impl IntoRawDescriptor for Timer {
fn into_raw_descriptor(self) -> RawDescriptor {
self.handle.into_raw_descriptor()
}
}
pub struct FakeTimer {
clock: Arc<Mutex<FakeClock>>,
deadline_ns: Option<u64>,
interval: Option<Duration>,
event: Event,
}
impl FakeTimer {
pub fn new(clock: Arc<Mutex<FakeClock>>) -> Self {
FakeTimer {
clock,
deadline_ns: None,
interval: None,
event: Event::new().unwrap(),
}
}
fn wait_for(&mut self, timeout: Option<Duration>) -> Result<WaitResult> {
let wait_start = Instant::now();
loop {
if let Some(timeout) = timeout {
let elapsed = Instant::now() - wait_start;
if let Some(remaining) = elapsed.checked_sub(timeout) {
if let EventWaitResult::TimedOut = self.event.wait_timeout(remaining)? {
return Ok(WaitResult::Timeout);
}
} else {
return Ok(WaitResult::Timeout);
}
} else {
self.event.wait()?;
}
if let Some(deadline_ns) = &mut self.deadline_ns {
let mut guard = self.clock.lock();
let now = guard.nanos();
if now >= *deadline_ns {
let mut expirys = 0;
if let Some(interval) = self.interval {
let interval_ns = interval.as_nanos() as u64;
if interval_ns > 0 {
expirys += (now - *deadline_ns) / interval_ns;
*deadline_ns += (expirys + 1) * interval_ns;
guard.add_event(*deadline_ns, self.event.try_clone()?);
}
}
return Ok(WaitResult::Expired);
}
}
}
}
}
impl TimerTrait for FakeTimer {
fn reset(&mut self, dur: Duration, interval: Option<Duration>) -> Result<()> {
let mut guard = self.clock.lock();
let deadline = guard.nanos() + dur.as_nanos() as u64;
self.deadline_ns = Some(deadline);
self.interval = interval;
guard.add_event(deadline, self.event.try_clone()?);
Ok(())
}
fn wait(&mut self) -> Result<()> {
self.wait_for(None).map(|_| ())
}
fn mark_waited(&mut self) -> Result<bool> {
if let WaitResult::Timeout = self.wait_for(Some(Duration::from_secs(0)))? {
Ok(true)
} else {
Ok(false)
}
}
fn clear(&mut self) -> Result<()> {
self.deadline_ns = None;
self.interval = None;
Ok(())
}
fn resolution(&self) -> Result<Duration> {
Ok(Duration::from_nanos(1))
}
}
impl AsRawDescriptor for FakeTimer {
fn as_raw_descriptor(&self) -> RawDescriptor {
self.event.as_raw_descriptor()
}
}
impl IntoRawDescriptor for FakeTimer {
fn into_raw_descriptor(self) -> RawDescriptor {
self.event.into_raw_descriptor()
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use std::time::Instant;
use super::*;
fn get_clock_error() -> Duration {
Timer::new()
.unwrap()
.resolution()
.expect("expected to be able to read timer resolution")
.checked_mul(2)
.expect("timer resolution x 2 should not overflow")
.checked_add(Duration::from_micros(100))
.expect("timer resolution x 2 + 100 microsecond should not overflow")
}
#[test]
#[ignore]
fn one_shot() {
let mut tfd = Timer::new().expect("failed to create Timer");
let dur = Duration::from_millis(1000);
let clock_error = get_clock_error();
let now = Instant::now();
tfd.reset(dur, None).expect("failed to arm timer");
tfd.wait().expect("unable to wait for timer");
let elapsed = now.elapsed();
assert!(
elapsed - clock_error <= dur,
"expected {:?} - {:?} <= {:?}",
elapsed,
clock_error,
dur
);
assert!(
elapsed + clock_error >= dur,
"expected {:?} + {:?} >= {:?}",
elapsed,
clock_error,
dur
);
}
#[test]
#[ignore]
fn one_shot_cloned() {
let mut tfd = Timer::new().expect("failed to create Timer");
let dur = Duration::from_millis(1000);
let mut cloned_tfd = tfd.try_clone().expect("failed to clone timer");
let clock_error = get_clock_error();
let now = Instant::now();
tfd.reset(dur, None).expect("failed to arm timer");
cloned_tfd.wait().expect("unable to wait for timer");
let elapsed = now.elapsed();
assert!(
elapsed - clock_error <= dur,
"expected {:?} - {:?} <= {:?}",
elapsed,
clock_error,
dur
);
assert!(
elapsed + clock_error >= dur,
"expected {:?} + {:?} >= {:?}",
elapsed,
clock_error,
dur
);
}
#[test]
#[ignore]
fn repeating() {
let mut tfd = Timer::new().expect("failed to create Timer");
let dur = Duration::from_millis(200);
let clock_error = Timer::new()
.unwrap()
.resolution()
.expect("expected to be able to read timer resolution")
.checked_mul(2)
.expect("timer resolution x 2 should not overflow")
.checked_add(Duration::from_micros(100))
.expect("timer resolution x 2 + 100 microsecond should not overflow");
let interval = Duration::from_millis(100);
let now = Instant::now();
tfd.reset(dur, Some(interval)).expect("failed to arm timer");
tfd.wait().expect("unable to wait for timer");
assert!(now.elapsed() + clock_error >= dur);
tfd.wait().expect("unable to wait for timer");
assert!(now.elapsed() + clock_error >= dur + interval);
tfd.wait().expect("unable to wait for timer");
assert!(now.elapsed() + clock_error >= dur + interval * 2);
}
#[test]
fn fake_one_shot() {
let clock = Arc::new(Mutex::new(FakeClock::new()));
let mut tfd = FakeTimer::new(clock.clone());
let dur = Duration::from_nanos(200);
tfd.reset(dur, None).expect("failed to arm timer");
clock.lock().add_ns(200);
assert_eq!(tfd.wait().is_ok(), true);
}
#[test]
fn fake_one_shot_timeout() {
let clock = Arc::new(Mutex::new(FakeClock::new()));
let mut tfd = FakeTimer::new(clock.clone());
let dur = Duration::from_nanos(200);
tfd.reset(dur, None).expect("failed to arm timer");
clock.lock().add_ns(100);
let result = tfd
.wait_for(Some(Duration::from_millis(0)))
.expect("unable to wait for timer");
assert_eq!(result, WaitResult::Timeout);
let result = tfd
.wait_for(Some(Duration::from_millis(1)))
.expect("unable to wait for timer");
assert_eq!(result, WaitResult::Timeout);
clock.lock().add_ns(100);
let result = tfd
.wait_for(Some(Duration::from_millis(0)))
.expect("unable to wait for timer");
assert_eq!(result, WaitResult::Expired);
}
#[test]
fn fake_repeating() {
let clock = Arc::new(Mutex::new(FakeClock::new()));
let mut tfd = FakeTimer::new(clock.clone());
let dur = Duration::from_nanos(200);
let interval = Duration::from_nanos(100);
tfd.reset(dur, Some(interval)).expect("failed to arm timer");
clock.lock().add_ns(300);
assert_eq!(tfd.wait().is_ok(), true);
clock.lock().add_ns(300);
assert_eq!(tfd.wait().is_ok(), true);
}
}