ztimer 0.1.2

// Copyright 2024 Lorby Bi
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! ztimer,where z stands for zero-overhead, provides an implementation of a near O(1) timer. It operates under the assumption that, in normal application usage, the number of timer expirations across different scenarios is typically limited. Therefore, there's no need to support a huge number of different expires.
//!
//! # Concept
//!
//! The main concepts introduced in ztimer are `AutoDropTimer`, `Timer`, and `Clock`.
//!
//! - An instance of `Timer` held in the application is an indirect reference to the real timer instance stored in the `Clock`. It holds a callback provided by the application, which will be invoked after a specified duration. A `Timer` instance can be canceled before it expires.
//!
//! - If a `Timer` instance is not canceled by the application but instead is dropped before expiring, nothing will happen. The `Clock` will still call the callback when the underlying timer instance expires. The application needs to handle this case correctly.
//!
//! - `AutoDropTimer` is a wrapper of `Timer` with an additional benefit: when the `AutoDropTimer` instance is dropped, it automatically cancels the underlying timer if it is not expired, preventing further callback invocations.
//!
//! - The `Clock` class is used to group timers. An instance of `Clock` can hold multiple or even all the timers within one process. The number of clocks in one process follows these restrictions:
//!   1. At least one clock instance is required.
//!   2. Up to CPUs multiplied by 4 for collocated clocks.
//!   3. For non-collocated clocks, application can create as many as it wants, the library will return new or reused clock instances accordingly, it is transparent to the application.
//!
//! Application shall create at least one `Clock` instance before using the timer. A suggestion is to allocate several clocks based on functional groups.

//! # Example of use AutoDropTimer:
//! ```
//! use std::thread::sleep;
//! use std::time::Duration;
//! use ztimer::{AutoDropTimer, Clock} ;// Only one of AutoDropTimer or Timer is needed in general
//! let clock = Clock::new(None).unwrap(); // One process can have one or a few number of clock instances
//! let t1 = AutoDropTimer::new(clock, Duration::from_secs(1), ||{println!("T1 expired");}, "t1".to_string()).unwrap();
//! let t2 = AutoDropTimer::new(clock, Duration::from_secs(10), ||{println!("T2 expired");}, "t2".to_string()).unwrap();
//! let mut t3 = AutoDropTimer::new(clock, Duration::from_secs(10), ||{println!("T3 expired");}, "t2".to_string()).unwrap();
//! assert_eq!(clock.len(), 3);
//! sleep(Duration::from_secs(2));// T1 expired
//! assert_eq!(clock.len(), 2);
//! {
//!     let _t4 = t2;
//! }
//! // The timer t2 is moved to _t4, then dropped automatically without invoking timeout function.
//! assert_eq!(clock.len(), 1);
//! t3.cancel().unwrap();
//! assert_eq!(clock.len(), 0);
//! ```
//! If an application needs to wait for the underlying timer thread before terminate the process, here is
//! what the application shall execute
//! #Example of waiting for underlying timer thread
//! ```
//! use ztimer::Clock;
//! let _ = Clock::new(None);
//! //Before terminating:
//! let tjh = Clock::take_thread_handle();
//! Clock::terminate_for_process_exit();
//! let _ = tjh.unwrap().join();
//! ```
//!
#![allow(dead_code)] // Allow dead code to avoid warnings on the code for testing purpose

use std::time::Duration;
pub mod error;
mod inner;
use anyhow::Result as AnyResult;
pub use error::MyError;
pub use inner::Tick;
pub(self) use inner::{timer, ClockPtr};
use std::thread::JoinHandle;

