initial change

Author: michael-weigelt

src/ion/data_structures.rs

@@ -444,6 +444,53 @@ impl core::ops::IndexMut<VReg> for VRegs {
     }
 }
 
+/// A dedup set of `LiveBundleIndex` values that avoids hashing.
+///
+/// Each bundle index is mapped to a slot in a dense array holding the
+/// generation at which it was last inserted. `clear` simply bumps the
+/// current generation (O(1) in the common case), and `insert` is a
+/// single bounds-checked compare-and-store. This is a drop-in
+/// replacement for the previous `FxHashSet<LiveBundleIndex>` that is
+/// much cheaper when a bundle conflicts with many others (e.g. a
+/// function with many locals).
+#[derive(Clone, Debug, Default)]
+pub struct ConflictSet {
+    // Generation at which each bundle was last inserted. The value `0`
+    // means "never inserted"; `generation` is therefore always >= 1
+    // after the first `clear`.
+    stamps: Vec<u32>,
+    generation: u32,
+}
+
+impl ConflictSet {
+    /// Empty the set. O(1) except on the rare generation wraparound.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.generation = self.generation.wrapping_add(1);
+        if self.generation == 0 {
+            // Wrapped around; reset stamps so stale entries don't read
+            // as present, and skip the reserved `0` generation.
+            self.stamps.iter_mut().for_each(|s| *s = 0);
+            self.generation = 1;
+        }
+    }
+
+    /// Insert `bundle`. Returns `true` if it was not already present.
+    #[inline]
+    pub fn insert(&mut self, bundle: LiveBundleIndex) -> bool {
+        let idx = bundle.index();
+        if idx >= self.stamps.len() {
+            self.stamps.resize(idx + 1, 0);
+        }
+        if self.stamps[idx] == self.generation {
+            false
+        } else {
+            self.stamps[idx] = self.generation;
+            true
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct Ctx {
     pub(crate) cfginfo: CFGInfo,
@@ -484,9 +531,10 @@ pub struct Ctx {
     pub(crate) debug_annotations: FxHashMap<ProgPoint, Vec<String>>,
     pub(crate) annotations_enabled: bool,
 
-    // Cached allocation for `try_to_allocate_bundle_to_reg` to avoid allocating
-    // a new HashSet on every call.
-    pub(crate) conflict_set: FxHashSet<LiveBundleIndex>,
+    // Scratch dedup set for `try_to_allocate_bundle_to_reg`, reused
+    // across calls. Uses generation stamping to avoid hashing and to
+    // make clearing O(1).
+    pub(crate) conflict_set: ConflictSet,
 
     // Output:
     pub output: Output,