Remove Timer from the main OS struct.

Author: veluca93

pixie-uefi/src/os/executor.rs

@@ -1,4 +1,6 @@
-use super::{sync::SyncRefCell, UefiOS};
+use crate::os::timer::Timer;
+
+use super::sync::SyncRefCell;
 use alloc::{boxed::Box, collections::VecDeque, sync::Arc, task::Wake};
 use core::{
     cell::RefCell,
@@ -63,7 +65,7 @@ pub struct Executor {
 }
 
 impl Executor {
-    pub fn run(os: UefiOS) -> ! {
+    pub fn run() -> ! {
         loop {
             let task = EXECUTOR
                 .borrow_mut()
@@ -75,9 +77,9 @@ impl Executor {
             let waker = Waker::from(task.clone());
             let mut context = Context::from_waker(&waker);
             let mut fut = task.inner.borrow_mut().future.take().unwrap();
-            let begin = os.timer().micros();
+            let begin = Timer::micros();
             let status = fut.as_mut().poll(&mut context);
-            let end = os.timer().micros();
+            let end = Timer::micros();
             task.inner.borrow_mut().micros += end - begin;
             if status.is_pending() {
                 task.inner.borrow_mut().future = Some(fut);

pixie-uefi/src/os/mod.rs

@@ -57,7 +57,6 @@ mod timer;
 pub use net::{TcpStream, UdpHandle, PACKET_SIZE};
 
 struct UefiOSImpl {
-    timer: Timer,
     rng: Rng,
     tasks: Vec<Arc<Task>>,
     input: ScopedProtocol<Input>,
@@ -163,7 +162,7 @@ impl UefiOS {
             .unwrap();
         }
 
-        let timer = Timer::new();
+        Timer::ensure_init();
         let rng = Rng::new();
 
         let input_handles = uefi::boot::find_handles::<Input>().unwrap();
@@ -179,7 +178,6 @@ impl UefiOS {
         vga.clear().unwrap();
 
         *OS.borrow_mut() = Some(UefiOSImpl {
-            timer,
             rng,
             tasks: Vec::new(),
             input,
@@ -227,9 +225,8 @@ impl UefiOS {
         os.spawn(
             "[net_poll]",
             poll_fn(move |cx| {
-                let (mut net, timer) =
-                    RefMut::map_split(os.borrow_mut(), |os| (&mut os.net, &mut os.timer));
-                net.as_mut().unwrap().poll(&timer);
+                let mut os = os.borrow_mut();
+                os.net.as_mut().unwrap().poll();
                 // TODO(veluca): figure out whether we can suspend the task.
                 cx.waker().wake_by_ref();
                 Poll::Pending
@@ -239,10 +236,10 @@ impl UefiOS {
         os.spawn("[net_speed]", async move {
             let mut prx = 0;
             let mut ptx = 0;
-            let mut ptm = os.timer().instant();
+            let mut ptm = Timer::instant();
             loop {
                 {
-                    let now = os.timer().instant();
+                    let now = Timer::instant();
                     let dt = (now - ptm).total_micros() as f64 / 1_000_000.0;
                     ptm = now;
 
@@ -263,7 +260,7 @@ impl UefiOS {
             }
         });
 
-        Executor::run(os)
+        Executor::run()
     }
 
     fn borrow(&self) -> Ref<'static, UefiOSImpl> {
@@ -274,10 +271,6 @@ impl UefiOS {
         RefMut::map(OS.borrow_mut(), |f| f.as_mut().unwrap())
     }
 
-    pub fn timer(&self) -> Ref<'static, Timer> {
-        Ref::map(self.borrow(), |f| &f.timer)
-    }
-
     pub fn rng(&self) -> RefMut<'static, Rng> {
         RefMut::map(self.borrow_mut(), |f| &mut f.rng)
     }
@@ -317,9 +310,9 @@ impl UefiOS {
     }
 
     pub fn sleep_us(self, us: u64) -> impl Future<Output = ()> {
-        let tgt = self.timer().micros() as u64 + us;
+        let tgt = Timer::micros() as u64 + us;
         poll_fn(move |cx| {
-            let now = self.timer().micros() as u64;
+            let now = Timer::micros() as u64;
             if now >= tgt {
                 Poll::Ready(())
             } else {
@@ -431,7 +424,7 @@ impl UefiOS {
     fn draw_ui(&self) {
         // Write the header.
         {
-            let time = self.timer().micros() as f32 * 0.000_001;
+            let time = Timer::micros() as f32 * 0.000_001;
             let ip = self.net().ip();
             let mut os = self.borrow_mut();
 
@@ -572,7 +565,7 @@ impl log::Log for UefiOS {
     }
 
     fn log(&self, record: &log::Record) {
-        let now = self.timer().micros() as f64 * 0.000_001;
+        let now = Timer::micros() as f64 * 0.000_001;
         self.append_message(
             now,
             record.level(),

pixie-uefi/src/os/net.rs

@@ -183,7 +183,7 @@ impl NetworkInterface {
 
         let mut interface_config = Config::new(hw_addr);
         interface_config.random_seed = os.rng().rand_u64();
-        let now = Instant::from_micros(os.timer().micros());
+        let now = Timer::instant();
         let interface = Interface::new(interface_config, &mut device, now);
         let mut dhcp_socket = Dhcpv4Socket::new();
         dhcp_socket.set_outgoing_options(&[DhcpOption {
@@ -220,8 +220,8 @@ impl NetworkInterface {
         self.interface.ipv4_addr()
     }
 
-    pub(super) fn poll(&mut self, timer: &Timer) -> bool {
-        let now = timer.instant();
+    pub(super) fn poll(&mut self) -> bool {
+        let now = Timer::instant();
         let status = self
             .interface
             .poll(now, &mut self.device, &mut self.socket_set);

pixie-uefi/src/os/timer.rs

@@ -1,43 +1,49 @@
-use core::arch::x86_64::_rdtsc;
+use core::{
+    arch::x86_64::_rdtsc,
+    sync::atomic::{AtomicBool, AtomicI64, Ordering},
+};
 use smoltcp::time::Instant;
 
-pub struct Timer {
-    ticks_at_start: i64,
-    ticks_per_micro: i64,
+static TICKS_AT_START: AtomicI64 = AtomicI64::new(0);
+static TICKS_PER_MICRO: AtomicI64 = AtomicI64::new(0);
+static INITIALIZED: AtomicBool = AtomicBool::new(false);
+
+pub struct Timer {}
+
+fn rdtsc() -> i64 {
+    // SAFETY: modern x86 CPUs have this instruction.
+    unsafe { _rdtsc() as i64 }
 }
 
 impl Timer {
-    fn rdtsc() -> i64 {
-        // SAFETY: modern x86 CPUs have this instruction.
-        unsafe { _rdtsc() as i64 }
-    }
-
-    pub fn new() -> Timer {
+    pub(super) fn ensure_init() {
+        if INITIALIZED.load(Ordering::Relaxed) {
+            return;
+        }
         // Read timer clock & wait to stabilize the counter.
-        Self::rdtsc();
+        rdtsc();
         uefi::boot::stall(20000);
-        let tsc_before = Self::rdtsc();
+        let tsc_before = rdtsc();
         uefi::boot::stall(20000);
-        let tsc_after = Self::rdtsc();
+        let tsc_after = rdtsc();
 
-        Timer {
-            ticks_at_start: tsc_after,
-            // TICKS_PER_MICRO is a multiple of 10 on every reasonable system.
-            ticks_per_micro: (tsc_after - tsc_before) / (20000 * 10) * 10,
-        }
-    }
-
-    pub fn micros(&self) -> i64 {
-        (Self::rdtsc() - self.ticks_at_start) / self.ticks_per_micro
+        TICKS_AT_START.store(tsc_after, Ordering::Relaxed);
+        // TICKS_PER_MICRO is a multiple of 10 on every reasonable system.
+        TICKS_PER_MICRO.store(
+            (tsc_after - tsc_before) / (20000 * 10) * 10,
+            Ordering::Relaxed,
+        );
+        INITIALIZED.store(true, Ordering::Relaxed);
     }
 
-    pub fn instant(&self) -> Instant {
-        Instant::from_micros(self.micros())
+    pub fn micros() -> i64 {
+        Self::ensure_init();
+        let ticks_at_start = TICKS_AT_START.load(Ordering::Relaxed);
+        let ticks_per_micro = TICKS_PER_MICRO.load(Ordering::Relaxed);
+        (rdtsc() - ticks_at_start) / ticks_per_micro
     }
-}
 
-impl Default for Timer {
-    fn default() -> Self {
-        Self::new()
+    pub fn instant() -> Instant {
+        Instant::from_micros(Timer::micros())
     }
 }