refactor: replace TinyVec with Vec for improved memory management in multiple modules

Author: Foster Guo

DESIGN.md

@@ -331,7 +331,7 @@ For single-entry simple patterns, the automaton value encodes `rule_idx | (1 <<
 #### Bitmask vs Matrix
 
 - **Bitmask** (≤64 segments, no repeated counts): each AND hit sets bit `offset` in `satisfied_mask` and decrements `remaining_and`. Reaching 0 → satisfied. NOT hits set `not_generation` immediately.
-- **Matrix** (>64 segments or repeated counts): a `TinyVec<[i32; 16]>` counter grid sized `[segments × variants]`. AND cells decrement; NOT cells increment. Threshold crossings tracked per-segment via `matrix_status`.
+- **Matrix** (>64 segments or repeated counts): a `Vec<i32>` counter grid sized `[segments × variants]`. AND cells decrement; NOT cells increment. Threshold crossings tracked per-segment via `matrix_status`.
 
 ```
 Rule parsed from pattern string
@@ -343,7 +343,7 @@ Rule parsed from pattern string
   ≤64 segs, no repeats?  ──► Bitmask (u64 + remaining_and)
         │ NO
         ▼
-                              Matrix (TinyVec counter grid)
+                              Matrix (Vec counter grid)
 ```
 
 ---

matcher_rs/Cargo.toml

@@ -30,7 +30,6 @@ daachorse = "1.0.1"
 mimalloc = { version = "0.1.48", features = ["v3"] }
 serde = { version = "1.0.228", features = ["derive"], optional = true }
 serde_json = { version = "1.0", optional = true }
-tinyvec = { version = "1.11.0", features = ["alloc"] }
 
 [dev-dependencies]
 divan = "0.1.21"

matcher_rs/src/process/graph.rs

@@ -24,8 +24,6 @@
 
 use std::collections::HashSet;
 
-use tinyvec::TinyVec;
-
 use crate::process::{
     process_type::ProcessType,
     step::{TransformStep, get_transform_step},
@@ -47,7 +45,7 @@ pub(crate) struct ProcessTypeBitNode {
     ///
     /// Children represent the next transformation step that follows this one.
     /// Empty for leaf nodes.
-    pub(crate) children: TinyVec<[usize; 4]>,
+    pub(crate) children: Vec<usize>,
     /// Cached reference to the compiled [`TransformStep`] for this node's bit.
     ///
     /// [`None`] only for the root node (which represents the raw input text and
@@ -67,13 +65,8 @@ pub(crate) struct ProcessTypeBitNode {
 
 impl ProcessTypeBitNode {
     /// Returns the estimated heap memory in bytes used by the `children` vec.
-    ///
-    /// Returns 0 when `children` fits in the inline `TinyVec` storage.
     pub(crate) fn heap_bytes(&self) -> usize {
-        match &self.children {
-            TinyVec::Heap(v) => v.capacity() * size_of::<usize>(),
-            _ => 0,
-        }
+        self.children.capacity() * size_of::<usize>()
     }
 }
 
@@ -115,7 +108,7 @@ pub(crate) fn build_process_type_tree(
     let mut process_type_tree = Vec::with_capacity(max_nodes);
     let mut root = ProcessTypeBitNode {
         process_type_bit: ProcessType::None,
-        children: TinyVec::new(),
+        children: Vec::new(),
         step: None,
         pt_index_mask: 0,
     };
@@ -144,7 +137,7 @@ pub(crate) fn build_process_type_tree(
             } else {
                 let child = ProcessTypeBitNode {
                     process_type_bit,
-                    children: TinyVec::new(),
+                    children: Vec::new(),
                     step: Some(get_transform_step(process_type_bit)),
                     pt_index_mask: pt_mask_bit,
                 };

matcher_rs/src/simple_matcher/mod.rs

@@ -21,8 +21,6 @@
 
 use std::{borrow::Cow, fmt, iter::FusedIterator};
 
-use tinyvec::TinyVec;
-
 use crate::process::graph::ProcessTypeBitNode;
 
 mod build;
@@ -405,7 +403,7 @@ impl SimpleMatcher {
         if text.is_empty() {
             return SimpleMatchIter {
                 rules: &self.rules,
-                indices: TinyVec::new(),
+                indices: Vec::new(),
                 front: 0,
                 back: 0,
             };
@@ -446,7 +444,7 @@ impl SimpleMatcher {
 #[must_use]
 pub struct SimpleMatchIter<'a> {
     rules: &'a RuleSet,
-    indices: TinyVec<[usize; 16]>,
+    indices: Vec<usize>,
     front: usize,
     back: usize,
 }

matcher_rs/src/simple_matcher/rule.rs

@@ -12,8 +12,6 @@
 
 use std::{borrow::Cow, collections::HashMap};
 
-use tinyvec::TinyVec;
-
 use super::{
     SimpleResult,
     pattern::{PatternEntry, PatternKind},
@@ -258,8 +256,8 @@ impl RuleSet {
     }
 
     /// Collects indices of satisfied touched rules for iterator construction.
-    pub(super) fn collect_satisfied_indices(&self, ss: &ScanState<'_>) -> TinyVec<[usize; 16]> {
-        let mut indices = TinyVec::new();
+    pub(super) fn collect_satisfied_indices(&self, ss: &ScanState<'_>) -> Vec<usize> {
+        let mut indices = Vec::new();
         for &rule_idx in ss.touched_indices() {
             if ss.rule_is_satisfied(rule_idx) {
                 indices.push(rule_idx);

matcher_rs/src/simple_matcher/search.rs

@@ -28,9 +28,7 @@
 //! static is `#[thread_local]` (no cross-thread sharing) and the functions are
 //! not re-entrant. See [`SIMPLE_MATCH_STATE`] for the full safety argument.
 
