Address review comments and remove fencing from rdtsc()

Author: Stypox

src/bin/log/tracing_chrome_instant.rs

@@ -6,6 +6,8 @@
 //! since the former is not reliable (i.e. it might lead to non-monotonic time measurements).
 //! Another useful resource for future improvements might be measureme's time measurement utils:
 //! <https://github.com/rust-lang/measureme/blob/master/measureme/src/counters.rs>.
+//! Documentation about how the Linux kernel chooses a clock source can be found here:
+//! <https://btorpey.github.io/blog/2014/02/18/clock-sources-in-linux/>.
 #![cfg(feature = "tracing")]
 
 /// This alternative `TracingChromeInstant` implementation was made entirely to suit the needs of
@@ -90,27 +92,16 @@ impl TracingChromeInstant {
                 f(ts);
 
                 // Measure how much time was spent executing `f` and shift `start_instant` forward
-                // by that amount.
+                // by that amount. This "removes" that time from the trace.
                 *start_instant += std::time::Instant::now() - instant_before_f;
             }
 
             #[cfg(all(target_os = "linux", any(target_arch = "x86", target_arch = "x86_64")))]
             TracingChromeInstant::Tsc { start_tsc, tsc_to_microseconds } => {
-                // Obtain the current time (before executing `f`).
+                // the comments above also apply here, since it's the same logic
                 let tsc_before_f = tsc::rdtsc();
-
-                // Using the current time (`instant_before_f`) and the `start_instant` stored in
-                // `self`, calculate the elapsed time (in microseconds) since this instant was
-                // instantiated, accounting for any time that was previously spent executing `f`.
-                // The "accounting" part is not computed in this line, but is rather done by
-                // shifting forward the `start_instant` down below.
                 let ts = ((tsc_before_f - *start_tsc) as f64) * (*tsc_to_microseconds);
-
-                // Run the function (supposedly a function internal to the tracing infrastructure).
                 f(ts);
-
-                // Measure how much time was spent executing `f` and shift `start_instant` forward
-                // by that amount.
                 *start_tsc += tsc::rdtsc() - tsc_before_f;
             }
         }
@@ -127,21 +118,11 @@ mod tsc {
     #[inline(always)]
     pub(super) fn rdtsc() -> u64 {
         #[cfg(target_arch = "x86")]
-        use core::arch::x86::{_mm_lfence, _rdtsc};
+        use core::arch::x86::_rdtsc;
         #[cfg(target_arch = "x86_64")]
-        use core::arch::x86_64::{_mm_lfence, _rdtsc};
-        use std::arch::asm;
-
-        unsafe {
-            // Fence the execution with `_mm_lfence` and `asm!` to ensure that neither the compiler
-            // nor the CPU reorder instructions, as that would make _rdtsc() run at the wrong time.
-            _mm_lfence();
-            asm!("", options(nostack, preserves_flags));
-            let tsc = _rdtsc();
-            asm!("", options(nostack, preserves_flags));
-            _mm_lfence();
-            tsc
-        }
+        use core::arch::x86_64::_rdtsc;
+
+        unsafe { _rdtsc() }
     }
 
     /// Estimates the frequency of the TSC counter by waiting 10ms in a busy loop and