feat: works

__wasm/wit-bindgen-sample/engine/boa/boa_profiler/src/lib.rs

@@ -0,0 +1,85 @@
+#![allow(missing_copy_implementations, missing_debug_implementations)]
+
+#[cfg(feature = "profiler")]
+use measureme::{EventId, Profiler as MeasuremeProfiler, TimingGuard};
+#[cfg(feature = "profiler")]
+use once_cell::sync::OnceCell;
+use std::fmt::{self, Debug};
+#[cfg(feature = "profiler")]
+use std::{
+    path::Path,
+    thread::{current, ThreadId},
+};
+
+#[cfg(feature = "profiler")]
+pub struct Profiler {
+    profiler: MeasuremeProfiler,
+}
+
+/// This static instance must never be public, and its only access must be done through the
+/// `global()` and `drop()` methods. This is because `get_or_init` manages synchronization and the
+/// case of an empty value.
+#[cfg(feature = "profiler")]
+static mut INSTANCE: OnceCell<Profiler> = OnceCell::new();
+
+#[cfg(feature = "profiler")]
+impl Profiler {
+    pub fn start_event(&self, label: &str, category: &str) -> TimingGuard<'_> {
+        let kind = self.profiler.alloc_string(category);
+        let id = EventId::from_label(self.profiler.alloc_string(label));
+        let thread_id = Self::thread_id_to_u32(current().id());
+        self.profiler
+            .start_recording_interval_event(kind, id, thread_id)
+    }
+
+    pub fn default() -> Self {
+        let profiler =
+            MeasuremeProfiler::new(Path::new("./my_trace")).expect("must be able to create file");
+        Self { profiler }
+    }
+
+    pub fn global() -> &'static Self {
+        unsafe { INSTANCE.get_or_init(Self::default) }
+    }
+
+    pub fn drop(&self) {
+        // In order to drop the INSTANCE we need to get ownership of it, which isn't possible on a static unless you make it a mutable static
+        // mutating statics is unsafe, so we need to wrap it as so.
+        // This is actually safe though because init and drop are only called at the beginning and end of the application
+        unsafe {
+            INSTANCE
+                .take()
+                .expect("Could not take back profiler instance");
+        }
+    }
+
+    // Sadly we need to use the unsafe method until this is resolved:
+    // https://github.com/rust-lang/rust/issues/67939
+    // Once `as_64()` is in stable we can do this:
+    // https://github.com/rust-lang/rust/pull/68531/commits/ea42b1c5b85f649728e3a3b334489bac6dce890a
+    // Until then our options are: use rust-nightly or use unsafe {}
+    fn thread_id_to_u32(tid: ThreadId) -> u32 {
+        unsafe { std::mem::transmute::<ThreadId, u64>(tid) as u32 }
+    }
+}
+
+impl Debug for Profiler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Debug::fmt("no debug implemented", f)
+    }
+}
+
+#[cfg(not(feature = "profiler"))]
+pub struct Profiler;
+
+#[allow(clippy::unused_unit, clippy::unused_self)]
+#[cfg(not(feature = "profiler"))]
+impl Profiler {
+    pub fn start_event(&self, _label: &str, _category: &str) -> () {}
+
+    pub fn drop(&self) {}
+
+    pub fn global() -> Self {
+        Self
+    }
+}