#include "gb-include.h"

#include "MemPoolTree.h"

MemPoolTree::MemPoolTree () {

}

MemPoolTree::~MemPoolTree ( ) {

m_mem = NULL;

m_memSize = 0;

}

// "memMax" includes records plus the overhead

bool MemPoolTree::init ( char *mem , int32_t memSize ) {

}

// . used by cache

// . wrapper for getNode()

MemNode *MemPoolTree::getNode ( MemKey &key ) {

// debug msg

//log("getting node for k.n1=%"UINT32" n0=%"UINT64"",key.n1,key.n0);

// get the node (about 4 cycles per loop, 80cycles for 1 million items)

MemNode *i = m_headNode;

while ( i ) {

if ( key < i->m_key ) { i = i->m_left ; continue;}

if ( key > i->m_key ) { i = i->m_right; continue;}

return i;

}

return NULL;

}

// . returns node whose key is >= "key"

// . returns NULL if none

MemNode *MemPoolTree::getNextNode ( MemKey &key ) {

// return NULL if tree empty

if ( ! m_headNode ) return NULL;

// get the node

MemNode *parent;

MemNode *i = m_headNode ;

while ( i ) {

parent = i ;

if ( key < i->m_key ) { i = i->m_left ; continue; }

if ( key > i->m_key ) { i = i->m_right ; continue; }

return i;

}

// if parent's key is > we're done

if ( parent->m_key > key ) return parent;

// otherwise we must get the node after the parent

return getNextNode ( parent );

}

// . get the node whose key is <= "key"

// . returns -1 if none

MemNode *MemPoolTree::getPrevNode ( MemKey &key ) {

// return NULL if tree empty

if ( ! m_headNode ) return NULL;

// get the node

MemNode *parent;

MemNode *i = m_headNode ;

while ( i ) {

parent = i ;

if ( key < i->m_key ) { i = i->m_left ; continue; }

if ( key > i->m_key ) { i = i->m_right ; continue; }

return i;

}

// if parent's key is < we're done

if ( parent->m_key < key ) return parent;

// otherwise we must get the node after the parent

return getPrevNode ( parent );

}

// get next node after "node"

MemNode *MemPoolTree::getNextNode ( MemNode *i ) {

// cruise the kids if we have a right one

if ( i->m_right ) {

// go to the right kid

i = i->m_right;

// now go left as much as we can

while ( i->m_left ) i = i->m_left;

// return that node (it's a leaf or has one right kid)

return i;

}

// now keep getting parents until one has a key bigger than i's key

MemNode *p = i->m_parent;

// if parent is NULL we're done

if ( ! p ) return NULL;

// if we're the left kid of the parent, then the parent is the

// next biggest node

if ( p->m_left == i ) return p;

// otherwise keep getting the parent until it has a bigger key

// or until we're the LEFT kid of the parent. that's better

// cuz comparing keys takes longer. loop is 6 cycles per iteration.

while ( p && p->m_key < i->m_key ) p = p->m_parent;

// p will be NULL if none are left

return p;

}

MemNode *MemPoolTree::getPrevNode ( MemNode *i ) {

// cruise the kids if we have a left one

if ( i->m_left ) {

// go to the left kid

i = i->m_left;

// now go right as much as we can

while ( i->m_right ) i = i->m_right ;

// return that node (it's a leaf or has one left kid)

return i;

}

// now keep getting parents until one has a key bigger than i's key

MemNode *p = i->m_parent;

// if we're the right kid of the parent, then the parent is the

// next least node

if ( p->m_right == i ) return p;

// keep getting the parent until it has a bigger key

// or until we're the RIGHT kid of the parent. that's better

// cuz comparing keys takes longer. loop is 6 cycles per iteration.

while ( p && p->m_key > i->m_key ) p = p->m_parent;

// p will be NULL if none are left

return p;

}

// . returns NULL and sets errno on failure

// . returns node ptr we added it to on success

// . this will NOT replace any current node with the same key

