refactor: avoid direct libc calls to get Duration from Instant

Author: paolobarbolini

Cargo.lock

@@ -21,9 +21,6 @@ socket2 = { version = "0.5.1", features = ["all"] }
 getrandom = "0.3.1"
 tokio = { version = "1.25", features = ["net", "sync", "rt"] }
 
-# weak
-libc = "0.2"
-
 # stream
 futures-core = { version = "0.3", optional = true }
 

Cargo.toml

@@ -1,82 +1,114 @@
-use std::{mem, ops::Sub, time::Duration};
+use std::{
+    ops::Sub,
+    time::{Duration, Instant},
+};
+
+#[derive(Debug, Clone)]
+pub struct ReferenceInstant {
+    #[cfg(not(feature = "strong"))]
+    instant: Instant,
+}
 
-#[derive(Copy, Clone)]
-pub struct Instant {
-    spec: libc::timespec,
+#[derive(Debug, Copy, Clone)]
+pub struct RelativeInstant {
+    #[cfg(feature = "strong")]
+    relative: Instant,
+    #[cfg(not(feature = "strong"))]
+    relative: Duration,
 }
 
-impl Instant {
-    pub fn now() -> Self {
-        let mut spec = unsafe { mem::zeroed() };
-        unsafe {
-            libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut spec as *mut _);
+impl ReferenceInstant {
+    pub fn new() -> Self {
+        Self {
+            #[cfg(not(feature = "strong"))]
+            instant: Instant::now(),
         }
-        Self { spec }
     }
 
-    pub const ENCODED_LEN: usize = mem::size_of::<libc::timespec>();
-
-    pub fn encode(&self) -> [u8; Self::ENCODED_LEN] {
-        // SAFETY: transmuting between items of the same length is fine
-        unsafe { mem::transmute_copy(&self.spec) }
+    pub fn now(&self) -> RelativeInstant {
+        RelativeInstant {
+            #[cfg(feature = "strong")]
+            relative: Instant::now(),
+            #[cfg(not(feature = "strong"))]
+            relative: self.instant.elapsed(),
+        }
     }
+}
 
-    pub fn decode(bytes: &[u8; Self::ENCODED_LEN]) -> Option<Self> {
-        // SAFETY: transmuting between items of the same length is fine
-        let spec: libc::timespec = unsafe { mem::transmute_copy(bytes) };
+impl RelativeInstant {
+    #[cfg(not(feature = "strong"))]
+    pub const ENCODED_LEN: usize = 12;
 
-        if spec.tv_sec >= 0 && spec.tv_nsec >= 0 {
-            Some(Self { spec })
-        } else {
-            None
-        }
+    #[cfg(not(feature = "strong"))]
+    pub fn encode(&self) -> [u8; Self::ENCODED_LEN] {
+        let mut buf = [0u8; Self::ENCODED_LEN];
+        let (secs, nanos) = buf.split_at_mut(8);
+        secs.copy_from_slice(&self.relative.as_secs().to_ne_bytes());
+        nanos.copy_from_slice(&self.relative.subsec_nanos().to_ne_bytes());
+
+        buf
     }
-}
 
-impl From<Instant> for Duration {
-    fn from(instant: Instant) -> Self {
-        Duration::new(instant.spec.tv_sec as _, instant.spec.tv_nsec as _)
+    #[cfg(not(feature = "strong"))]
+    pub fn decode(buf: &[u8; Self::ENCODED_LEN]) -> Option<Self> {
+        let (secs, nanos) = buf.split_at(8);
+        let secs = u64::from_ne_bytes(secs.try_into().unwrap());
+        let nanos = u32::from_ne_bytes(nanos.try_into().unwrap());
+
+        let relative = Duration::from_secs(secs).checked_add(Duration::from_nanos(nanos.into()))?;
+        Some(Self { relative })
     }
 }
 
-impl Sub<Instant> for Instant {
+impl Sub<RelativeInstant> for RelativeInstant {
     type Output = Duration;
 
-    fn sub(self, other: Instant) -> Self::Output {
-        Duration::from(self).saturating_sub(Duration::from(other))
+    fn sub(self, rhs: RelativeInstant) -> Self::Output {
+        #[cfg(feature = "strong")]
+        {
+            self.relative.saturating_duration_since(rhs.relative)
+        }
+
+        #[cfg(not(feature = "strong"))]
+        {
+            self.relative.saturating_sub(rhs.relative)
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use std::time::Duration;
 
-    use super::Instant;
+    use super::ReferenceInstant;
+    #[cfg(not(feature = "strong"))]
+    use super::RelativeInstant;
 
     #[test]
     fn passing_time() {
-        let a = Instant::now();
-        let b = Instant::now();
+        let reference = ReferenceInstant::new();
+        let a = reference.now();
+        let b = reference.now();
 
         assert!(b - a <= Duration::from_millis(10));
     }
 
     #[test]
     fn wrong_order() {
-        let a = Instant::now();
-        let b = Instant::now();
+        let reference = ReferenceInstant::new();
+        let a = reference.now();
+        let b = reference.now();
 
         assert_eq!(a - b, Duration::ZERO);
     }
 
     #[test]
+    #[cfg(not(feature = "strong"))]
     fn encode_decode() {
-        let a1 = Instant::now();
-        let a1_duration = Duration::from(a1);
-
-        let a2 = Instant::decode(a1.encode()).unwrap();
-        let a2_duration = Duration::from(a2);
+        let reference = ReferenceInstant::new();
+        let a1 = reference.now();
+        let a2 = RelativeInstant::decode(&a1.encode()).unwrap();
 
-        assert_eq!(a1_duration, a2_duration);
+        assert_eq!(a1.relative, a2.relative);
     }
 }

src/instant.rs

@@ -46,7 +46,6 @@ pub use self::{
     pinger::{MeasureManyStream, Pinger, V4Pinger, V6Pinger},
 };
 
-#[cfg(not(feature = "strong"))]
 mod instant;
 mod ip_version;
 pub mod packet;

src/lib.rs

@@ -1,5 +1,3 @@
-#[cfg(feature = "strong")]
-use std::time::Instant;
 use std::{
     collections::HashMap,
     io,
@@ -24,8 +22,7 @@ use tokio::{
     task,
 };
 
-#[cfg(not(feature = "strong"))]
-use crate::instant::Instant;
+use crate::instant::{ReferenceInstant, RelativeInstant};
 use crate::{
     packet::EchoRequestPacket,
     raw_pinger::{RawBlockingPinger, RawPinger},
@@ -44,6 +41,7 @@ pub struct Pinger<V: IpVersion> {
 
 struct InnerPinger<V: IpVersion> {
     raw: RawPinger<V>,
+    reference: ReferenceInstant,
     round_sender: mpsc::UnboundedSender<RoundMessage<V>>,
     identifier: u16,
     sequence_number: AtomicU16,
@@ -53,9 +51,9 @@ enum RoundMessage<V: IpVersion> {
     Subscribe {
         sequence_number: u16,
         #[cfg(feature = "strong")]
-        sender: mpsc::UnboundedSender<(V, Instant)>,
+        sender: mpsc::UnboundedSender<(V, RelativeInstant)>,
         #[cfg(not(feature = "strong"))]
-        sender: mpsc::UnboundedSender<(V, Instant, Instant)>,
+        sender: mpsc::UnboundedSender<(V, RelativeInstant, RelativeInstant)>,
     },
     Unsubscribe {
         sequence_number: u16,
@@ -70,6 +68,7 @@ impl<V: IpVersion> Pinger<V> {
     /// be beneficial to `Drop` the `Pinger` and recreate it if
     /// you are not going to be sending pings for a long period of time.
     pub fn new() -> io::Result<Self> {
+        let reference = ReferenceInstant::new();
         let raw = RawPinger::new()?;
         let raw_blocking = RawBlockingPinger::new()?;
 
@@ -81,6 +80,7 @@ impl<V: IpVersion> Pinger<V> {
 
         let inner = Arc::new(InnerPinger {
             raw,
+            reference: reference.clone(),
             round_sender: sender,
             identifier,
             sequence_number: AtomicU16::new(0),
@@ -89,11 +89,14 @@ impl<V: IpVersion> Pinger<V> {
             let mut buf = [MaybeUninit::<u8>::uninit(); 1600];
 
             #[cfg(feature = "strong")]
-            let mut subscribers: HashMap<u16, mpsc::UnboundedSender<(V, Instant)>> = HashMap::new();
+            let mut subscribers: HashMap<
+                u16,
+                mpsc::UnboundedSender<(V, RelativeInstant)>,
+            > = HashMap::new();
             #[cfg(not(feature = "strong"))]
             let mut subscribers: HashMap<
                 u16,
-                mpsc::UnboundedSender<(V, Instant, Instant)>,
+                mpsc::UnboundedSender<(V, RelativeInstant, RelativeInstant)>,
             > = HashMap::new();
             'packets: loop {
                 let maybe_packet = match raw_blocking.recv(&mut buf) {
@@ -106,13 +109,13 @@ impl<V: IpVersion> Pinger<V> {
 
                 match &maybe_packet {
                     Some(packet) if packet.identifier() == identifier => {
-                        let recv_instant = Instant::now();
+                        let recv_instant = reference.now();
 
                         #[cfg(not(feature = "strong"))]
                         let send_instant = {
                             let payload = packet.payload();
-                            match Instant::decode(
-                                payload[..Instant::ENCODED_LEN].try_into().unwrap(),
+                            match RelativeInstant::decode(
+                                payload[..RelativeInstant::ENCODED_LEN].try_into().unwrap(),
                             ) {
                                 Some(send_instant) => send_instant,
                                 None => continue 'packets,
@@ -271,11 +274,11 @@ pub struct MeasureManyStream<'a, V: IpVersion, I: Iterator<Item = V>> {
     pinger: &'a Pinger<V>,
     send_queue: Peekable<I>,
     #[cfg(feature = "strong")]
-    in_flight: HashMap<V, Instant>,
+    in_flight: HashMap<V, RelativeInstant>,
     #[cfg(feature = "strong")]
-    receiver: mpsc::UnboundedReceiver<(V, Instant)>,
+    receiver: mpsc::UnboundedReceiver<(V, RelativeInstant)>,
     #[cfg(not(feature = "strong"))]
-    receiver: mpsc::UnboundedReceiver<(V, Instant, Instant)>,
+    receiver: mpsc::UnboundedReceiver<(V, RelativeInstant, RelativeInstant)>,
     sequence_number: u16,
 }
 
@@ -299,7 +302,7 @@ impl<V: IpVersion, I: Iterator<Item = V>> MeasureManyStream<'_, V, I> {
             getrandom::fill(&mut payload).expect("generate random payload");
             #[cfg(not(feature = "strong"))]
             {
-                let now = Instant::now().encode();
+                let now = self.pinger.inner.reference.now().encode();
                 let (now_part, random_part) = payload.split_at_mut(now.len());
                 now_part.copy_from_slice(&now);
                 getrandom::fill(random_part).expect("generate random payload");
@@ -313,7 +316,7 @@ impl<V: IpVersion, I: Iterator<Item = V>> MeasureManyStream<'_, V, I> {
             match self.pinger.inner.raw.poll_send_to(cx, addr, &packet) {
                 Poll::Ready(_) => {
                     #[cfg(feature = "strong")]
-                    let sent_at = Instant::now();
+                    let sent_at = self.pinger.inner.reference.now();
 
                     let taken_addr = self.send_queue.next();
                     debug_assert!(taken_addr.is_some());