Reach parity with re2 by being less of an idiot

As hinted to in the previous commit, I completely missed the
significance of

    using IntMap = SparseArray<int>;

the first time around and just used whatever worked, but turns out
that was the entire source of my trouble: `IntMap` is just two array
lookups (and a few checks) to find an entry, not an entire siphash
hash, that is a ton cheaper.

Eventually we might want to implement a specialised version for our
exact needs (as we're still going through an entire hashing and entry
lookup machinery we don't need to), but for now get somewhat close
using an `IndexSet<NoHashHasher>`: `IndexSet` provides the ordering
and fast iteration, and NoHash provides a *nearly* free hashing, and
since the inputs are the output of aho and a few other processes it's
unlikely to be very adversarial, at least in a problematic way.

Also as noted previously, don't even bother for the counts, just use a
vec as that's the only bit that's needed. Tried to use a
stack-allocated TinyVec but that turns out to consistently be ~5%
slower, with ~7% more cycles needed (though only 2% more
instructions).

Here's the `time(1)` report after this change:

```
       46.63 real        46.25 user         0.03 sys
           143327232  maximum resident set size
                   0  average shared memory size
                   0  average unshared data size
                   0  average unshared stack size
                8884  page reclaims
                   0  page faults
                   0  swaps
                   0  block input operations
                   0  block output operations
                   0  messages sent
                   0  messages received
                   0  signals received
                   0  voluntary context switches
                 131  involuntary context switches
        498048446439  instructions retired
        149096223231  cycles elapsed
           139855488  peak memory footprint
```

Interestingly while the total runtime is about on par with re2 (even
more so if we consider that the rust script takes ~0.1s on loading and
compiling the prefilters) rust-regex now retires 10% less instructions
and burns 1.5% less cycles than re2. So it likely still has memory
access issues, most likely from misusing `IndexSet`

Also it's improved from 3.14 IPC to 3.34, which is great, but the re2
script is at 3.67. In all honesty I don't know where that would come
from, I assume from having more expensive instructions like modulos
for the hashset.

At least it doesn't look like the branches are too much of an issue...
Also I tried looking at using `get_unchecked` for the counts in case
that did something, it does not (at least not consistently), so
probably not something I need to investigate in the future even if I
will undoubtedly forget.

Author: masklinn

Diff for: regex-filtered/Cargo.toml

@@ -16,10 +16,12 @@ repository = "https://github.com/ua-parser/uap-rust/"
 aho-corasick = "1.1.3"
 indexmap = "2.2.6"
 itertools = "0.13.0"
+nohash = "0.2.0"
 regex = "1.10.4"
 regex-syntax = "0.8.3"
 
 [dev-dependencies]
+clap = { version = "4.5.7", features = ["derive"] }
 criterion = "0.5.1"
 
 [[bench]]

Diff for: regex-filtered/src/mapper.rs

@@ -1,4 +1,3 @@
-use std::collections::{HashMap, HashSet};
 use std::fmt::Display;
 use std::fmt::Formatter;
 
@@ -192,7 +191,7 @@ impl Display for Mapper {
         writeln!(f, "#Unique Atoms: {}", self.atom_to_entry.len())?;
         for (i, e) in self.atom_to_entry.iter().copied().enumerate() {
             writeln!(f, "\tatom {i} -> entry {e}")?;
-            for r in self.propagate_match([e].into()) {
+            for r in self.propagate_match(&mut FromIterator::from_iter([e])) {
                 writeln!(f, "\t\tregex {r}")?;
             }
         }
@@ -236,6 +235,8 @@ struct Entry {
     /// regexps that are triggered.
     regexps: Vec<usize>,
 }
+
+type Set = IndexSet<usize, nohash::BuildNoHashHasher<usize>>;
 pub struct Mapper {
     /// Number of regexes covered by the mapper
     regexp_count: usize,
@@ -250,26 +251,28 @@ pub struct Mapper {
 }
 impl Mapper {
     // name is shit and also needs to see if we can generate stuff on the fly
-    pub fn atom_to_re(&self, atoms: impl IntoIterator<Item = usize>) -> Vec<usize> {
-        let matched_atom_ids = atoms
-            .into_iter()
-            .map(|idx| self.atom_to_entry[idx])
-            .collect();
-        let regexps_map = self.propagate_match(matched_atom_ids);
-
-        let mut regexps = Vec::with_capacity(regexps_map.len() + self.unfiltered.len());
+    pub fn atom_to_re(&self, atoms: impl IntoIterator<Item = usize>) -> Set {
+        let mut matched_atom_ids = IndexSet::with_capacity_and_hasher(
+            self.entries.len(),
+            nohash::BuildNoHashHasher::default(),
+        );
+        matched_atom_ids.extend(atoms.into_iter().map(|idx| self.atom_to_entry[idx]));
+
+        let mut regexps = self.propagate_match(&mut matched_atom_ids);
+
         regexps.extend(&self.unfiltered);
-        regexps.extend(regexps_map);
 
         regexps.sort_unstable();
         regexps
     }
 
-    fn propagate_match(&self, mut work: IndexSet<usize>) -> HashSet<usize> {
-        work.reserve(self.entries.len() - work.len());
-        let mut count = HashMap::with_capacity(self.entries.len());
+    fn propagate_match(&self, work: &mut Set) -> Set {
+        let mut count = vec![0;self.entries.len()];
 
-        let mut regexps = HashSet::with_capacity(self.regexp_count);
+        let mut regexps = IndexSet::with_capacity_and_hasher(
+            self.regexp_count,
+            nohash::BuildNoHashHasher::default(),
+        );
 
         let mut i = 0;
         while i < work.len() {
@@ -284,7 +287,8 @@ impl Mapper {
                 let parent = &self.entries[j];
                 // Delay until all the children have succeeded.
                 if parent.propagate_up_at_count > 1 {
-                    let c = count.entry(j).and_modify(|e| *e += 1).or_insert(1);
+                    let c = &mut count[j];
+                    *c += 1;
                     if *c < parent.propagate_up_at_count {
                         continue;
                     }
@@ -337,8 +341,8 @@ mod test {
 
         assert_eq!(m.entries.len(), 3);
         assert_eq!(&m.atom_to_entry, &[0, 1]);
-        assert_eq!(m.propagate_match([0].into()), [0].into(),);
-        assert_eq!(m.propagate_match([1].into()), [0].into(),);
+        assert_eq!(m.propagate_match(&mut FromIterator::from_iter([0])), [0].into(),);
+        assert_eq!(m.propagate_match(&mut FromIterator::from_iter([1])), [0].into(),);
     }
 
     fn check_patterns(patterns: &'static [&'static str], expected: &'static [&'static str]) {