Quanta overhaul: calibration speed, accuracy, and more

Cargo.toml

@@ -24,6 +24,7 @@ harness = false
 metrics = ["metrics-core"]
 
 [dependencies]
+once_cell = "^1.4"
 metrics-core = { version = "^0.5", optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]

benches/timing.rs

@@ -23,7 +23,7 @@ fn time_clocksource_counter_scaled(b: &mut Bencher) {
 }
 
 fn time_quanta_now(b: &mut Bencher) {
-    let clock = Clock::new();
+    let mut clock = Clock::new();
     b.iter(|| clock.now())
 }
 
@@ -93,7 +93,7 @@ fn time_quanta_raw_delta(b: &mut Bencher) {
 }
 
 fn time_quanta_now_delta(b: &mut Bencher) {
-    let clock = Clock::new();
+    let mut clock = Clock::new();
     b.iter(|| {
         let start = clock.now();
         let end = clock.now();

src/counter.rs

@@ -1,7 +1,5 @@
 use crate::ClockSource;
 
-#[cfg(all(target_arch = "x86", target_feature = "sse2"))]
-use std::arch::x86::{__rdtscp, _mm_lfence, _rdtsc};
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 use std::arch::x86_64::{__rdtscp, _mm_lfence, _rdtsc};
 
@@ -15,10 +13,7 @@ impl Counter {
     }
 }
 
-#[cfg(all(
-    any(target_arch = "x86", target_arch = "x86_64"),
-    target_feature = "sse2"
-))]
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 impl ClockSource for Counter {
     fn now(&self) -> u64 {
         unsafe {
@@ -46,10 +41,7 @@ impl ClockSource for Counter {
     }
 }
 
-#[cfg(not(all(
-    any(target_arch = "x86", target_arch = "x86_64"),
-    target_feature = "sse2"
-)))]
+#[cfg(not(all(target_arch = "x86_64", target_feature = "sse2")))]
 impl ClockSource for Counter {
     fn now(&self) -> u64 {
         panic!("can't use counter without TSC support");

src/instant.rs

@@ -8,25 +8,17 @@ use std::time::Duration;
 
 /// A point-in-time wall-clock measurement.
 ///
-/// Represents a time measurement that has been taken by [`Clock`](crate::Clock) and scaled to wall-clock time.
+/// Represents a time measurement that has been taken by [`Clock`](crate::Clock) and scaled to reference time.
 ///
-/// Unlike the stdlib `Instant`, this type has two meaningful differences:
-/// - It provides no guarantees around monotonicity whatsoever, beyond any guarantees provided by
-/// `Clock` itself.
-/// - It is intended to be opaque, but the internal value can be accessed.  There are no guarantees
-/// on the internal value timebase, or other factors, remaining stable over time and this
-/// convenience is only intended for comparisons of `Instant`s provided by the same exact `Clock`
-/// instance.
+/// Unlike the stdlib `Instant`, this type has a meaningful difference: it is intended to be opaque, but the
+/// internal value _can_ be accessed.  There are no guarantees here and depending on this value directly is
+/// proceeding at your own risk. ⚠️
 ///
 /// An `Instant` is 8 bytes.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Instant(pub(crate) u64);
 
 impl Instant {
-    pub(crate) fn new(inner: u64) -> Self {
-        Instant(inner)
-    }
-
     /// Returns the amount of time elapsed from another instant to this one.
     ///
     /// # Panics
@@ -40,7 +32,7 @@ impl Instant {
     /// use std::time::Duration;
     /// use std::thread::sleep;
     ///
-    /// let clock = Clock::new();
+    /// let mut clock = Clock::new();
     /// let now = clock.now();
     /// sleep(Duration::new(1, 0));
     /// let new_now = clock.now();
@@ -63,7 +55,7 @@ impl Instant {
     /// use std::time::Duration;
     /// use std::thread::sleep;
     ///
-    /// let clock = Clock::new();
+    /// let mut clock = Clock::new();
     /// let now = clock.now();
     /// sleep(Duration::new(1, 0));
     /// let new_now = clock.now();
@@ -84,7 +76,7 @@ impl Instant {
     /// use std::time::Duration;
     /// use std::thread::sleep;
     ///
-    /// let clock = Clock::new();
+    /// let mut clock = Clock::new();
     /// let now = clock.now();
     /// sleep(Duration::new(1, 0));
     /// let new_now = clock.now();