MemNode *MemPoolTree::addNode ( MemKey &key ) {

// debug msg

//log("adding k.n1=%"UINT32" n0=%"UINT64"",key.n1,key.n0);

// set up vars

MemNode *iparent ;

// this is NULL iff there are no nodes used in the tree

MemNode *i = m_headNode;

// . find the parent of node i

// . if a node exists with our key then replace it

while ( i ) {

iparent = i ;

if ( key < i->m_key ) i = i->m_left ;

else if ( key > i->m_key ) i = i->m_right ;

else {

errno = EBADENGINEER;

log("MemPoolTree::addNode: node already in tree");

return NULL;

}

}

// store in the next available node

i = m_nextNode;

// if we're the first node we become the head node and our parent is -1

if ( ! m_headNode ) {

m_headNode = i;

iparent = NULL;

}

// . the right kid of an empty node is used as a linked list of

// empty nodes formed by deleting nodes

// . we keep the linked list so we can re-used these vacated nodes

MemNode *rightGuy = i->m_right ;

// stick ourselves in the next available node, "m_nextNode"

i->m_key = key;

i->m_parent = iparent;

i->m_left = NULL;

i->m_right = NULL;

i->m_depth = 1; // leave nodes have depth of 1

// make our parent, if any, point to us

if ( iparent ) {

if ( key < iparent->m_key ) iparent->m_left = i;

else if ( key > iparent->m_key ) iparent->m_right = i;

else log("MemPoolTree::addNode: bad engineer");

}

// . if we weren't recycling a middle node then advance to next

// . m_floor is the lowest node number that was never filled

// at any one time in the past

// . you might call it the brand new housing district

// . we advance downwards like a stack to use memory most efficiently

if ( m_nextNode == m_floor - 1 ) { m_nextNode--; m_floor--; }

// . otherwise, we're in a linked list of vacated used houses

// . we have a linked list in the right kid

// . make sure the new head doesn't have a left

else if ( rightGuy ) m_nextNode = rightGuy;

// otherwise point it to the next brand new house (TODO:REMOVE)

else {

log("MemPoolTree::addNode: bad engineer 2");

sleep(50000); // m_nextNode = m_floor;

}

// we have one more used node

m_numUsedNodes++;

// . reset depths starting at our parent and ascending the tree

// . will balance if child depths differ by 2 or more

setDepths ( iparent );

// return the node we occupied

return i;

}

// . deletes node i from the tree

// . i's parent should point to i's left or right kid

// . if i has no parent then his left or right kid becomes the new top node

void MemPoolTree::deleteNode ( MemNode *i ) {

}

// . recompute depths of nodes starting at i and ascending the tree

// . call rotateRight/Left() when depth of children differs by 2 or more

void MemPoolTree::setDepths ( MemNode *i ) {

}

/*

// W , X and B are SUBTREES.

// B's subtree was 1 less in depth than W or X, then a new node was added to

// W or X triggering the imbalance.

// However, if B gets deleted W and X can be the same size.

//

// Right rotation if W subtree depth is >= X subtree depth:

//

// A N

// / \ / \

// / \ / \

// N B ---> W A

// / \ / \

// W X X B

//

// Right rotation if W subtree depth is < X subtree depth:

// A X

// / \ / \

// / \ / \

// N B ---> N A

// / \ / \ / \

// W X W Q T B

// / \

// Q T

*/

// . we come here when A's left subtree is deeper than it's right subtree by 2

// . this rotation operation causes left to lose 1 depth and right to gain one

// . the type of rotation depends on which subtree is deeper, W or X

// . W or X must deeper by the other by exactly one

// . if they were equal depth then how did adding a node inc the depth?

// . if their depths differ by 2 then N would have been rotated first!

// . the parameter "i" is the node # for A in the illustration above

// . return the node # that replaced A so the balance() routine can continue

// . TODO: check our depth modifications below

MemNode *MemPoolTree::rotateRight ( MemNode *i ) {

// i's left kid's right kid takes his place

MemNode *A = i;

MemNode *N = A->m_left ;

MemNode *W = N->m_left ;

MemNode *X = N->m_right;

MemNode *Q = NULL;

MemNode *T = NULL;

if ( X ) {

Q = X->m_left ;

T = X->m_right;

}

// let AP be A's parent

MemNode *AP = A->m_parent ;

// whose the bigger subtree, W or X? (depth includes W or X itself)

int32_t Wdepth = 0;

int32_t Xdepth = 0;

if ( W ) Wdepth = W->m_depth;

if ( X ) Xdepth = X->m_depth;

// debug msg

//fprintf(stderr,"A=%"INT32" AP=%"INT32" N=%"INT32" W=%"INT32" X=%"INT32" Q=%"INT32" T=%"INT32" "

//"Wdepth=%"INT32" Xdepth=%"INT32"\n",A,AP,N,W,X,Q,T,Wdepth,Xdepth);

// goto Xdeeper if X is deeper

if ( Wdepth < Xdepth ) goto Xdeeper;

// N's parent becomes A's parent

N->m_parent = AP;

// A's parent becomes N

A->m_parent = N;

// X's parent becomes A

if ( X ) X->m_parent = A;

// A's parents kid becomes N

if ( AP ) {

if ( AP->m_left == A ) AP->m_left = N;

else AP->m_right = N;

}

// if A had no parent, it was the headNode

else {

//fprintf(stderr,"changing head node from %"INT32" to %"INT32"\n",

//m_headNode,N);

m_headNode = N;

}

// N's right kid becomes A

N->m_right = A;

// A's left kid becomes X

A->m_left = X;

// . compute A's depth from it's X and B kids

// . it should be one less if Xdepth smaller than Wdepth

// . might set m_depth[A] to computeDepth(A) if we have problems

if ( Xdepth < Wdepth ) A->m_depth -= 2;

else A->m_depth -= 1;

// N gains a depth iff W and X were of equal depth

if ( Wdepth == Xdepth ) N->m_depth += 1;

// now we're done, return the new pivot that replaced A

return N;

// come here if X is deeper

Xdeeper:

// X's parent becomes A's parent

X->m_parent = AP;

// A's parent becomes X

A->m_parent = X;

// N's parent becomes X

N->m_parent = X;

// Q's parent becomes N

if ( Q ) Q->m_parent = N;

// T's parent becomes A

if ( T ) T->m_parent = A;

// A's parent's kid becomes X

if ( AP ) {

if ( AP->m_left == A ) AP->m_left = X;

else AP->m_right = X;

}

// if A had no parent, it was the headNode

else {

//fprintf(stderr,"changing head node2 from %"INT32" to %"INT32"\n",

//m_headNode,X);

m_headNode = X;

}

// A's left kid becomes T

A->m_left = T;

// N's right kid becomes Q

N->m_right = Q;

// X's left kid becomes N

X->m_left = N;

// X's right kid becomes A

X->m_right = A;

// X's depth increases by 1 since it gained 1 level of 2 new kids

X->m_depth += 1;

// N's depth decreases by 1

N->m_depth -= 1;

// A's depth decreases by 2

A->m_depth -= 2;

// now we're done, return the new pivot that replaced A

return X;

}

