wip nostd without alloc

Author: hawkw

tracing-core/src/callsite.rs

@@ -14,21 +14,8 @@ use core::{
     sync::atomic::{AtomicPtr, Ordering},
 };
 
-lazy_static! {
-    static ref REGISTRY: Registry = Registry {
-        callsites: LinkedList::new(),
-        dispatchers: Mutex::new(Vec::new()),
-    };
-}
-
-type Dispatchers = Vec<dispatcher::Registrar>;
 type Callsites = LinkedList;
 
-struct Registry {
-    callsites: Callsites,
-    dispatchers: Mutex<Dispatchers>,
-}
-
 /// Trait implemented by callsites.
 ///
 /// These functions are only intended to be called by the callsite registry, which
@@ -76,98 +63,176 @@ pub struct Registration<T = &'static dyn Callsite> {
     next: AtomicPtr<Registration<T>>,
 }
 
-/// Clear and reregister interest on every [`Callsite`]
-///
-/// This function is intended for runtime reconfiguration of filters on traces
-/// when the filter recalculation is much less frequent than trace events are.
-/// The alternative is to have the [`Subscriber`] that supports runtime
-/// reconfiguration of filters always return [`Interest::sometimes()`] so that
-/// [`enabled`] is evaluated for every event.
-///
-/// This function will also re-compute the global maximum level as determined by
-/// the [`max_level_hint`] method. If a [`Subscriber`]
-/// implementation changes the value returned by its `max_level_hint`
-/// implementation at runtime, then it **must** call this function after that
-/// value changes, in order for the change to be reflected.
-///
-/// [`max_level_hint`]: super::subscriber::Subscriber::max_level_hint
-/// [`Callsite`]: super::callsite::Callsite
-/// [`enabled`]: super::subscriber::Subscriber::enabled
-/// [`Interest::sometimes()`]: super::subscriber::Interest::sometimes
-/// [`Subscriber`]: super::subscriber::Subscriber
-pub fn rebuild_interest_cache() {
-    let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
-    let callsites = &REGISTRY.callsites;
-    rebuild_interest(callsites, &mut dispatchers);
-}
+#[cfg(feature = "std")]
+pub(crate) use self::inner::register_dispatch;
+pub use self::inner::{rebuild_interest_cache, register};
 
