Optimize FlatMultiMapBuilder

src/filters/fb_network_builder.rs

@@ -129,7 +129,7 @@ impl<'a> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkFilterListBuilder {
         rule_list: Self,
         builder: &mut EngineFlatBuilder<'a>,
     ) -> WIPOffset<fb::NetworkFilterList<'a>> {
-        let mut filter_map = HashMap::<ShortHash, Vec<WIPOffset<fb::NetworkFilter<'a>>>>::new();
+        let mut filter_map_builder = FlatMultiMapBuilder::with_capacity(rule_list.filters.len());
 
         let mut optimizable = HashMap::<ShortHash, Vec<NetworkFilter>>::new();
 
@@ -158,7 +158,7 @@ impl<'a> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkFilterListBuilder {
 
                 let mut store_filter = |token: ShortHash| {
                     if let Some(flat_filter) = flat_filter {
-                        filter_map.entry(token).or_default().push(flat_filter);
+                        filter_map_builder.insert(token, flat_filter);
                     } else {
                         optimizable
                             .entry(token)
@@ -212,7 +212,7 @@ impl<'a> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkFilterListBuilder {
 
                 for filter in optimized {
                     let flat_filter = FlatSerialize::serialize(&filter, builder);
-                    filter_map.entry(token).or_default().push(flat_filter);
+                    filter_map_builder.insert(token, flat_filter);
                 }
             }
         } else {
@@ -222,8 +222,7 @@ impl<'a> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkFilterListBuilder {
             );
         }
 
-        let flat_filter_map_builder = FlatMultiMapBuilder::from_filter_map(filter_map);
-        let flat_filter_map = FlatMultiMapBuilder::finish(flat_filter_map_builder, builder);
+        let flat_filter_map = FlatMultiMapBuilder::finish(filter_map_builder, builder);
 
         fb::NetworkFilterList::create(
             builder.raw_builder(),

src/flatbuffers/containers/flat_multimap.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, marker::PhantomData};
+use std::marker::PhantomData;
 
 use crate::flatbuffers::containers;
 use containers::flat_serialize::{FlatBuilder, FlatMapBuilderOutput, FlatSerialize};
@@ -85,17 +85,19 @@ where
 
 #[derive(Default)]
 pub(crate) struct FlatMultiMapBuilder<I, V> {
-    map: HashMap<I, Vec<V>>,
+    entries: Vec<(I, V)>,
 }
 
 impl<I: Ord + std::hash::Hash, V> FlatMultiMapBuilder<I, V> {
-    pub fn from_filter_map(map: HashMap<I, Vec<V>>) -> Self {
-        Self { map }
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            entries: Vec::with_capacity(capacity),
+        }
     }
 
     #[allow(dead_code)] // Unused code is allowed during cosmetic filter migration
     pub fn insert(&mut self, key: I, value: V) {
-        self.map.entry(key).or_default().push(value);
+        self.entries.push((key, value));
     }
 
     pub fn finish<'a, B: FlatBuilder<'a>>(
@@ -106,17 +108,14 @@ impl<I: Ord + std::hash::Hash, V> FlatMultiMapBuilder<I, V> {
         I: FlatSerialize<'a, B>,
         V: FlatSerialize<'a, B>,
     {
-        let mut entries: Vec<_> = value.map.into_iter().collect();
-        entries.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
+        let mut entries = value.entries;
+        entries.sort_by(|(a, _), (b, _)| a.cmp(b));
         let mut indexes = Vec::with_capacity(entries.len());
         let mut values = Vec::with_capacity(entries.len());
 
-        for (key, mv) in entries.into_iter() {
-            let index = FlatSerialize::serialize(key, builder);
-            for value in mv.into_iter() {
-                indexes.push(index.clone());
-                values.push(FlatSerialize::serialize(value, builder));
-            }
+        for (key, value) in entries {
+            indexes.push(FlatSerialize::serialize(key, builder));
+            values.push(FlatSerialize::serialize(value, builder));
         }
 
         let indexes_vec = builder.raw_builder().create_vector(&indexes);