allow using more time sources

Author: imlvts

src/timed_span.rs

@@ -1,4 +1,3 @@
-use std::arch::asm;
 use std::sync::atomic::{AtomicU64, Ordering};
 
 macro_rules! entries {
@@ -90,57 +89,180 @@ pub fn print_counters() {
     }
 }
 
-#[cfg(target_arch = "aarch64")]
-#[inline]
-fn read_cycle_counter() -> u64 {
-    let val: u64;
-    unsafe {
-        asm!(
-            "mrs {}, CNTVCT_EL0",
-            out(reg) val,
-            options(nostack, nomem)
-        );
-    }
-    val
-}
+#[allow(dead_code)]
+mod tsc {
+    use std::arch::asm;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    #[cfg(target_arch = "aarch64")]
+    #[inline]
+    fn read_cycle_counter() -> u64 {
+        let val: u64;
+        unsafe {
+            asm!(
+                "mrs {}, CNTVCT_EL0",
+                out(reg) val,
+                options(nostack, nomem)
+            );
+        }
+        val
+    }
 
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-#[inline]
-fn read_cycle_counter() -> u64 {
-    let lo: u32;
-    let hi: u32;
-    unsafe {
-        asm!(
-            "rdtsc",
-            out("eax") lo,
-            out("edx") hi,
-            options(nostack, nomem)
-        );
-    }
-    ((hi as u64) << 32) | (lo as u64)
-}
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    #[inline]
+    fn read_cycle_counter() -> u64 {
+        let lo: u32;
+        let hi: u32;
+        unsafe {
+            asm!(
+                "rdtsc",
+                out("eax") lo,
+                out("edx") hi,
+                options(nostack, nomem)
+            );
+        }
+        ((hi as u64) << 32) | (lo as u64)
+    }
+
+    pub struct TimedSpanGuard<'a> {
+        start: u64,
+        counter: &'a AtomicU64,
+    }
+
+    impl<'a> TimedSpanGuard<'a> {
+        pub fn new(counter: &'a AtomicU64) -> Self {
+            Self {
+                start: read_cycle_counter(),
+                counter,
+            }
+        }
+    }
 
-pub struct TimedSpanGuard<'a> {
-    start: u64,
-    counter: &'a AtomicU64,
+    impl<'a> Drop for TimedSpanGuard<'a> {
+        fn drop(&mut self) {
+            let end = read_cycle_counter();
+            self.counter.fetch_add(end - self.start, Ordering::Relaxed);
+        }
+    }
 }
 
-impl<'a> TimedSpanGuard<'a> {
-    pub fn new(counter: &'a AtomicU64) -> Self {
-        Self {
-            start: read_cycle_counter(),
-            counter,
+#[allow(dead_code)]
+mod std_instant {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::time::Instant;
+    pub struct TimedSpanGuard<'a> {
+        start: Instant,
+        counter: &'a AtomicU64,
+    }
+
+    impl<'a> TimedSpanGuard<'a> {
+        pub fn new(counter: &'a AtomicU64) -> Self {
+            Self {
+                start: Instant::now(),
+                counter,
+            }
+        }
+    }
+
+    impl<'a> Drop for TimedSpanGuard<'a> {
+        fn drop(&mut self) {
+            let duration = self.start.elapsed().as_nanos() as u64;
+            self.counter.fetch_add(duration, Ordering::Relaxed);
         }
     }
 }
 
-impl<'a> Drop for TimedSpanGuard<'a> {
-    fn drop(&mut self) {
-        let end = read_cycle_counter();
-        self.counter.fetch_add(end - self.start, Ordering::Relaxed);
+#[allow(dead_code)]
+mod clock_monotonic {
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    #[cfg(target_os="linux")]
+    mod linux {
+        // linux/time.h
+        // const CLOCK_REALTIME          : i32 = 0;
+        // const CLOCK_MONOTONIC         : i32 = 1;
+        // const CLOCK_PROCESS_CPUTIME_ID: i32 = 2;
+        // const CLOCK_THREAD_CPUTIME_ID : i32 = 3;
+        const CLOCK_MONOTONIC_RAW     : i32 = 4;
+        // const CLOCK_REALTIME_COARSE   : i32 = 5;
+        const CLOCK_MONOTONIC_COARSE  : i32 = 6;
+        // const CLOCK_BOOTTIME          : i32 = 7;
+        // const CLOCK_REALTIME_ALARM    : i32 = 8;
+        // const CLOCK_BOOTTIME_ALARM    : i32 = 9;
+
+        #[allow(non_camel_case_types)]
+        #[repr(C)]
+        struct timespec {
+            tv_sec: u64,
+            tv_nsec: i32,
+        }
+
+        extern "C" {
+            fn clock_gettime(clockid: i32, tp: &mut timespec) -> i32;
+        }
+        pub fn get_time() -> u64 {
+            let mut time = timespec { tv_sec: 0, tv_nsec: 0 };
+            let rv = unsafe { clock_gettime(CLOCK_MONOTONIC_RAW, &mut time) };
+            debug_assert!(rv == 0, "failed clock_gettime?");
+            time.tv_sec * 1_000_000_000 + time.tv_nsec as u64
+        }
+    }
+    #[cfg(target_os="linux")]
+    use linux::get_time;
+
+    #[cfg(all(target_os="macos", target_arch="aarch64"))]
+    mod macos {
+        const CLOCK_MONOTONIC_RAW       : i32 = 4;
+        const CLOCK_MONOTONIC_RAW_APPROX: i32 = 5;
+        const CLOCK_MONOTONIC           : i32 = 6;
+        // const CALENDAR_CLOCK: u64 = 1;
+        #[allow(non_camel_case_types)]
+        #[repr(C)]
+        struct timespec {
+            tv_sec: u64,
+            tv_nsec: i32,
+        }
+        extern "C" {
+            // host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
+            // fn clock_get_time(clock_serv: &mut u64, cur_time: &mut mach_timespec) -> i64;
+            // mach_port_deallocate(mach_task_self(), cclock);
+            fn clock_gettime(clock_serv: i32, cur_time: &mut timespec) -> i64;
+        }
+
+        pub fn get_time() -> u64 {
+            let mut time = timespec { tv_sec: 0, tv_nsec: 0 };
+            let _rv = unsafe { clock_gettime(CLOCK_MONOTONIC_RAW, &mut time) };
+            let rv = unsafe { clock_gettime(CLOCK_MONOTONIC_RAW, &mut time) };
+            debug_assert!(rv == 0, "failed clock_gettime?");
+            (time.tv_sec as u64 * 1_000_000_000) + time.tv_nsec as u64
+        }
+    }
+
+    #[cfg(all(target_os="macos", target_arch="aarch64"))]
+    use macos::get_time;
+
+    pub struct TimedSpanGuard<'a> {
+        start: u64,
+        counter: &'a AtomicU64,
+    }
+
+    impl<'a> TimedSpanGuard<'a> {
+        pub fn new(counter: &'a AtomicU64) -> Self {
+            Self {
+                start: get_time(),
+                counter,
+            }
+        }
+    }
+
+    impl<'a> Drop for TimedSpanGuard<'a> {
+        fn drop(&mut self) {
+            let end = get_time();
+            self.counter.fetch_add(end - self.start, Ordering::Relaxed);
+        }
     }
 }
 
+pub use tsc::TimedSpanGuard;
 pub const ENABLED: bool = true;
 
 macro_rules! timed_span {