A bunch of hacks to make Maglev faster

Author: zhaofengli

sys/lib/libbenchnet/Cargo.toml

@@ -17,6 +17,8 @@ usr = { path = "../../../sys/interfaces/usr", version = "0.1.0" }
 console = { path = "../console", version = "0.1.0" }
 hashbrown = "0.7.2"
 
+sashstore-redleaf = { path = "../sashstore" }
+
 [dependencies.fnv]
 git = "https://github.com/servo/rust-fnv"
 default-features = false

sys/lib/libbenchnet/src/lib.rs

@@ -1001,6 +1001,9 @@ pub fn run_maglev_fwd_udptest_rref(net: &dyn Net, pkt_len: usize) -> Result<()>
     #[cfg(feature = "noop")]
     return Ok(());
 
+    let mut sender_mac = alloc::vec![0x90, 0xe2, 0xba, 0xb5, 0x13, 0x60];
+    let mut our_mac = alloc::vec![0x90, 0xe2, 0xba, 0xb5, 0x15, 0x74];
+
     let batch_sz = BATCH_SIZE;
     let mut maglev = maglev::Maglev::new(0..3);
     let mut rx_submit = RRefDeque::<[u8; 1514], 32>::default();
@@ -1075,11 +1078,17 @@ pub fn run_maglev_fwd_udptest_rref(net: &dyn Net, pkt_len: usize) -> Result<()>
                 }
             };
 
+            /*
             if let Some(_) = backend {
                 for i in 0..6 {
                     (pkt).swap(i, 6 + i);
                 }
             }
+            */
+            unsafe {
+                ptr::copy(our_mac.as_ptr(), pkt.as_mut_ptr().offset(6), our_mac.capacity());
+                ptr::copy(sender_mac.as_ptr(), pkt.as_mut_ptr().offset(0), sender_mac.capacity());
+            }
         }
 
         mswap_elapsed += rdtsc() - ms_start;
@@ -1125,6 +1134,8 @@ pub fn run_maglev_fwd_udptest_rref(net: &dyn Net, pkt_len: usize) -> Result<()>
 
     let adj_runtime = elapsed as f64 / CPU_MHZ as f64;
 
+    maglev.dump_stats();
+
     if sum > 0 && fwd_sum > 0 {
         println!("runtime: {:.2} seconds", adj_runtime);
 

sys/lib/libbenchnet/src/maglev.rs

@@ -27,10 +27,18 @@ use fnv::FnvHasher;
 use twox_hash::XxHash;
 use lru::LruCache;
 
+use core::default::Default;
+
 use hashbrown::HashMap;
+use sashstore_redleaf::indexmap::Index;
+
+use console::println;
 
 const TABLE_SIZE: usize = 65537;
-const CACHE_SIZE: usize = 1000;
+const CACHE_SIZE: usize = 1 << 24;
+
+static mut HIT_COUNT: usize = 0;
+static mut HASHMAP_TOTAL: usize = 0;
 
 type FnvHashFactory = BuildHasherDefault<FnvHasher>;
 type XxHashFactory = BuildHasherDefault<XxHash>;
@@ -39,8 +47,9 @@ type XxHashFactory = BuildHasherDefault<XxHash>;
 pub struct Maglev<N> {
     pub nodes: Vec<N>,
     pub lookup: Vec<isize>,
-    pub cache: RefCell<HashMap<usize, usize>>,
     // pub cache: RefCell<LruCache<usize, usize>>, // hash -> backend
+    // pub cache: RefCell<HashMap<usize, usize, FnvHashFactory>>,
+    pub cache: RefCell<Index<usize, usize>>,
 }
 
 impl<N: Hash + Eq> Maglev<N> {
@@ -49,7 +58,8 @@ impl<N: Hash + Eq> Maglev<N> {
         let nodes = nodes.into_iter().collect::<Vec<_>>();
         let lookup = Self::populate(&nodes);
         // let cache = RefCell::new(LruCache::new(CACHE_SIZE));
-        let cache = RefCell::new(HashMap::with_capacity(3_000_000));
+        // let cache = RefCell::new(HashMap::with_capacity_and_hasher(CACHE_SIZE, Default::default()));
+        let cache = RefCell::new(Index::with_capacity(CACHE_SIZE));
 
         Maglev { nodes, lookup, cache }
     }
@@ -134,18 +144,26 @@ impl<N: Hash + Eq> Maglev<N> {
     #[inline]
     pub fn get_index_from_hash(&self, hash: usize) -> usize {
         let mut cache = self.cache.borrow_mut();
-        match cache.get(&hash) {
+        let mut set_cache = false;
+        let x = match cache.get(&hash) {
             None => {
                 // Use lookup directly
-                let idx = self.lookup[hash % self.lookup.len()] as usize;
-                cache.insert(hash, idx);
-                idx
+                set_cache = true;
+                self.lookup[hash % self.lookup.len()] as usize
             },
             Some(idx) => {
                 // Use cached backend
+                unsafe { HIT_COUNT += 1; }
                 *idx
             },
+        };
+        unsafe { HASHMAP_TOTAL += 1; }
+
+        if set_cache {
+            cache.insert(hash, x);
         }
+
+        x
     }
 
     #[inline]
@@ -155,4 +173,11 @@ impl<N: Hash + Eq> Maglev<N> {
     {
         &self.nodes[self.get_index(key)]
     }
+
+    pub fn dump_stats(&self) {
+        unsafe {
+            println!("Hits: {}, total: {}", HIT_COUNT, HASHMAP_TOTAL);
+        }
+        sashstore_redleaf::indexmap::print_stats();
+    }
 }