maglev: More optimizations

Author: zhaofengli

sys/driver/ixgbe/Cargo.toml

@@ -15,6 +15,7 @@ panic = "abort"
 [profile.release]
 panic = "abort"
 debug = true
+lto = true
 
 [dependencies]
 syscalls = { path = "../../../sys/interfaces/syscalls", version = "0.1.0" }

sys/lib/libbenchnet/Cargo.toml

@@ -16,7 +16,6 @@ rref = { path = "../rref", version = "0.1.0" }
 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]

sys/lib/libbenchnet/src/lib.rs

@@ -1080,9 +1080,15 @@ 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());
+                }
             }
             */
             unsafe {
@@ -1134,8 +1140,6 @@ 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);
 
@@ -1171,6 +1175,8 @@ pub fn run_maglev_fwd_udptest_rref(net: &dyn Net, pkt_len: usize) -> Result<()>
     print_hist!(submit_tx_hist);
 
     println!("+++++++++++++++++++++++++++++++++++++++++++++++++");
+    maglev.dump_stats();
+
     Ok(())
 }
 

sys/lib/libbenchnet/src/maglev.rs

@@ -31,15 +31,24 @@ use core::default::Default;
 
 use hashbrown::HashMap;
 use sashstore_redleaf::indexmap::Index;
-
 use console::println;
 
 const TABLE_SIZE: usize = 65537;
-const CACHE_SIZE: usize = 1 << 24;
+const CACHE_SIZE: usize = 1 << 21;
 
 static mut HIT_COUNT: usize = 0;
 static mut HASHMAP_TOTAL: usize = 0;
 
+/*
+lut (consistent hashing), cache (connection tracking)
+
+- receive the packet
+- generate flowhash from 5-tuple
+- lookup in cache
+- if found in cache: just return
+- if not found: (lut[hash] -> backend number) and insert into cache
+*/
+
 type FnvHashFactory = BuildHasherDefault<FnvHasher>;
 type XxHashFactory = BuildHasherDefault<XxHash>;
 

sys/lib/libbenchnet/src/packettool.rs

@@ -56,34 +56,53 @@ pub fn fix_udp_checksum(frame: &mut [u8]) {
     frame[ETH_HEADER_LEN + v4len + UDP_CHECKSUM_OFFSET + 1] = 0;
 }
 
+#[inline(always)]
+fn fnv_a(data: &[u8], state: &mut u64) {
+    for byte in data.iter() {
+        *state *= 0x100000001b3;
+        *state ^= u64::from(*byte);
+    }
+}
+
 pub fn get_flowhash(frame: &[u8]) -> Option<usize> {
     // Ugly but fast (supposedly)
-    let h1f: BuildHasherDefault<FnvHasher> = Default::default();
-    let mut h1 = h1f.build_hasher();
+    // let h1f: BuildHasherDefault<FnvHasher> = Default::default();
+    // let mut h1 = h1f.build_hasher();
+    let mut state: u64 = 0xcbf29ce484222325;
 
+    /*
     if frame[ETH_HEADER_LEN] >> 4 != 4 {
         // This shitty implementation can only handle IPv4 :(
         return None
     }
+    */
 
     // Length of IPv4 header
     let v4len = (frame[ETH_HEADER_LEN] & 0b1111) as usize * 4;
 
     // Hash source/destination IP addresses
-    frame[(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET)..(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET + IPV4_SRCDST_LEN)].hash(&mut h1);
+    fnv_a(&frame[(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET)..(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET + IPV4_SRCDST_LEN)], &mut state);
+    // frame[(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET)..(ETH_HEADER_LEN + IPV4_SRCDST_OFFSET + IPV4_SRCDST_LEN)].hash(&mut h1);
 
     // Hash IP protocol number
     let proto = frame[ETH_HEADER_LEN + IPV4_PROTO_OFFSET];
+    /*
     if proto != 6 && proto != 17 {
         // This shitty implementation can only handle TCP and UDP
         return None;
     }
-    proto.hash(&mut h1);
+    */
+    state *= 0x100000001b3;
+    state ^= u64::from(proto);
+
+    // proto.hash(&mut h1);
 
     // Hash source/destination port
-    frame[(ETH_HEADER_LEN + v4len)..(ETH_HEADER_LEN + v4len + 4)].hash(&mut h1);
+    fnv_a(&frame[(ETH_HEADER_LEN + v4len)..(ETH_HEADER_LEN + v4len + 4)], &mut state);
+    // frame[(ETH_HEADER_LEN + v4len)..(ETH_HEADER_LEN + v4len + 4)].hash(&mut h1);
 
-    Some(h1.finish() as usize)
+    // Some(h1.finish() as usize)
+    Some(state as usize)
 }
 
 pub fn get_mut_udp_payload(frame: &mut [u8]) -> Option<(usize, &mut [u8])> {