-use std::borrow::Cow;
-
-use tinyvec::TinyVec;
+use std::{borrow::Cow, vec};
 
 use super::{
     SimpleMatcher, SimpleResult,
@@ -301,15 +299,13 @@ impl SimpleMatcher {
         // density_flags[i] — non-ASCII byte density for arena index i.
         // density == 0.0 means pure ASCII (used for both engine dispatch and
         // transform correctness: is_noop_on_ascii_input, step.apply).
-        let mut density_flags: TinyVec<[f32; 16]> = TinyVec::new();
+        let mut density_flags: Vec<f32> = Vec::new();
         density_flags.push(root_density);
 
         // Maps tree node index -> arena index for its text.
-        let mut node_arena: TinyVec<[usize; 16]> = TinyVec::new();
-        node_arena.resize(num_variants, 0);
+        let mut node_arena: Vec<usize> = vec![0; num_variants];
         // Maps tree node index -> variant index used in ScanContext::text_index.
-        let mut node_variant: TinyVec<[usize; 16]> = TinyVec::new();
-        node_variant.resize(num_variants, 0);
+        let mut node_variant: Vec<usize> = vec![0; num_variants];
         let mut variant_counter = 1usize;
         let mut stopped = false;
 

matcher_rs/src/simple_matcher/state.rs

@@ -27,8 +27,6 @@
 
 use std::cell::UnsafeCell;
 
-use tinyvec::TinyVec;
-
 /// Per-rule mutable state reused across scans.
 ///
 /// Each rule has one `WordState` slot in [`SimpleMatchState::word_states`],
@@ -96,19 +94,19 @@ pub(super) struct WordState {
 pub(super) struct SimpleMatchState {
     /// Per-rule state slots indexed by rule id.
     pub(super) word_states: Vec<WordState>,
-    /// Per-variant counter matrix for complex rules (one `TinyVec` per rule
+    /// Per-variant counter matrix for complex rules (one `Vec` per rule
     /// index).
     ///
     /// `matrix[rule_idx][segment * num_variants + variant_idx]` holds the
     /// remaining count for that segment in that variant. Initialized lazily
     /// on first touch.
-    pub(super) matrix: Vec<TinyVec<[i32; 16]>>,
-    /// Per-segment completion flags for complex rules (one `TinyVec` per rule
+    pub(super) matrix: Vec<Vec<i32>>,
+    /// Per-segment completion flags for complex rules (one `Vec` per rule
     /// index).
     ///
     /// `matrix_status[rule_idx][segment]` is 0 if the segment is still pending,
     /// 1 if it has been satisfied (AND) or triggered (NOT).
-    pub(super) matrix_status: Vec<TinyVec<[u8; 16]>>,
+    pub(super) matrix_status: Vec<Vec<u8>>,
     /// Rule indices touched during the current scan generation.
     ///
     /// Cleared at the start of each scan in [`prepare`](Self::prepare). Used by
@@ -163,8 +161,8 @@ pub(super) struct ScanState<'a> {
     pub(super) word_states: &'a mut [WordState],
     pub(super) touched_indices: &'a mut Vec<usize>,
     pub(super) resolved_count: usize,
-    pub(super) matrix: &'a mut [TinyVec<[i32; 16]>],
-    pub(super) matrix_status: &'a mut [TinyVec<[u8; 16]>],
+    pub(super) matrix: &'a mut [Vec<i32>],
+    pub(super) matrix_status: &'a mut [Vec<u8>],
     pub(super) generation: u32,
 }
 
@@ -333,8 +331,8 @@ impl SimpleMatchState {
 
         if self.word_states.len() < size {
             self.word_states.resize(size, WordState::default());
-            self.matrix.resize(size, TinyVec::new());
-            self.matrix_status.resize(size, TinyVec::new());
+            self.matrix.resize(size, Vec::new());
+            self.matrix_status.resize(size, Vec::new());
         }
 
         self.touched_indices.clear();
@@ -371,8 +369,8 @@ impl SimpleMatchState {
 #[cold]
 #[inline(never)]
 pub(super) fn init_matrix(
-    flat_matrix: &mut TinyVec<[i32; 16]>,
-    flat_status: &mut TinyVec<[u8; 16]>,
+    flat_matrix: &mut Vec<i32>,
+    flat_status: &mut Vec<u8>,
     segment_counts: &[i32],
     num_variants: usize,
 ) {