cleanup(profiling): consolidate heap-live value indices and reduce duplication

Extract ValueIndices struct, deduplicate values construction, and
optimize string-ID label handling to skip resolving excluded labels.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: realFlowControl

libdd-profiling/src/internal/heap_live.rs

@@ -15,20 +15,37 @@ use std::hash::BuildHasherDefault;
 /// `reset_and_return_previous()`.
 type FxBuildHasher = BuildHasherDefault<rustc_hash::FxHasher>;
 
-pub(crate) struct HeapLiveState {
-    pub tracked: HashMap<u64, TrackedAlloc, FxBuildHasher>,
-    pub max_tracked: usize,
-    pub excluded_labels: Vec<Box<str>>,
+/// Indices into the sample values array for reading/writing heap-live fields.
+struct ValueIndices {
     /// Index of alloc-size in the sample values array (to read allocation size).
-    alloc_size_idx: usize,
+    alloc_size: usize,
     /// Index of heap-live-samples in the sample values array (to write 1).
-    heap_live_samples_idx: usize,
+    heap_live_samples: usize,
     /// Index of heap-live-size in the sample values array (to write the size).
-    heap_live_size_idx: usize,
+    heap_live_size: usize,
     /// Total number of values per sample.
     num_values: usize,
 }
 
+impl ValueIndices {
+    /// Build a heap-live values vector: all zeros except heap-live-samples=1
+    /// and heap-live-size=alloc_size (read from the original sample).
+    fn build_values(&self, sample_values: &[i64]) -> Vec<i64> {
+        let alloc_size = sample_values.get(self.alloc_size).copied().unwrap_or(0);
+        let mut values = vec![0i64; self.num_values];
+        values[self.heap_live_samples] = 1;
+        values[self.heap_live_size] = alloc_size;
+        values
+    }
+}
+
+pub(crate) struct HeapLiveState {
+    pub tracked: HashMap<u64, TrackedAlloc, FxBuildHasher>,
+    pub max_tracked: usize,
+    pub excluded_labels: Vec<Box<str>>,
+    indices: ValueIndices,
+}
+
 /// A single tracked live allocation with owned frame/label/values data.
 pub(crate) struct TrackedAlloc {
     pub frames: Vec<OwnedFrame>,
@@ -49,10 +66,12 @@ impl HeapLiveState {
             tracked: HashMap::with_capacity_and_hasher(max_tracked, FxBuildHasher::default()),
             max_tracked,
             excluded_labels: excluded_labels.iter().map(|s| Box::from(*s)).collect(),
-            alloc_size_idx,
-            heap_live_samples_idx,
-            heap_live_size_idx,
-            num_values,
+            indices: ValueIndices {
+                alloc_size: alloc_size_idx,
+                heap_live_samples: heap_live_samples_idx,
+                heap_live_size: heap_live_size_idx,
+                num_values,
+            },
         }
     }
 
@@ -64,14 +83,7 @@ impl HeapLiveState {
         if self.tracked.len() >= self.max_tracked {
             return false;
         }
-        let alloc = TrackedAlloc::from_api_sample(
-            sample,
-            &self.excluded_labels,
-            self.alloc_size_idx,
-            self.heap_live_samples_idx,
-            self.heap_live_size_idx,
-            self.num_values,
-        );
+        let alloc = TrackedAlloc::from_api_sample(sample, &self.excluded_labels, &self.indices);
         self.tracked.insert(ptr, alloc);
         true
     }
@@ -92,10 +104,7 @@ impl HeapLiveState {
             sample,
             storage,
             &self.excluded_labels,
-            self.alloc_size_idx,
-            self.heap_live_samples_idx,
-            self.heap_live_size_idx,
-            self.num_values,
+            &self.indices,
         )?;
         self.tracked.insert(ptr, alloc);
         Ok(true)
@@ -107,14 +116,15 @@ impl HeapLiveState {
     }
 }
 
+fn is_excluded(excluded_labels: &[Box<str>], key: &str) -> bool {
+    excluded_labels.iter().any(|ex| ex.as_ref() == key)
+}
+
 impl TrackedAlloc {
     fn from_api_sample(
         sample: &api::Sample,
         excluded_labels: &[Box<str>],
-        alloc_size_idx: usize,
-        heap_live_samples_idx: usize,
-        heap_live_size_idx: usize,
-        num_values: usize,
+        indices: &ValueIndices,
     ) -> Self {
         let frames = sample
             .locations
@@ -129,7 +139,7 @@ impl TrackedAlloc {
         let labels = sample
             .labels
             .iter()
-            .filter(|l| !excluded_labels.iter().any(|ex| ex.as_ref() == l.key))
+            .filter(|l| !is_excluded(excluded_labels, l.key))
             .map(|l| OwnedLabel {
                 key: l.key.into(),
                 str_value: l.str.into(),
@@ -138,29 +148,18 @@ impl TrackedAlloc {
             })
             .collect();
 
-        // Construct heap-live-only values: all zeros except the heap-live
-        // fields. The allocation size is read from the original sample's
-        // alloc-size slot.
-        let alloc_size = sample.values.get(alloc_size_idx).copied().unwrap_or(0);
-        let mut values = vec![0i64; num_values];
-        values[heap_live_samples_idx] = 1;
-        values[heap_live_size_idx] = alloc_size;
-
         TrackedAlloc {
             frames,
             labels,
-            values,
+            values: indices.build_values(sample.values),
         }
     }
 
     fn from_string_id_sample(
         sample: &api::StringIdSample,
         storage: &ManagedStringStorage,
         excluded_labels: &[Box<str>],
-        alloc_size_idx: usize,
-        heap_live_samples_idx: usize,
-        heap_live_size_idx: usize,
-        num_values: usize,
+        indices: &ValueIndices,
     ) -> anyhow::Result<Self> {
         let frames = sample
             .locations
@@ -174,37 +173,24 @@ impl TrackedAlloc {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let labels = sample
-            .labels
-            .iter()
-            .map(|l| -> anyhow::Result<OwnedLabel> {
-                Ok(OwnedLabel {
-                    key: resolve_managed_string(storage, l.key)?,
-                    str_value: resolve_managed_string(storage, l.str)?,
-                    num: l.num,
-                    num_unit: resolve_managed_string(storage, l.num_unit)?,
-                })
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let labels = labels
-            .into_iter()
-            .filter(|l| {
-                !excluded_labels
-                    .iter()
-                    .any(|ex| ex.as_ref() == l.key.as_ref())
-            })
-            .collect();
-
-        let alloc_size = sample.values.get(alloc_size_idx).copied().unwrap_or(0);
-        let mut values = vec![0i64; num_values];
-        values[heap_live_samples_idx] = 1;
-        values[heap_live_size_idx] = alloc_size;
+        let mut labels = Vec::with_capacity(sample.labels.len());
+        for l in &sample.labels {
+            let key = resolve_managed_string(storage, l.key)?;
+            if is_excluded(excluded_labels, &key) {
+                continue;
+            }
+            labels.push(OwnedLabel {
+                key,
+                str_value: resolve_managed_string(storage, l.str)?,
+                num: l.num,
+                num_unit: resolve_managed_string(storage, l.num_unit)?,
+            });
+        }
 
         Ok(TrackedAlloc {
             frames,
             labels,
-            values,
+            values: indices.build_values(sample.values),
         })
     }
 }