add buffer

Author: habatake

src/rapidhash.rs

@@ -1,4 +1,4 @@
-use std::io::Read;
+use std::io::{BufRead, Read};
 
 pub const RAPID_SEED: u64 = 0xbdd8_9aa9_8270_4029;
 pub const RAPID_SECRET: [u64; 3] = [
@@ -47,6 +47,7 @@ pub fn rapidhash(key: &[u8], seed: u64, secret: &[u64; 3]) -> u64 {
     let mut a;
     let mut b;
 
+    
     if len <= 16 {
         if len >= 4 {
             let delta = ((len & 24) >> (len >> 3)) as usize;
@@ -84,8 +85,10 @@ pub fn rapidhash(key: &[u8], seed: u64, secret: &[u64; 3]) -> u64 {
                 );
                 p = &p[48..];
                 i -= 48;
+                
             }
             seed ^= see1 ^ see2;
+            
         }
         if i > 16 {
             seed = rapid_mix(
@@ -99,26 +102,30 @@ pub fn rapidhash(key: &[u8], seed: u64, secret: &[u64; 3]) -> u64 {
                 );
             }
         }
+        
         a = rapid_read64(&key[len - 16..]);
         b = rapid_read64(&key[len - 8..]);
+        
     }
 
     a ^= secret[1];
     b ^= seed;
+    
     rapid_mum(&mut a, &mut b);
     rapid_mix(a ^ secret[0] ^ len as u64, b ^ secret[1])
 }
 
 // reference: https://github.com/hoxxep/rapidhash/blob/master/src/rapid_file.rs
 pub fn rapidhash_file(filename: String, seed: u64, secret: &[u64; 3]) -> u64 {
-    let f = std::fs::File::open(filename).expect("Can't open file.");
+    let f = std::fs::File::open(filename).expect("failed");
     let len = f.metadata().unwrap().len() as usize;
     let mut reader = std::io::BufReader::new(&f);
     let mut seed = seed ^ rapid_mix(seed ^ secret[0], secret[1]) ^ len as u64;
 
     let mut a;
     let mut b;
 
+    
     if len <= 16 {
         let mut key = [0u8;48];
         reader.read_exact(&mut key[..len]).unwrap();
@@ -138,14 +145,17 @@ pub fn rapidhash_file(filename: String, seed: u64, secret: &[u64; 3]) -> u64 {
             b = 0;
         }
     } else {
-        let mut tails = [0u8;48*2];
-        let (p,last) = tails.split_at_mut(48);
+        let buffer_size = 255984; // ~ 256KB
+        assert!(buffer_size % 48 == 0);
+        let mut buffer = vec![0u8;buffer_size];
         let mut i = len;
+        let mut offset = 48;
+        reader.read_exact(&mut buffer[48..std::cmp::min(48+i, buffer_size)]).unwrap();
         if i > 48 {
             let mut see1 = seed;
             let mut see2 = seed;
             while i >= 48 {
-                reader.read_exact(p).unwrap();
+                let p:&[u8] = &buffer[offset..];
                 seed = rapid_mix(
                     rapid_read64(&p[0..]) ^ secret[0],
                     rapid_read64(&p[8..]) ^ seed,
@@ -159,28 +169,47 @@ pub fn rapidhash_file(filename: String, seed: u64, secret: &[u64; 3]) -> u64 {
                     rapid_read64(&p[40..]) ^ see2,
                 );
                 i -= 48;
+                offset += 48;
+
+                if offset == buffer_size {
+                    let (head, t) = buffer.split_at_mut(48);
+                    head.copy_from_slice(&t[t.len()-48..]);
+                    reader.read_exact(&mut buffer[48..std::cmp::min(48+i, buffer_size)]).unwrap();
+                    offset = 48;
+                }
+
+                
             }
             seed ^= see1 ^ see2;
+            
         }
-        reader.read_exact(&mut last[..i]).unwrap();
+        //reader.read_exact(&mut last[..i]).unwrap();
+        let p = &buffer[offset..offset+48];
         if i > 16 {
             seed = rapid_mix(
-                rapid_read64(&last[0..]) ^ secret[2],
-                rapid_read64(&last[8..]) ^ seed ^ secret[1],
+                rapid_read64(&p[0..]) ^ secret[2],
+                rapid_read64(&p[8..]) ^ seed ^ secret[1],
             );
             if i > 32 {
                 seed = rapid_mix(
-                    rapid_read64(&last[16..]) ^ secret[2],
-                    rapid_read64(&last[24..]) ^ seed,
+                    rapid_read64(&p[16..]) ^ secret[2],
+                    rapid_read64(&p[24..]) ^ seed,
                 );
             }
         }
+        
         let end = 48 + i;
+        
+        assert!(i % 48 == len % 48);
+        
+        let tails = &buffer[offset-48..offset+48];
         a = rapid_read64(&tails[end - 16..]);
         b = rapid_read64(&tails[end - 8..]);
+        
     }
     a ^= secret[1];
     b ^= seed;
+    
     rapid_mum(&mut a, &mut b);
     rapid_mix(a ^ secret[0] ^ len as u64, b ^ secret[1])
 }