BeTreeAllocationIssuePatch

diff --git a/src/PagedDataStructures/betree.jl b/src/PagedDataStructures/betree.jl
index a5668002..098bfdae 100644
--- a/src/PagedDataStructures/betree.jl
+++ b/src/PagedDataStructures/betree.jl
@@ -7,6 +7,7 @@ using ..Common
 using Blobs
 import Suppressor: @suppress
 using Nullables: Nullable, isnull
+using StaticArrays

 const PMAImpl = NaivePackedMemoryArray
 const FOUND_ELEMENT = true
@@ -319,7 +320,7 @@ end
 #######################################
 # Iterator interface for Internal Nodes
 #######################################
-mutable struct BeInternalNodeIteratorState
+struct BeInternalNodeIteratorState
     index::Int
     done::Bool
 end
@@ -345,21 +346,14 @@ end
 end

 @inline function pds_next(node::Blob{BeInternalNode{K,V,E}}, state) where {K,V,E}
-    (mutable_next(node, state), state)
-end
-
-@inline function mutable_next(node::Blob{BeInternalNode{K,V,E}}, state) where {K,V,E}
     @dassert1 !pds_done(node, state)

     if !pds_done(node.pivots[], state.index)
         ((k,v), index) = pds_next(node.pivots[], state.index)
-        state.index = index
         @dassert1 !state.done
-        (Nullable{K}(k) => v)
+        (Nullable{K}(k) => v, BeInternalNodeIteratorState(index, false))
     else
-        state.index = 0
-        state.done = true
-        (Nullable{K}() => getrightmost(node))
+        (Nullable{K}() => getrightmost(node), BeInternalNodeIteratorState(0, true))
     end
 end

@@ -783,8 +777,7 @@ end
 #######################################
 # Iterator interface for BeTree with epsilon equal to 1.0
 #######################################
-mutable struct BIteratorStackFrame{K,V}
-    page::Pager.PagePtr
+struct BIteratorStackFrame{K,V}
     node::Blob{BeInternalNode{K,V,1.0}}
     state::BeInternalNodeIteratorState
 end
@@ -794,15 +787,41 @@ const BInternalNode{K,V} = BeInternalNode{K,V,1.0}

 const BeLeafNodeIteratorState = Int64

-mutable struct BIteratorState{K,V}
-    pager::Transaction
-    stack::SStack{BIteratorStackFrame{K,V}}
-    lpage::Pager.PagePtr
-    lnode::Blob{BLeafNode{K,V}}
-    lstate::BeLeafNodeIteratorState
-    done::Bool
-
-    BIteratorState{K,V}(pager::Transaction) where {K,V} = new{K,V}(pager, SStack{BIteratorStackFrame{K,V}}())
+eval(quote
+    mutable struct BIteratorState{K,V} <: FieldVector{SSTACK_INIT_SIZE, BIteratorStackFrame{K,V}}
+        $([:($(Symbol("_$i"))::BIteratorStackFrame{K,V}) for i=1:SSTACK_INIT_SIZE]...)
+        len::Int64
+        pager::Transaction
+        lnode::Blob{BLeafNode{K,V}}
+        lstate::BeLeafNodeIteratorState
+        done::Bool
+
+        function BIteratorState{K,V}(pager::Transaction) where {K,V}
+            inst = new{K,V}()
+            inst.len = 0
+            inst.pager = pager
+            inst
+        end
+    end
+end)
+Base.isempty(s::BIteratorState) = s.len == 0
+Base.length(s::BIteratorState) = s.len
+Base.size(s::BIteratorState) = (s.len,)
+function Base.push!(s::BIteratorState, x)
+    s.len += 1
+    SSTACK_INIT_SIZE < s.len && throw(ArgumentError("BIteratorState's stack is full"))
+    s[s.len] = x
+    nothing
+end
+function DataStructures.top(s::BIteratorState{K,V}) where {K,V}
+    isempty(s) && throw(ArgumentError("BIteratorState's stack must be non-empty"))
+    s[s.len]::BIteratorStackFrame{K,V}
+end
+function Base.pop!(s::BIteratorState{K,V}) where {K,V}
+    isempty(s) && throw(ArgumentError("BIteratorState's stack must be non-empty"))
+    top::BIteratorStackFrame{K,V} = s[s.len]
+    s.len -= 1
+    top
 end

 function mark_as_done(state::BIteratorState{K,V}) where {K,V}
@@ -812,18 +831,17 @@ end

 function complement_btree_iterator_state_for_next(tree::BTree{K,V}, pid, biter_state::BIteratorState{K,V}) where {K,V}
     t = tree.state
-    while length(biter_state.stack) < t.height[]-1
+    while length(biter_state#=.stack=#) < t.height[]-1
         (page, node) = get_paged_obj(biter_state.pager, BInternalNode{K,V}, pid)
         state = pds_start(node)
         @dassert1 !pds_done(node, state)
-        (_, pid) = mutable_next(node, state)
-        push!(biter_state.stack, BIteratorStackFrame{K,V}(page, node, state))
+        ((_, pid), state) = pds_next(node, state)
+        push!(biter_state#=.stack=#, BIteratorStackFrame{K,V}(node, state))
     end

     (lpage, lnode) = get_paged_obj(biter_state.pager, BLeafNode{K,V}, pid)
     lstate = pds_start(lnode)

-    biter_state.lpage = lpage
     biter_state.lnode = lnode
     biter_state.lstate = lstate
     biter_state.done = pds_done(lnode, lstate)
@@ -848,15 +866,17 @@ end
 function nextleaf(tree::BTree{K,V}, state::BIteratorState{K,V}) where {K,V}
     t = tree.state
     height = t.height[]
-    @dassert1 height-1 == length(state.stack)
+    @dassert1 height-1 == length(state#=.stack=#)

-    while !isempty(state.stack)
-        frame = DataStructures.top(state.stack)
+    while !isempty(state#=.stack=#)
+        frame = pop!(state#=.stack=#)
         if !pds_done(frame.node, frame.state)
-            (_, pid) = mutable_next(frame.node, frame.state)
-            return complement_btree_iterator_state_for_next(tree, pid, state)
+            # InteractiveUtils.@code_warntype pds_next(frame.node, frame.state)
+            ((_, pid), new_state) = pds_next(frame.node, frame.state)
+            push!(state#=.stack=#, BIteratorStackFrame{K,V}(frame.node, new_state))
+            complement_btree_iterator_state_for_next(tree, pid, state)
+            return nothing
         end
-        pop!(state.stack)
     end

     mark_as_done(state)