MemNode *MemPoolTree::rotateLeft ( MemNode *i ) {

// i's left kid's right kid takes his place

MemNode *A = i;

MemNode *N = A->m_right ;

MemNode *W = N->m_right ;

MemNode *X = N->m_left;

MemNode *Q = NULL;

MemNode *T = NULL;

if ( X ) {

Q = X->m_right ;

T = X->m_left ;

}

// let AP be A's parent

MemNode *AP = A->m_parent ;

// whose the bigger subtree, W or X? (depth includes W or X itself)

int32_t Wdepth = 0;

int32_t Xdepth = 0;

if ( W ) Wdepth = W->m_depth;

if ( X ) Xdepth = X->m_depth;

// debug msg

//fprintf(stderr,"A=%"INT32" AP=%"INT32" N=%"INT32" W=%"INT32" X=%"INT32" Q=%"INT32" T=%"INT32" "

//"Wdepth=%"INT32" Xdepth=%"INT32"\n",A,AP,N,W,X,Q,T,Wdepth,Xdepth);

// goto Xdeeper if X is deeper

if ( Wdepth < Xdepth ) goto Xdeeper;

// N's parent becomes A's parent

N->m_parent = AP;

// A's parent becomes N

A->m_parent = N;

// X's parent becomes A

if ( X ) X->m_parent = A;

// A's parents kid becomes N

if ( AP ) {

if ( AP->m_right == A ) AP->m_right = N;

else AP->m_left = N;

}

// if A had no parent, it was the headNode

else {

//fprintf(stderr,"changing head node from %"INT32" to %"INT32"\n",

//m_headNode,N);

m_headNode = N;

}

// N's right kid becomes A

N->m_left = A;

// A's left kid becomes X

A->m_right = X;

// . compute A's depth from it's X and B kids

// . it should be one less if Xdepth smaller than Wdepth

// . might set m_depth[A] to computeDepth(A) if we have problems

if ( Xdepth < Wdepth ) A->m_depth -= 2;

else A->m_depth -= 1;

// N gains a depth iff W and X were of equal depth

if ( Wdepth == Xdepth ) N->m_depth += 1;

// now we're done, return the new pivot that replaced A

return N;

// come here if X is deeper

Xdeeper:

// X's parent becomes A's parent

X->m_parent = AP;

// A's parent becomes X

A->m_parent = X;

// N's parent becomes X

N->m_parent = X;

// Q's parent becomes N

if ( Q ) Q->m_parent = N;

// T's parent becomes A

if ( T ) T->m_parent = A;

// A's parent's kid becomes X

if ( AP ) {

if ( AP->m_right == A ) AP->m_right = X;

else AP->m_left = X;

}

// if A had no parent, it was the headNode

else {

//fprintf(stderr,"changing head node2 from %"INT32" to %"INT32"\n",

//m_headNode,X);

m_headNode = X;

}

// A's left kid becomes T

A->m_right = T;

// N's right kid becomes Q

N->m_left = Q;

// X's left kid becomes N

X->m_right = N;

// X's right kid becomes A

X->m_left = A;

// X's depth increases by 1 since it gained 1 level of 2 new kids

X->m_depth += 1;

// N's depth decreases by 1

N->m_depth -= 1;

// A's depth decreases by 2

A->m_depth -= 2;

// now we're done, return the new pivot that replaced A

return X;

}