#[cfg(test)]
use std::sync::Mutex;
/// NonBlockTickBridge: a call back to pass the Tick to the instance of clock. Application must provide one when colocated_timer is enabled
/// At the end, normally it's the receiving portion of application thread, application needs to call Clock::on_tick() to transfer the
/// Tick event.
/// As indicated by the name, the function for TickBridge CANNOT have any blocking operations.
///
/// # Examples
///
/// ```
/// use std::thread::{self, JoinHandle, sleep};
/// use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
/// use std::time::Duration;
/// use log::warn;
/// use ztimer::{AutoDropTimer, Clock, Tick, Timer};
///
/// enum AppMessage {
///     MsgTick(Clock, Tick),
///     Terminate,
/// }
///
/// let mut app_threads = Vec::<JoinHandle<()>>::new();
/// let mut txes = Vec::<crossbeam_channel::Sender<AppMessage>>::new();
/// let count = Arc::new(AtomicUsize::new(0));
/// let (tx, rx) = crossbeam_channel::bounded::<AppMessage>(1000);
///
/// // The application thread is a long-lived thread that processes `AppMessage`s.
/// let th = thread::Builder::new().name("AppThread".to_string()).spawn(move || {
///     while let Ok(m) = rx.recv() {
///         match m {
///             AppMessage::MsgTick(c, t) => {
///                 c.on_tick(t);
///             },
///             AppMessage::Terminate => {
///                 return;
///             },
///         }
///     }
/// }).unwrap();
/// app_threads.push(th);
/// txes.push(tx.clone());
///
/// let cnt = count.clone();
///
/// // A non-blocking closure as a TickBridge
/// let tb = move |c: Clock, t: Tick| {
///     cnt.fetch_add(1, Ordering::Relaxed);
///     let _ = tx.try_send(AppMessage::MsgTick(c, t));
/// };
/// let clk = Clock::new(Some(Box::new(tb))).unwrap();
///
/// let _ = Timer::new(clk, Duration::from_secs(1), || { println!("Timer expired") }, "TestTimer".into());
///
/// sleep(Duration::from_secs(2));
///
/// for tx in txes.iter() {
///     let _ = tx.send(AppMessage::Terminate);
/// }
/// assert!(count.load(Ordering::Relaxed) > 0);
/// for h in app_threads {
///     h.join().unwrap();
/// }
/// ```
pub type NonBlockTickBridge = dyn Fn(Clock, Tick) + Send + Sync;

// The required trait for the callback function when timer is triggered.

pub struct Timer(timer::Timer);
impl Timer {
    /// Creates a new `Timer` instance on the specified `Clock`.
    ///
    /// # Arguments
    ///
    /// * `clk`: The clock instance which the timer is being created on.
    /// * `duration`: Specifies the expiration duration of the timer.
    /// * `f`: Callback function invoked after the timer expires.
    /// * `name`: Name of the timer, used for logging purposes.
    ///
    /// # Returns
    ///
    /// Returns `Ok(Timer)` if successful, or an error if creation fails.

    pub fn new<F>(clk: Clock, duration: Duration, f: F, name: String) -> AnyResult<Self>
    where
        F: FnOnce() + Send + Sync + 'static,
    {
        inner::Clock::new_timer(clk.0, duration, f, name).map(|t| Timer(t))
    }

    /// Cancels the specified `Timer` instance.
    ///
    /// # Arguments
    ///
    /// * `t`: The `Timer` instance to cancel.
    ///
    /// # Returns
    ///
    /// Returns `Ok(())` if successful, or an error if cancellation fails.
    pub fn cancel(&mut self) -> AnyResult<()> {
        self.0.cancel()
    }
}
pub struct AutoDropTimer(timer::AutoDropTimer);
impl AutoDropTimer {
    /// Takes over the underlying timer and returns an instance of `AutoDropTimer`, encapsulating the `Timer`.
    ///
    /// After calling this function, the timer `t` is moved into the `AutoDropTimer`.
    ///
    /// # Parameters
    ///
    /// * `t`: The timer instance to be encapsulated.
    ///
    /// # Returns
    ///
    /// Returns the `AutoDropTimer` instance.
    pub fn from_timer(t: Timer) -> Self {
        Self(timer::AutoDropTimer::from_timer(t.0))
    }