-/// Register a new `Callsite` with the global registry.
-///
-/// This should be called once per callsite after the callsite has been
-/// constructed.
-pub fn register(registration: &'static Registration) {
-    let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
-    rebuild_callsite_interest(&mut dispatchers, registration.callsite);
-    REGISTRY.callsites.push(registration);
-}
+#[cfg(feature = "std")]
+mod inner {
+    use super::*;
+    use std::vec::Vec;
+    type Dispatchers = Vec<dispatcher::Registrar>;
 
-pub(crate) fn register_dispatch(dispatch: &Dispatch) {
-    let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
-    let callsites = &REGISTRY.callsites;
+    struct Registry {
+        callsites: Callsites,
+        dispatchers: Mutex<Dispatchers>,
+    }
 
-    dispatchers.push(dispatch.registrar());
+    lazy_static! {
+        static ref REGISTRY: Registry = Registry {
+            callsites: LinkedList::new(),
+            dispatchers: Mutex::new(Vec::new()),
+        };
+    }
 
-    rebuild_interest(callsites, &mut dispatchers);
-}
+    /// Clear and reregister interest on every [`Callsite`]
+    ///
+    /// This function is intended for runtime reconfiguration of filters on traces
+    /// when the filter recalculation is much less frequent than trace events are.
+    /// The alternative is to have the [`Subscriber`] that supports runtime
+    /// reconfiguration of filters always return [`Interest::sometimes()`] so that
+    /// [`enabled`] is evaluated for every event.
+    ///
+    /// This function will also re-compute the global maximum level as determined by
+    /// the [`max_level_hint`] method. If a [`Subscriber`]
+    /// implementation changes the value returned by its `max_level_hint`
+    /// implementation at runtime, then it **must** call this function after that
+    /// value changes, in order for the change to be reflected.
+    ///
+    /// [`max_level_hint`]: super::subscriber::Subscriber::max_level_hint
+    /// [`Callsite`]: super::callsite::Callsite
+    /// [`enabled`]: super::subscriber::Subscriber::enabled
+    /// [`Interest::sometimes()`]: super::subscriber::Interest::sometimes
+    /// [`Subscriber`]: super::subscriber::Subscriber
+    pub fn rebuild_interest_cache() {
+        let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
+        let callsites = &REGISTRY.callsites;
+        rebuild_interest(callsites, &mut dispatchers);
+    }
 
-fn rebuild_callsite_interest(
-    dispatchers: &mut MutexGuard<'_, Vec<dispatcher::Registrar>>,
-    callsite: &'static dyn Callsite,
-) {
-    let meta = callsite.metadata();
-
-    // Iterate over the subscribers in the registry, and — if they are
-    // active — register the callsite with them.
-    let mut interests = dispatchers.iter().filter_map(|registrar| {
-        registrar
-            .upgrade()
-            .map(|dispatch| dispatch.register_callsite(meta))
-    });
-
-    // Use the first subscriber's `Interest` as the base value.
-    let interest = if let Some(interest) = interests.next() {
-        // Combine all remaining `Interest`s.
-        interests.fold(interest, Interest::and)
-    } else {
-        // If nobody was interested in this thing, just return `never`.
-        Interest::never()
-    };
-
-    callsite.set_interest(interest)
-}
+    /// Register a new `Callsite` with the global registry.
+    ///
+    /// This should be called once per callsite after the callsite has been
+    /// constructed.
+    pub fn register(registration: &'static Registration) {
+        let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
+        rebuild_callsite_interest(&mut dispatchers, registration.callsite);
+        REGISTRY.callsites.push(registration);
+    }
 
-fn rebuild_interest(
-    callsites: &Callsites,
-    dispatchers: &mut MutexGuard<'_, Vec<dispatcher::Registrar>>,
-) {
-    let mut max_level = LevelFilter::OFF;
-    dispatchers.retain(|registrar| {
-        if let Some(dispatch) = registrar.upgrade() {
-            // If the subscriber did not provide a max level hint, assume
-            // that it may enable every level.
-            let level_hint = dispatch.max_level_hint().unwrap_or(LevelFilter::TRACE);
-            if level_hint > max_level {
-                max_level = level_hint;
-            }
-            true
+    pub(crate) fn register_dispatch(dispatch: &Dispatch) {
+        let mut dispatchers = REGISTRY.dispatchers.lock().unwrap();
+        let callsites = &REGISTRY.callsites;
+
+        dispatchers.push(dispatch.registrar());
+
+        rebuild_interest(callsites, &mut dispatchers);
+    }
+
+    fn rebuild_callsite_interest(
+        dispatchers: &mut MutexGuard<'_, Vec<dispatcher::Registrar>>,
+        callsite: &'static dyn Callsite,
+    ) {
+        let meta = callsite.metadata();
+
+        // Iterate over the subscribers in the registry, and — if they are
+        // active — register the callsite with them.
+        let mut interests = dispatchers.iter().filter_map(|registrar| {
+            registrar
+                .upgrade()
+                .map(|dispatch| dispatch.register_callsite(meta))
+        });
+
+        // Use the first subscriber's `Interest` as the base value.
+        let interest = if let Some(interest) = interests.next() {
+            // Combine all remaining `Interest`s.
+            interests.fold(interest, Interest::and)
         } else {
-            false
-        }
-    });
+            // If nobody was interested in this thing, just return `never`.
+            Interest::never()
+        };
 
-    callsites.for_each(|reg| rebuild_callsite_interest(dispatchers, reg.callsite));
+        callsite.set_interest(interest)
+    }
+
+    fn rebuild_interest(
+        callsites: &Callsites,
+        dispatchers: &mut MutexGuard<'_, Vec<dispatcher::Registrar>>,
+    ) {
+        let mut max_level = LevelFilter::OFF;
+        dispatchers.retain(|registrar| {
+            if let Some(dispatch) = registrar.upgrade() {
+                // If the subscriber did not provide a max level hint, assume
+                // that it may enable every level.
+                let level_hint = dispatch.max_level_hint().unwrap_or(LevelFilter::TRACE);
+                if level_hint > max_level {
+                    max_level = level_hint;
+                }
+                true
+            } else {
+                false
+            }
+        });
 
-    LevelFilter::set_max(max_level);
+        callsites.for_each(|reg| rebuild_callsite_interest(dispatchers, reg.callsite));
+
+        LevelFilter::set_max(max_level);
+    }
+}
+
+#[cfg(not(feature = "std"))]
+mod inner {
+    use super::*;
+    static REGISTRY: Callsites = LinkedList::new();
+
+    /// Clear and reregister interest on every [`Callsite`]
+    ///
+    /// This function is intended for runtime reconfiguration of filters on traces
+    /// when the filter recalculation is much less frequent than trace events are.
+    /// The alternative is to have the [`Subscriber`] that supports runtime
+    /// reconfiguration of filters always return [`Interest::sometimes()`] so that
+    /// [`enabled`] is evaluated for every event.
+    ///
+    /// This function will also re-compute the global maximum level as determined by
+    /// the [`max_level_hint`] method. If a [`Subscriber`]
+    /// implementation changes the value returned by its `max_level_hint`
+    /// implementation at runtime, then it **must** call this function after that
+    /// value changes, in order for the change to be reflected.
+    ///
+    /// [`max_level_hint`]: super::subscriber::Subscriber::max_level_hint
+    /// [`Callsite`]: super::callsite::Callsite
+    /// [`enabled`]: super::subscriber::Subscriber::enabled
+    /// [`Interest::sometimes()`]: super::subscriber::Interest::sometimes
+    /// [`Subscriber`]: super::subscriber::Subscriber
+    pub fn rebuild_interest_cache() {
+        rebuild_interest(&REGISTRY, crate::dispatcher::get_global());
+    }
+
+    /// Register a new `Callsite` with the global registry.
+    ///
+    /// This should be called once per callsite after the callsite has been
+    /// constructed.
+    pub fn register(registration: &'static Registration) {
+        rebuild_callsite_interest(crate::dispatcher::get_global(), registration.callsite);
+        REGISTRY.push(registration);
+    }
+
+    fn rebuild_callsite_interest(dispatcher: &'static Dispatch, callsite: &'static dyn Callsite) {
+        let meta = callsite.metadata();
+
+        callsite.set_interest(dispatcher.register_callsite(meta))
+    }
+
+    fn rebuild_interest(callsites: &Callsites, dispatcher: &dyn Subscriber) {
+        let mut max_level = LevelFilter::OFF;
+        // If the subscriber did not provide a max level hint, assume
+        // that it may enable every level.
+        let level_hint = dispatcher.max_level_hint().unwrap_or(LevelFilter::TRACE);
+
+        callsites.for_each(|reg| rebuild_callsite_interest(dispatcher, reg.callsite));
+
+        LevelFilter::set_max(max_level);
+    }
 }
 
 // ===== impl Identifier =====
@@ -222,17 +287,19 @@ impl fmt::Debug for Registration {
 // ===== impl LinkedList =====
 
 /// An intrusive atomic push-only linked list.
-struct LinkedList {
-    head: AtomicPtr<Registration>,
+struct LinkedList<T = &'static dyn Callsite> {
+    head: AtomicPtr<Registration<T>>,
 }
 
-impl LinkedList {
-    fn new() -> Self {
+impl<T> LinkedList<T> {
+    const fn new() -> Self {
         LinkedList {
             head: AtomicPtr::new(ptr::null_mut()),
         }
     }
+}
 
+impl LinkedList {
     fn for_each(&self, mut f: impl FnMut(&'static Registration)) {
         let mut head = self.head.load(Ordering::Acquire);