style: fix clippy lints

Author: morrisonlevi

profiling/src/bitset.rs

@@ -1,20 +1,19 @@
 // Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
 
-use std::cell::Cell;
 use std::hash::{Hash, Hasher};
 
 /// Very simple bitset which doesn't allocate, and doesn't change after it has
 /// been created.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[repr(transparent)]
 pub struct BitSet {
-    bits: Cell<u32>,
+    bits: u32,
 }
 
 impl Hash for BitSet {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        let bits = self.bits.get();
+        let bits = self.bits;
         bits.count_ones().hash(state);
         bits.hash(state);
     }
@@ -24,47 +23,25 @@ impl BitSet {
     pub const MAX: usize = u32::BITS as usize;
 
     /// Creates a new bitset from the provided number.
-    pub const fn new(bitset: u32) -> Self {
-        Self {
-            bits: Cell::new(bitset),
-        }
-    }
-
-    /// Creates a new bitset from the iterator.
-    ///
-    /// # Panics
-    ///
-    /// Panics if an item is out of the range of the bitset e.g. [`u32::MAX`].
-    pub fn from_iter<I: Iterator<Item = usize>>(iter: I) -> BitSet {
-        let mut bits = 0;
-        let mut insert = |bit| {
-            // todo: add non-panic API
-            assert!(bit < BitSet::MAX);
-            bits |= 1u32 << bit;
-        };
-        for bit in iter {
-            insert(bit);
-        }
-        BitSet {
-            bits: Cell::new(bits),
-        }
+    pub const fn new(bits: u32) -> Self {
+        Self { bits }
     }
 
     #[inline]
     pub fn len(&self) -> usize {
-        self.bits.get().count_ones() as usize
+        self.bits.count_ones() as usize
     }
 
     #[inline]
     pub fn is_empty(&self) -> bool {
-        self.bits.get() == 0
+        self.bits == 0
     }
 
     #[inline]
     pub fn contains(&self, bit: usize) -> bool {
         if bit < 32 {
             let mask = 1u32 << bit;
-            let masked = self.bits.get() & mask;
+            let masked = self.bits & mask;
             masked != 0
         } else {
             false
@@ -76,6 +53,26 @@ impl BitSet {
     }
 }
 
+impl FromIterator<usize> for BitSet {
+    /// Creates a new bitset from the iterator.
+    ///
+    /// # Panics
+    ///
+    /// Panics if an item is out of the range of the bitset e.g. [`u32::MAX`].
+    fn from_iter<I: IntoIterator<Item = usize>>(iter: I) -> BitSet {
+        let mut bits = 0;
+        let mut insert = |bit| {
+            // todo: add non-panic API
+            assert!(bit < BitSet::MAX);
+            bits |= 1u32 << bit;
+        };
+        for bit in iter {
+            insert(bit);
+        }
+        BitSet { bits }
+    }
+}
+
 pub struct BitSetIter {
     bitset: u32,
     offset: u32,
@@ -84,7 +81,7 @@ pub struct BitSetIter {
 
 impl BitSetIter {
     pub fn new(bitset: &BitSet) -> BitSetIter {
-        let bitset = bitset.bits.get();
+        let bitset = bitset.bits;
         let offset = 0;
         let end = {
             let num_bits = u32::BITS;

profiling/src/inlinevec.rs

@@ -18,6 +18,13 @@ const fn assert_capacity(n: usize) {
         panic!("InlineVec only supports up to u8::MAX capacities");
     }
 }
+
+impl<T, const N: usize> Default for InlineVec<T, N> {
+    fn default() -> Self {
+        InlineVec::new()
+    }
+}
+
 impl<T, const N: usize> InlineVec<T, N> {
     pub const fn new() -> Self {
         assert_capacity(N);
@@ -146,7 +153,7 @@ impl<T, const N: usize> InlineVecIter<T, N> {
 impl<T, const N: usize> Drop for InlineVecIter<T, N> {
     fn drop(&mut self) {
         if core::mem::needs_drop::<T>() {
-            let base = unsafe { self.vec.as_mut_ptr() };
+            let base = self.vec.as_mut_ptr();
             for i in self.live_range() {
                 unsafe { base.add(i).drop_in_place() }
             }
@@ -232,7 +239,7 @@ mod tests {
 
     const TEST_INLINE_VEC: InlineVec<bool, 2> = {
         let mut vec = InlineVec::from([false]);
-        if let Err(e) = vec.try_push(true) {
+        if vec.try_push(true).is_err() {
             panic!("expected to be able push another item into the vec")
         }
         vec

profiling/src/lib.rs

@@ -1,13 +1,16 @@
 pub mod bindings;
+pub mod bitset;
 pub mod capi;
+pub mod inlinevec;
+pub mod profiling;
+
 mod clocks;
 mod config;
-mod inlinevec;
 mod logging;
-pub mod profiling;
 mod pthread;
 mod sapi;
 mod thin_str;
+mod vec_ext;
 mod wall_time;
 
 #[cfg(php_run_time_cache)]
@@ -22,10 +25,8 @@ mod io;
 #[cfg(feature = "exception_profiling")]
 mod exception;
 
-mod bitset;
 #[cfg(feature = "timeline")]
 mod timeline;
-mod vec_ext;
 
 use crate::config::{SystemSettings, INITIAL_SYSTEM_SETTINGS};
 use crate::zend::datadog_sapi_globals_request_info;

profiling/src/profiling/mod.rs

@@ -177,6 +177,10 @@ pub struct LocalRootSpanResourceMessage {
     pub resource: String,
 }
 
+// Allow large enum variant for now, because we're avoiding an allocation on
+// a hot path. The correct fix is probably to take some kind of
+// `InlineVec<SampleValue>` where `SampleValue` is an enum per profile type.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum ProfilerMessage {
     Cancel,

profiling/src/profiling/samples.rs

@@ -35,8 +35,9 @@ pub const PROFILE_TYPES: [ProfileType; NUM_PROFILE_TYPES] = [
 ///  1. Always enabled types.
 ///  2. On by default types.
 ///  3. Off by default types.
+///
 /// But this doesn't really matter anymore, because the number of sample types
-/// has grown.
+/// has grown and the optimizations used don't work well anymore.
 #[derive(Default, Debug)]
 #[repr(C)]
 pub struct SampleValues {
@@ -65,30 +66,30 @@ pub struct SampleValues {
     pub file_write_size_samples: i64,
 }
 
-/// The sample values for a given profile type.
-///
-/// The repr(u8) is valid even though this holds data larger than u8; see the
-/// documentation on primitive representations:
-/// https://doc.rust-lang.org/reference/type-layout.html#primitive-representations
-///
-/// If the order of the enum is changed, or if variants are added or removed,
-/// then [`PROFILE_TYPES`] needs to be changed.
-#[repr(u8)]
-pub enum SampleValue {
-    WallTime { nanoseconds: i64, count: i64 },
-    CpuTime { nanoseconds: i64 },
-    Alloc { bytes: i64, count: i64 },
-    Timeline { nanoseconds: i64 },
-    Exception { count: i64 },
-    FileIoReadTime { nanoseconds: i64, count: i64 },
-    FileIoWriteTime { nanoseconds: i64, count: i64 },
-    FileIoReadSize { bytes: i64, count: i64 },
-    FileIoWriteSize { bytes: i64, count: i64 },
-    SocketReadTime { nanoseconds: i64, count: i64 },
-    SocketWriteTime { nanoseconds: i64, count: i64 },
-    SocketReadSize { bytes: i64, count: i64 },
-    SocketWriteSize { bytes: i64, count: i64 },
-}
+// /// The sample values for a given profile type.
+// ///
+// /// The repr(u8) is valid even though this holds data larger than u8; see the
+// /// documentation on primitive representations:
+// /// https://doc.rust-lang.org/reference/type-layout.html#primitive-representations
+// ///
+// /// If the order of the enum is changed, or if variants are added or removed,
+// /// then [`PROFILE_TYPES`] needs to be changed (or vice versa)
+// #[repr(u8)]
+// pub enum SampleValue {
+//     WallTime { nanoseconds: i64, count: i64 },
+//     CpuTime { nanoseconds: i64 },
+//     Alloc { bytes: i64, count: i64 },
+//     Timeline { nanoseconds: i64 },
+//     Exception { count: i64 },
+//     FileIoReadTime { nanoseconds: i64, count: i64 },
+//     FileIoWriteTime { nanoseconds: i64, count: i64 },
+//     FileIoReadSize { bytes: i64, count: i64 },
+//     FileIoWriteSize { bytes: i64, count: i64 },
+//     SocketReadTime { nanoseconds: i64, count: i64 },
+//     SocketWriteTime { nanoseconds: i64, count: i64 },
+//     SocketReadSize { bytes: i64, count: i64 },
+//     SocketWriteSize { bytes: i64, count: i64 },
+// }
 
 /// Tracks which profile types are enabled. Since there are 1 or 2 sample
 /// types per profile, it also keeps a bitset for which sample types and
@@ -234,8 +235,8 @@ impl EnabledProfiles {
     pub fn filter<'a>(
         &self,
         sample_values: &'a SampleValues,
-    ) -> SampleIter<i64, impl Iterator<Item = i64> + 'a> {
-        let bitset = self.samples.clone();
+    ) -> SampleIter<impl Iterator<Item = i64> + 'a> {
+        let bitset = self.samples;
         let len = bitset.len();
         let iter =
             sample_values
@@ -252,9 +253,7 @@ impl EnabledProfiles {
         SampleIter { len, iter }
     }
 
-    pub fn enabled_profile_types<'a>(
-        &'a self,
-    ) -> SampleIter<ProfileType, impl Iterator<Item = ProfileType> + 'a> {
+    pub fn enabled_profile_types(&self) -> SampleIter<impl Iterator<Item = ProfileType> + '_> {
         let len = self.num_enabled_profiles();
         let iter = PROFILE_TYPES
             .iter()
@@ -265,9 +264,7 @@ impl EnabledProfiles {
         SampleIter { len, iter }
     }
 
-    pub fn enabled_sample_types<'a>(
-        &'a self,
-    ) -> SampleIter<ValueType, impl Iterator<Item = ValueType> + 'a> {
+    pub fn enabled_sample_types(&self) -> SampleIter<impl Iterator<Item = ValueType> + '_> {
         let len = self.num_enabled_sample_types();
         let iter = self.enabled_profile_types().flatten();
         SampleIter { len, iter }
@@ -399,28 +396,26 @@ const SAMPLE_TYPE_FILE_IO_WRITE_SIZE: ProfileType = ProfileType::from([
     },
 ]);
 
-impl SampleValue {
-    fn discriminant(&self) -> usize {
-        // SAFETY: SampleValue uses a primitive representation.
-        let r#repr = unsafe { *(self as *const Self as *const u8) };
-        r#repr as usize
-    }
-}
-
-impl SampleValue {
-    pub fn sample_types(&self) -> ProfileType {
-        let discriminant = self.discriminant();
-        PROFILE_TYPES[discriminant]
-    }
-}
-
-pub struct SampleIter<T, I: Iterator<Item = T>> {
+// impl SampleValue {
+//     pub fn discriminant(&self) -> usize {
+//         // SAFETY: SampleValue uses a primitive representation.
+//         let r#repr = unsafe { *(self as *const Self as *const u8) };
+//         r#repr as usize
+//     }
+//
+//     pub fn sample_types(&self) -> ProfileType {
+//         let discriminant = self.discriminant();
+//         PROFILE_TYPES[discriminant]
+//     }
+// }
+
+pub struct SampleIter<I: Iterator> {
     len: usize,
     iter: I,
 }
 
-impl<T, I: Iterator<Item = T>> Iterator for SampleIter<T, I> {
-    type Item = T;
+impl<I: Iterator> Iterator for SampleIter<I> {
+    type Item = I::Item;
     fn next(&mut self) -> Option<Self::Item> {
         let next = self.iter.next();
         if next.is_some() {
@@ -435,7 +430,7 @@ impl<T, I: Iterator<Item = T>> Iterator for SampleIter<T, I> {
     }
 }
 
-impl<T, I: Iterator<Item = T>> ExactSizeIterator for SampleIter<T, I> {
+impl<I: Iterator> ExactSizeIterator for SampleIter<I> {
     fn len(&self) -> usize {
         self.len
     }