    /// Creates an instance of `AutoDropTimer` on the clock indicated by the `clk` parameter.
    ///
    /// # Arguments
    ///
    /// * `clk`: The clock instance on which to create the timer.
    /// * `duration`: Specifies the expiration duration of the timer.
    /// * `f`: Callback function invoked after the timer expires.
    /// * `name`: Name of the timer, used for logging purposes.
    ///
    /// # Returns
    ///
    /// Returns `Ok(AutoDropTimer)` if successful, or an error if creation fails.
    pub fn new<F>(clk: Clock, duration: Duration, f: F, name: String) -> AnyResult<Self>
    where
        F: FnOnce() + Send + Sync + 'static,
    {
        Timer::new(clk, duration, f, name).map(|t| Self::from_timer(t))
    }

    /// Cancels the timer before it expires.
    ///
    /// Returns `Ok(())` if it is successfully canceled, or an error if the timer has already expired.
    /// Applications should handle the race condition where a timer may expire after `cancel` is invoked.
    ///
    /// # Returns
    ///
    /// Returns `Ok(())` if the timer is successfully canceled, or an error otherwise.
    pub fn cancel(&mut self) -> AnyResult<()> {
        self.0.cancel()
    }

    /// Extracts the `Timer` from the `AutoDropTimer`.
    ///
    /// Applications need to handle canceling the timer when the `Timer` instance is dropped
    /// after calling this function.
    ///
    /// # Returns
    ///
    /// Returns the `Timer` if it exists, or `None` if it has been canceled.
    pub fn take(&mut self) -> Option<Timer> {
        self.0.take().map(|t| Timer(t))
    }

    /// Informs the `AutoDropTimer` to perform cleanup when the timer expires.
    ///
    /// This function is primarily for performance considerations; functionally, it does not affect whether
    /// calling it or not on expiry.
    pub fn expired(&mut self) {
        let _ = self.0.take();
    }
}
#[derive(Clone, Copy)]
pub struct Clock(ClockPtr);
impl Clock {
    /// Creates a new `Clock` instance collocated with application thread.
    /// It is recommended to create collocated Clock for message-based applications,
    /// especially when each application instance is anchored to a dedicated thread.
    /// This ensures that the clock is synchronized with the application thread,
    /// allowing all relevant timers to be handled within the same thread for optimal performance.
    ///
    /// Panics if too many instances are created.
    /// The instance will persist until the process is closed.
    /// Implements the `Copy` trait, maintaining only one real instance.
    /// # Arguments
    ///
    /// * `tb`: Tick bridge, a proxy to pass the tick to the clock instance when the clock is collocated
    /// with application thread, otherwise, None.
    ///
    /// # Returns
    ///
    /// The newly created `Clock` instance.
    pub fn new(tb: Option<Box<NonBlockTickBridge>>) -> Option<Self> {
        inner::Clock::new(tb).map(|c| Self(c))
    }

    /// Takes the thread handle of the Timer module for graceful shutdown.
    ///
    /// # Returns
    ///
    /// The thread handle for the Timer module shutdown.
    pub fn take_thread_handle() -> Option<JoinHandle<()>> {
        inner::ticker::Ticker::take_join_handle()
    }

    /// Terminates the Timer module.
    pub fn terminate_for_process_exit() {
        inner::ticker::Ticker::terminate();
    }

    /// In case of clock instance is collocated with application thread, at the end of
    /// the path of relaying Tick, the application shall invoke clock.on_tick() to send
    /// the event to relevant instance. See the sample for TickBridge.
    pub fn on_tick(self, tick: Tick) -> AnyResult<()> {
        inner::Clock::on_tick(self.0, tick)
    }
    /// Retrieves the number of timer instances residing on the `Clock`.
    ///
    /// # Returns
    ///
    /// The count of timer instances.
    pub fn len(self) -> isize {
        inner::Clock::clock_len(self.0)
    }

