update: avoid using Reflection to get Performance each time

Author: Officeyutong

src/clocks/monotonic/mod.rs

@@ -3,10 +3,16 @@ mod windows;
 #[cfg(target_os = "windows")]
 pub use self::windows::Monotonic;
 
-#[cfg(target_arch = "wasm32")]
-mod wasm;
-#[cfg(target_arch = "wasm32")]
-pub use self::wasm::Monotonic;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+mod wasm_browser;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+pub use self::wasm_browser::Monotonic;
+
+#[cfg(all(target_arch = "wasm32", target_os = "wasi"))]
+mod wasm_wasi;
+#[cfg(all(target_arch = "wasm32", target_os = "wasi"))]
+pub use self::wasm_wasi::Monotonic;
+
 
 #[cfg(not(any(target_os = "windows", target_arch = "wasm32")))]
 mod unix;

src/clocks/monotonic/wasm.rs

@@ -0,0 +1,54 @@
+/// Since threads (WebWorkers) in browser don't shared the same memory space, so no objects would have a chance to be sended to other threads, thus it's safe to implement Send for objects here
+use web_sys::{
+    js_sys::Reflect,
+    wasm_bindgen::{JsCast, JsValue},
+    Performance,
+};
+
+const WASM_MISSING_GLOBAL_THIS_PERF: &str = "failed to find `globalThis.performance`";
+const WASM_UNABLE_TO_CAST_PERF: &str =
+    "Unable to cast `globalThis.performance` to Performance type";
+
+struct PerformanceClassWrapper(Performance);
+
+unsafe impl Send for PerformanceClassWrapper {}
+unsafe impl Sync for PerformanceClassWrapper {}
+
+static GLOBAL_PERFORMANCE_INSTANCE: std::sync::OnceLock<PerformanceClassWrapper> =
+    std::sync::OnceLock::new();
+
+#[derive(Clone, Copy, Debug)]
+pub struct Monotonic {
+    performance: &'static Performance,
+}
+
+unsafe impl Send for Monotonic {}
+unsafe impl Sync for Monotonic {}
+
+impl Default for Monotonic {
+    fn default() -> Self {
+        let performance = GLOBAL_PERFORMANCE_INSTANCE.get_or_init(|| {
+            PerformanceClassWrapper(
+                Reflect::get(
+                    &web_sys::js_sys::global(),
+                    &JsValue::from_str("performance"),
+                )
+                .expect(WASM_MISSING_GLOBAL_THIS_PERF)
+                .dyn_into::<Performance>()
+                .expect(WASM_UNABLE_TO_CAST_PERF),
+            )
+        });
+
+        Self {
+            performance: &performance.0,
+        }
+    }
+}
+
+impl Monotonic {
+    pub fn now(&self) -> u64 {
+        let now = self.performance.now();
+        // `performance.now()` returns the time in milliseconds.
+        return f64::trunc(now * 1_000_000.0) as u64;
+    }
+}

src/clocks/monotonic/wasm_browser.rs

@@ -0,0 +1,10 @@
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Monotonic {
+    _default: (),
+}
+
+impl Monotonic {
+    pub fn now(&self) -> u64 {
+        unsafe { wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 1).expect("failed to get time") }
+    }
+}