From ecbdd70c37563ea192c8c189b3c7227432a47f9d Mon Sep 17 00:00:00 2001
From: Paul Masurel <paul.masurel@gmail.com>
Date: Fri, 12 May 2017 14:01:52 +0900
Subject: [PATCH] Removed the clunky linked list logic of the heap.

---
 src/datastruct/stacker/heap.rs | 78 ++++++++++------------------------
 1 file changed, 22 insertions(+), 56 deletions(-)

diff --git a/src/datastruct/stacker/heap.rs b/src/datastruct/stacker/heap.rs
index 694e45c8d..bf89b923a 100644
--- a/src/datastruct/stacker/heap.rs
+++ b/src/datastruct/stacker/heap.rs
@@ -96,9 +96,8 @@ impl Heap {
 
 struct InnerHeap {
     buffer: Vec<u8>,
-    buffer_len: u32,
     used: u32,
-    next_heap: Option<Box<InnerHeap>>,
+    has_been_resized: bool,
 }
 
 
@@ -108,15 +107,13 @@ impl InnerHeap {
         let buffer: Vec<u8> = vec![0u8; num_bytes];
         InnerHeap {
             buffer: buffer,
-            buffer_len: num_bytes as u32,
-            next_heap: None,
             used: 0u32,
+            has_been_resized: false,
         }
     }
 
     pub fn clear(&mut self) {
         self.used = 0u32;
-        self.next_heap = None;
     }
 
     pub fn capacity(&self,) -> u32 {
@@ -126,47 +123,31 @@ impl InnerHeap {
     // Returns the number of free bytes. If the buffer
     // has reached it's capacity and overflowed to another buffer, return 0.
     pub fn num_free_bytes(&self,) -> u32 {
-        if self.next_heap.is_some() {
+        if self.has_been_resized {
             0u32
         }
         else {
-            self.buffer_len - self.used
+            (self.buffer.len() as u32) - self.used
         } 
     }
 
     pub fn allocate_space(&mut self, num_bytes: usize) -> u32 {
         let addr = self.used;
         self.used += num_bytes as u32;
-        if self.used <= self.buffer_len {
-            addr
+        let buffer_len = self.buffer.len();
+        if self.used > buffer_len as u32 {
+            self.buffer.resize(buffer_len * 2, 0u8);
+            self.has_been_resized = true
         }
-        else {
-            if self.next_heap.is_none() {
-                warn!("Exceeded heap size. The margin was apparently unsufficient. The segment will be committed right after indexing this very last document.");
-                self.next_heap = Some(Box::new(InnerHeap::with_capacity(self.buffer_len as usize)));
-            }
-            self.next_heap.as_mut().unwrap().allocate_space(num_bytes) + self.buffer_len
-        }
-        
-        
+        addr
     }
     
     fn get_slice(&self, start: u32, stop: u32) -> &[u8] {
-        if start >= self.buffer_len {
-            self.next_heap.as_ref().unwrap().get_slice(start - self.buffer_len, stop - self.buffer_len)
-        }
-        else {
-            &self.buffer[start as usize..stop as usize]
-        }
+        &self.buffer[start as usize..stop as usize]
     }
     
     fn get_mut_slice(&mut self, start: u32, stop: u32) -> &mut [u8] {
-        if start >= self.buffer_len {
-            self.next_heap.as_mut().unwrap().get_mut_slice(start - self.buffer_len, stop - self.buffer_len)
-        }
-        else {
-            &mut self.buffer[start as usize..stop as usize]
-        }
+        &mut self.buffer[start as usize..stop as usize]
     }
 
     fn allocate_and_set(&mut self, data: &[u8]) -> BytesRef {
@@ -180,38 +161,23 @@ impl InnerHeap {
     }
 
     fn get_mut(&mut self, addr: u32) -> *mut u8 {
-        if addr >= self.buffer_len {
-            self.next_heap.as_mut().unwrap().get_mut(addr - self.buffer_len)
-        }
-        else {
-            let addr_isize = addr as isize;
-            unsafe { self.buffer.as_mut_ptr().offset(addr_isize) }
-        }
+        let addr_isize = addr as isize;
+        unsafe { self.buffer.as_mut_ptr().offset(addr_isize) }
     }
 
     fn get_mut_ref<Item>(&mut self, addr: u32) -> &mut Item {
-        if addr >= self.buffer_len {
-            self.next_heap.as_mut().unwrap().get_mut_ref(addr - self.buffer_len)
-        }
-        else {
-            let v_ptr_u8 = self.get_mut(addr) as *mut u8;
-            let v_ptr = v_ptr_u8 as *mut Item;
-            unsafe { &mut *v_ptr }
-        }
+        let v_ptr_u8 = self.get_mut(addr) as *mut u8;
+        let v_ptr = v_ptr_u8 as *mut Item;
+        unsafe { &mut *v_ptr }
     }
 
     fn set<Item>(&mut self, addr: u32, val: &Item) {
-        if addr >= self.buffer_len {
-            self.next_heap.as_mut().unwrap().set(addr - self.buffer_len, val);
-        }
-        else {
-            let v_ptr: *const Item = val as *const Item;
-            let v_ptr_u8: *const u8 = v_ptr as *const u8;
-            debug_assert!(addr + mem::size_of::<Item>() as u32 <= self.used);
-            unsafe {
-                let dest_ptr: *mut u8 = self.get_mut(addr);
-                ptr::copy(v_ptr_u8, dest_ptr, mem::size_of::<Item>());
-            }
+        let v_ptr: *const Item = val as *const Item;
+        let v_ptr_u8: *const u8 = v_ptr as *const u8;
+        debug_assert!(addr + mem::size_of::<Item>() as u32 <= self.used);
+        unsafe {
+            let dest_ptr: *mut u8 = self.get_mut(addr);
+            ptr::copy(v_ptr_u8, dest_ptr, mem::size_of::<Item>());
         }
     }
 }
\ No newline at end of file