    /// Retrieves the current tick of the `Clock`.
    ///
    /// # Returns
    ///
    /// The current tick.
    pub fn now(self) -> u64 {
        inner::Clock::now(self.0).to_u64()
    }
    #[cfg(test)]
    /// Retrieves the inner address of the `Clock` instance.
    pub fn inner_address(self) -> *const usize {
        self.0.get_ref() as *const Mutex<inner::Clock> as *const usize
    }
}

#[cfg(all(test, not(feature = "mock_clock")))]

mod test {
    use super::*;
    extern crate env_logger;
    use env_logger::{Builder, Env};

    use log::{trace, warn};
    use std::sync::atomic::AtomicIsize;
    use std::sync::{
        atomic::{AtomicUsize, Ordering},
        Arc, Condvar, LazyLock, Mutex, Once,
    };
    use std::thread::{self, sleep, JoinHandle};
    use std::time::{Duration, Instant};
    use taskchain::{CondvarPair, Kinds, Signal, TaskChain};

    static INIT: Once = Once::new();
    static mut SEQ: AtomicUsize = AtomicUsize::new(1);
    static SEQUENTIAL: LazyLock<Arc<CondvarPair>> =
        LazyLock::new(|| Arc::new(CondvarPair::new(Signal::TRIGGER(Kinds::ANY))));

    const EXPIRES: [Duration; 5] = [
        Duration::from_millis(100),
        Duration::from_millis(300),
        Duration::from_secs(1),
        Duration::from_secs(5),
        Duration::from_secs(10),
    ];

    fn initialize() {
        INIT.call_once(|| {
            let _ = Builder::from_env(Env::default().default_filter_or("warn")).try_init();
        });
    }
    fn single_timer_cancel(clk: Clock, duration: Duration, vec: &mut Vec<JoinHandle<()>>) {
        let name = format!("TimerForCancel-{:?}", unsafe {
            SEQ.fetch_add(1, Ordering::Relaxed)
        })
        .to_string();
        let n2 = name.clone();
        let count = Arc::new(AtomicUsize::new(0));
        let local = count.clone();
        let cv1 = Arc::new((Mutex::new(false), Condvar::new()));
        let cv2 = cv1.clone();
        let mut timer = Timer::new(
            clk,
            duration,
            move || {
                count.fetch_add(1, Ordering::SeqCst);
            },
            name,
        )
        .expect("Failed to create timer");
        let verification = thread::Builder::new()
            .name(n2)
            .spawn(move || {
                let (lock, cv) = &*cv1;
                let mut go = lock.lock().unwrap();
                while !*go {
                    go = cv.wait(go).unwrap();
                }
                sleep(duration - Duration::from_millis(100));
                assert_eq!(local.load(Ordering::SeqCst), 0);
                let r = timer.cancel();
                assert!(r.is_ok());
                sleep(Duration::from_secs(1));
                assert_eq!(local.load(Ordering::SeqCst), 0); // No time out
            })
            .unwrap();

        {
            let (lock, cv) = &*cv2;
            *lock.lock().unwrap() = true;
            cv.notify_all();
        }
        vec.push(verification);
    }

    fn single_timer_drop(clk: Clock, duration: Duration, vec: &mut Vec<JoinHandle<()>>) {
        let name = format!("TimerForDrop-{:?}", unsafe {
            SEQ.fetch_add(1, Ordering::Relaxed)
        })
        .to_string();
        let n2 = name.clone();
        let count = Arc::new(AtomicUsize::new(0));
        let local = count.clone();
        let cv1 = Arc::new((Mutex::new(false), Condvar::new()));
        let cv2 = cv1.clone();
        let timer = Timer::new(
            clk,
            duration,
            move || {
                count.fetch_add(1, Ordering::SeqCst);
            },
            name,
        )
        .expect("Failed to create timer");
        let verification = thread::Builder::new()
            .name(n2)
            .spawn(move || {
                let (lock, cv) = &*cv1;
                let mut go = lock.lock().unwrap();
                while !*go {
                    go = cv.wait(go).unwrap();
                }
                let _ = AutoDropTimer::from_timer(timer);
                {
                    sleep(duration - Duration::from_millis(100));
                    assert_eq!(local.load(Ordering::SeqCst), 0);
                }
                sleep(Duration::from_secs(1));
                assert_eq!(local.load(Ordering::SeqCst), 0); // No time out
            })
            .unwrap();

        {
            let (lock, cv) = &*cv2;
            *lock.lock().unwrap() = true;
            cv.notify_all();
        }
        vec.push(verification);
    }

