gamma writer slow

src/io/writer.rs

@@ -1,27 +1,68 @@
-use std::fs::File;
+use std::{fs::File, io::Write};
 
-const BUFFER_SIZE: usize = 1024;
+const BUFFER_SIZE: u32 = 128;
+const VEC_BUFFER_SIZE: usize = 10;
 
 #[allow(dead_code)]
 pub struct Writer {
     file: File,
     buffer: u128,
-    free: u16,
-    vec_buffer: [u128; BUFFER_SIZE],
+    written: u32,
+    vec_buffer: [u128; VEC_BUFFER_SIZE],
+    written_vec: usize,
 }
 
 #[allow(dead_code)]
 impl Writer {
     pub fn new(filename: &str) -> Writer {
-        let file = File::create(filename).unwrap();
-        let buffer = 0;
-        let free = 128;
-        let vec_buffer: [u128; BUFFER_SIZE] = [0; BUFFER_SIZE];
         Writer {
-            file,
-            buffer,
-            free,
-            vec_buffer,
+            file: File::create(filename).unwrap(),
+            buffer: 0,
+            written: 0,
+            vec_buffer: [0; VEC_BUFFER_SIZE],
+            written_vec: 0,
+        }
+    }
+
+    pub fn write_int(&mut self, n: u32) {
+        let free = BUFFER_SIZE - self.written;
+
+        let (gamma, len) = Writer::int_to_gamma(n);
+        self.buffer |= (gamma as u128) << self.written;
+
+        if free > len {
+            self.written += len;
+            return;
+        }
+
+        self.update_buffer();
+        if len > free {
+            self.buffer |= (gamma as u128) >> (len - free);
+            self.written += len - free;
+        }
+    }
+
+    pub fn update_buffer(&mut self) {
+        self.vec_buffer[self.written_vec] = self.buffer;
+        self.written_vec += 1;
+        self.buffer = 0;
+        self.written = 0;
+
+        if self.written_vec == VEC_BUFFER_SIZE {
+            for b in self.vec_buffer {
+                self.file
+                    .write_all(&b.to_be_bytes())
+                    .expect("unable to dump u128 buffer to disk");
+            }
+            self.written_vec = 0;
+        }
+    }
+
+    pub fn flush_buffer(&mut self) {
+        for i in 0..self.written_vec {
+            self.file
+                .write_all(&self.vec_buffer[i].to_be_bytes())
+                .expect("unable to dump u128 buffer to disk");
         }
     }