Improve performance by indexing addresses

Author: Your Name

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rbase"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 repository = "https://github.com/WorksButNotTested/rbase.git"
 authors = [ "WorksButNotTested" ]

Cargo.toml

@@ -0,0 +1,2 @@
+MD5SUM: bf520953defc78434726f4794376b8e5
+BASE: 0xc0208000

data/Image-arm32le.txt

@@ -0,0 +1,2 @@
+MD5SUM: 5f895efe5fe77cebb790690b915370e0
+BASE: 0xffffffc000080000

data/Image-arm64be.txt

@@ -1,13 +1,13 @@
 use {
-    crate::progress::Progress,
+    crate::{progress::Progress, PAGE_OFFSET_MASK},
     dashmap::DashMap,
     indicatif::ParallelProgressIterator,
     rayon::iter::{IntoParallelRefIterator, ParallelIterator},
-    std::{hash::Hash, mem::size_of, num::TryFromIntError},
+    std::{hash::Hash, mem::size_of, num::TryFromIntError, ops::BitAnd},
 };
 
 pub struct Addresses<T> {
-    addresses: Vec<T>,
+    addresses: DashMap<T, Vec<T>>,
 }
 
 impl<
@@ -18,6 +18,7 @@ impl<
             + PartialEq
             + Eq
             + Hash
+            + BitAnd<Output = T>
             + TryFrom<usize, Error = TryFromIntError>,
     > Addresses<T>
 {
@@ -39,31 +40,35 @@ impl<
         map
     }
 
-    fn get_unique_addresses(frequencies: DashMap<T, usize>) -> Vec<T> {
+    fn get_unique_addresses_by_page_offset(frequencies: DashMap<T, usize>) -> DashMap<T, Vec<T>> {
         let pb = Progress::get("Finding unique addresses", frequencies.len());
+        let map = DashMap::<T, Vec<T>>::new();
         frequencies
             .par_iter()
             .progress_with(pb)
-            .filter_map(|r| {
-                let (&k, &v) = r.pair();
-                if v == 1 {
-                    Some(k)
+            .filter(|r| *r.value() != 1)
+            .for_each(|r| {
+                let &k = r.key();
+                let offset = k & T::try_from(PAGE_OFFSET_MASK).unwrap();
+                if let Some(mut v) = map.get_mut(&offset) {
+                    v.push(k);
                 } else {
-                    None
+                    map.insert(k, vec![k]);
                 }
-            })
-            .collect()
+            });
+        map
     }
 
     pub fn new<F: Fn(&[u8]) -> T + Sync + Send + Copy>(bytes: &[u8], convert: F) -> Self {
         let frequencies = Self::get_address_frequencies(bytes, convert);
         println!("Found: {:?} addresses", frequencies.len());
-        let unique = Self::get_unique_addresses(frequencies);
-        println!("Found: {:?} unique addresses", unique.len());
-        Self { addresses: unique }
+
+        let addresses = Self::get_unique_addresses_by_page_offset(frequencies);
+        println!("Found: {:?} unique addresses", addresses.len());
+        Self { addresses }
     }
 
-    pub fn get_addresses(&self) -> &Vec<T> {
+    pub fn get_addresses(&self) -> &DashMap<T, Vec<T>> {
         return &self.addresses;
     }
 }

src/addresses.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{progress::Progress, Addresses, Strings, PAGE_OFFSET_MASK},
+    crate::{progress::Progress, Addresses, Strings},
     dashmap::DashMap,
     indicatif::ParallelProgressIterator,
     rayon::iter::{IntoParallelRefIterator, ParallelIterator},
@@ -34,13 +34,15 @@ impl<
         let list = addresses.get_addresses();
         let pb = Progress::get("Collecting candidate base addresses", list.len());
         let map = DashMap::<T, usize>::new();
-        list.par_iter().progress_with(pb).for_each(|&ptr| {
-            let offset = ptr & T::try_from(PAGE_OFFSET_MASK).unwrap();
-            if let Some(strings) = strings.get().get(&offset) {
+        list.par_iter().progress_with(pb).for_each(|r| {
+            let (offset, addresses) = r.pair();
+            if let Some(strings) = strings.get().get(offset) {
                 for &s in strings.deref() {
-                    if ptr > s {
-                        let base = ptr - s;
-                        *map.entry(base).or_insert(0) += 1;
+                    for &a in addresses.deref() {
+                        if a > s {
+                            let base = a - s;
+                            *map.entry(base).or_insert(0) += 1;
+                        }
                     }
                 }
             }