    fn single_timer_timeout(clk: Clock, duration: Duration, vec: &mut Vec<JoinHandle<()>>) {
        let name = format!("TimerForExpire-{:?}", unsafe {
            SEQ.fetch_add(1, Ordering::Relaxed)
        })
        .to_string();
        let n2 = name.clone();
        let count = Arc::new(AtomicUsize::new(0));
        let local = count.clone();
        let cv1 = Arc::new((Mutex::new(false), Condvar::new()));
        let cv2 = cv1.clone();

        let verification = thread::Builder::new()
            .name(n2)
            .spawn(move || {
                let (lock, cv) = &*cv1;
                let mut go = lock.lock().unwrap();
                while !*go {
                    go = cv.wait(go).unwrap();
                }

                let now = Instant::now();
                sleep(duration + Duration::from_millis(100));
                let elapsed = now.elapsed();
                //assert_eq!(local.load(Ordering::SeqCst), 1);
                if local.load(Ordering::SeqCst) == 0 {
                    warn!(
                        "timer of {:?} not triggered in {:?}, num of timers:{}",
                        duration,
                        elapsed,
                        clk.len()
                    );
                    //assert!(clk.cancel_timer(timer).is_ok());
                }
            })
            .unwrap();

        thread::spawn(move || {
            Timer::new(
                clk,
                duration,
                move || {
                    count.fetch_add(1, Ordering::SeqCst);
                },
                name,
            )
            .expect("Failed to create timer");
            {
                let (lock, cv) = &*cv2;
                *lock.lock().unwrap() = true;
                cv.notify_all();
            }

            sleep(Duration::from_secs(1));
        });
        vec.push(verification);
    }
    fn run_tests(
        n_clock: usize,
        repeat: usize,
        num_exp: usize,
        fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>>,
    ) {
        let mut vec = Vec::<JoinHandle<()>>::new();
        for _ in 0..n_clock {
            if let Some(clk) = Clock::new(None) {
                for duration in EXPIRES[0..num_exp].iter() {
                    for _ in 0..repeat {
                        for f in &fns {
                            f(clk, *duration, &mut vec);
                        }
                    }
                    sleep(Duration::from_secs(1));
                }
            } else {
                break;
            }
        }
        for h in vec {
            trace!("joining {:?}", h);
            h.join().unwrap();
        }
    }
    //impl dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()> for single_timer_timeout {}
    #[test]
    fn test_time_out() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();
        // Sleep for 2 seconds to allow the ticker to calibrate.
        warn!("Application started");
        let num_exp = EXPIRES.len();
        let repeat: usize = 10;
        warn!("Repeat {} times", repeat);
        let mut fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>> = Vec::new();
        fns.push(Box::new(single_timer_timeout));
        run_tests(10, repeat, num_exp, fns);
    }
    #[test]
    fn test_cancel() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();
        warn!("Application started");
        let num_exp = EXPIRES.len();
        let repeat = 10;
        warn!("Repeat {} times", repeat);
        let mut fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>> = Vec::new();
        fns.push(Box::new(single_timer_cancel));
        run_tests(10, repeat, num_exp, fns);
    }

    #[test]
    fn test_drop() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();

        // Sleep for 2 seconds to allow the ticker to calibrate.
        warn!("Application started");
        let num_exp = EXPIRES.len();
        let repeat: usize = 10;
        warn!("Repeat {} times", repeat);
        let mut fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>> = Vec::new();
        fns.push(Box::new(single_timer_drop));
        run_tests(10, repeat, num_exp, fns);
    }

    #[test]
    fn test_combination() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();

        // Sleep for 2 seconds to allow the ticker to calibrate.
        warn!("Application started");
        let num_exp = EXPIRES.len();
        let repeat: usize = 10;
        warn!("Repeat {} times", repeat);
        let mut fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>> = Vec::new();
        fns.push(Box::new(single_timer_timeout));
        fns.push(Box::new(single_timer_cancel));
        fns.push(Box::new(single_timer_drop));
        run_tests(10, repeat, num_exp, fns);
    }

    enum AppMessage {
        Tick(Clock, Tick),
        Terminate,
    }
    fn run_tests_with_collocated_clock(
        n_clock: usize,
        repeat: usize,
        num_exp: usize,
        fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>>,
    ) {
        let mut vec = Vec::<JoinHandle<()>>::new();
        let mut app_threads = Vec::<JoinHandle<()>>::new();
        let mut txes = Vec::<crossbeam_channel::Sender<AppMessage>>::new();
        let count = Arc::new(AtomicUsize::new(0));
        for i in 0..n_clock {
            let (tx, rx) = crossbeam_channel::bounded::<AppMessage>(1000);
            let th = thread::Builder::new()
                .name("Thread".to_string() + i.to_string().as_str())
                .spawn(move || {
                    while let Ok(m) = rx.recv() {
                        match m {
                            AppMessage::Tick(c, t) => {
                                let _ = c.on_tick(t);
                            }
                            AppMessage::Terminate => {
                                return;
                            }
                        }
                    }
                })
                .unwrap();
            app_threads.push(th);
            txes.push(tx.clone());
            let count = count.clone();
            let tb = move |c: Clock, t: Tick| {
                count.fetch_add(1, Ordering::Relaxed);
                let _ = tx.try_send(AppMessage::Tick(c, t));
            };

            if let Some(clk) = Clock::new(Some(Box::new(tb))) {
                for duration in EXPIRES[0..num_exp].iter() {
                    for _ in 0..repeat {
                        for f in &fns {
                            f(clk, *duration, &mut vec);
                        }
                    }
                    sleep(Duration::from_secs(1));
                }
            } else {
                break;
            }
        }
        for h in vec {
            trace!("joining {:?}", h);
            h.join().unwrap();
        }
        for tx in txes.iter() {
            let _ = tx.send(AppMessage::Terminate);
        }
        assert!(count.load(Ordering::Relaxed) > 0);
        for h in app_threads {
            h.join().unwrap();
        }
    }

    #[test]
    fn test_combination_collocated() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();

        // Sleep for 2 seconds to allow the ticker to calibrate.
        warn!("Application started");
        let num_exp = EXPIRES.len();
        let repeat: usize = 10;
        warn!("Repeat {} times", repeat);
        let mut fns: Vec<Box<dyn Fn(Clock, Duration, &mut Vec<JoinHandle<()>>)>> = Vec::new();
        fns.push(Box::new(single_timer_timeout));
        fns.push(Box::new(single_timer_cancel));
        fns.push(Box::new(single_timer_drop));
        run_tests_with_collocated_clock(10, repeat, num_exp, fns);
    }

    fn cycle_for_precision(
        clk: Clock,
        duration: Duration,
        repeat: i32,
        count: Arc<AtomicIsize>,
        errors: Arc<Mutex<Vec<isize>>>,
        jhs: &mut Mutex<Vec<JoinHandle<()>>>,
    ) {
        let jh = thread::spawn(move || {
            thread::scope(|s| {
                thread::Builder::new()
                    .name(format!("ThreadAddingExpire-{}", unsafe {
                        SEQ.fetch_add(1, Ordering::Relaxed)
                    }))
                    .spawn_scoped(s, || {
                        for _ in 0..repeat {
                            let errors = errors.clone();
                            let count = count.clone();
                            let name = format!("TimerForExpire-{:?}", unsafe {
                                SEQ.fetch_add(1, Ordering::Relaxed)
                            })
                            .to_string();
                            let now = Instant::now();
                            count.fetch_add(1, Ordering::AcqRel);

                            Timer::new(
                                clk,
                                duration,
                                move || {
                                    errors.lock().unwrap().push(
                                        now.elapsed().as_micros() as isize
                                            - duration.as_micros() as isize,
                                    );
                                    count.fetch_sub(1, Ordering::AcqRel);
                                },
                                name,
                            )
                            .expect("Failed to create timer");
                        }
                    })
                    .unwrap();
            })
        });
        jhs.lock().unwrap().push(jh);
    }

    #[test]
    fn test_precision() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();
        let num_of_clock = 8;
        let num_of_thread_group = 2;
        let repeat = 2;

        let count = Arc::new(AtomicIsize::new(0));
        let errors = Arc::new(Mutex::new(Vec::<isize>::new()));
        let mut jhs = Mutex::new(Vec::<JoinHandle<()>>::new());

        for _ in 0..num_of_clock {
            if let Some(clk) = Clock::new(None) {
                for _ in 0..num_of_thread_group {
                    for d in EXPIRES {
                        cycle_for_precision(
                            clk,
                            d,
                            repeat,
                            count.clone(),
                            errors.clone(),
                            &mut jhs,
                        );
                    }
                }
            } else {
                break;
            }
        }

        loop {
            sleep(Duration::from_secs(5));
            let c = count.load(Ordering::Acquire);
            if c == 0 {
                break;
            }
        }

        let lock = errors.lock().unwrap();
        let errors = &*lock;
        let s: usize = errors.iter().map(|&x| (x) * (x)).sum::<isize>() as usize;
        let std = s / (errors.len() as usize);
        let mean = errors.iter().sum::<isize>() / (errors.len() as isize);
        let min = *errors.iter().min().unwrap();
        let max = *errors.iter().max().unwrap();
        drop(lock);

        warn!(
            "Derivations: std:{}ms, mean:{}ms, min:{}ms, max:{}ms",
            (std as f64).sqrt() as usize / 1000,
            mean / 1000,
            min / 1000,
            max / 1000
        );
    }

    #[test]
    fn test_autodrop_timer() {
        let mut pl = TaskChain::new(
            Arc::clone(&SEQUENTIAL),
            Kinds::ANY,
            Signal::TRIGGER(Kinds::ANY),
        );
        pl.wait(Duration::ZERO);

        initialize();
        let clk = Clock::new(None).unwrap();

        // New and timeout
        let _adt = AutoDropTimer::new(clk, EXPIRES[0], || {}, "test".to_string()).unwrap();
        assert_eq!(clk.len(), 1);
        sleep(EXPIRES[0] + Duration::from_millis(100));
        assert_eq!(clk.len(), 0);
        // Drop
        {
            let _adt = AutoDropTimer::new(clk, EXPIRES[1], || {}, "test".to_string()).unwrap();
            assert_eq!(clk.len(), 1);
        }
        assert_eq!(clk.len(), 0);
        // Cancel
        let mut adt = AutoDropTimer::new(clk, EXPIRES[0], || {}, "test".to_string()).unwrap();
        assert_eq!(clk.len(), 1);
        adt.cancel().unwrap();
        assert_eq!(clk.len(), 0);

        // Take
        // Drop
        {
            let mut adt =
                AutoDropTimer::new(clk, Duration::from_secs(1000), || {}, "test".to_string())
                    .unwrap();
            assert_eq!(clk.len(), 1);
            let _t = adt.take().unwrap();
            let _ = adt.cancel();
        }
        assert_eq!(clk.len(), 1);

        // Cancel multiple times
        {
            let mut adt =
                AutoDropTimer::new(clk, Duration::from_secs(1000), || {}, "test".to_string())
                    .unwrap();
            assert_eq!(clk.len(), 2);
            let _ = adt.cancel();
            let _ = adt.cancel();
            let _ = adt.cancel();
        }
        assert_eq!(clk.len(), 1);
    }
    // TODO: Profiling testing
}