#include "gb-include.h"

#include "MemPool.h"

#include "Mem.h"

#include "Errno.h"

MemPool::MemPool() {

}

MemPool::~MemPool ( ) {

log("MemPool::~MemPool: mem alloced now: %li\n", m_memUsedByData );

reset();

}

void MemPool::reset ( ) {

}

bool MemPool::init ( long maxMem ) {

}

void *MemPool::dup ( void *data , long dataSize ) {

char *p = (char *)malloc ( dataSize );

// async signal safe copy

if ( p ) memcpy_ass ( p , (char *)data , dataSize );

return p;

}

void *MemPool::gbcalloc ( long size ) {

char *p = (char *)malloc ( size );

if ( ! p ) return NULL;

for ( long i = 0 ; i < size ; i++ ) p[i] = 0;

return p;

}

void *MemPool::gbrealloc ( void *ptr , long newSize ) {

// find this node in our tree

MemKey k;

k.setOffsetKey ( ptr , newSize , true );

MemNode *node = m_tree.getNode ( k );

// it's gotta be there

if ( ! node ) {

g_errno = EBADENGINEER;

log("MemPool::realloc: bad engineer");

return NULL;

}

// what's the original size and ptr?

long size = node->m_key.getSize ();

// just use malloc for now

char *mem = (char *)malloc ( newSize );

if ( ! mem ) return NULL;

// how much to copy?

long toCopy = size;

// shrink if too much

if ( toCopy > newSize ) toCopy = newSize;

// async signal safe copy

memcpy_ass ( mem , (char *)ptr , toCopy );

// free old one

free ( ptr );

return mem;

}

void *MemPool::gbmalloc ( long need ) {

// make size key

MemKey k;

k.setSizeKey ( need , NULL , false );

// . find first slot pointing of this size or higher not in use

// . this is essentially the best-fit algorithm

MemNode *node = m_tree.getNextNode ( k );

// according to bitmap of key may return one in use, so check that

if ( node && node->m_key.inUse() ) node = NULL;

// if no node, that's any error, buddy

if ( ! node ) {

g_errno = ENOMEM;

log("MemPool::malloc: no memory");

return NULL;

}

// get the size of this slot

long oldSize = node->m_key.getSize() ;

// get the mem offset into m_mem

char *ptr = node->m_key.getOffset();

// the new size

long size = oldSize;

// . get the memory floor

// . the memory above the floor is storing MemNodes

// . we may lower the floor by 2 MemNodes on success

char *floor = m_tree.getFloor();

// how many nodes we have to add that will require lowering m_floor?

long extra = 4 - m_tree.getNumEmptyNodesAboveFloor ();

// if size just right that's nice

//if ( size == need ) goto exactFit;

// lower it to accomodate up to 4 new MemNodes if we're maxed out now

if ( extra > 0 ) floor -= sizeof(MemNode) * extra ;

// if another node has data in this region, bail

if ( m_top > floor ) {

g_errno = ENOMEM;

log("MemPool::malloc: no memory");

return NULL;

}

// does the node we are splitting come up to the floor?

if ( ptr + size >= floor ) {

// how much do we have to decrease the slotSize?

long dec = ptr + size - floor;

// remove some if it's memory

size -= dec;

// if too much, we fail

if ( size < need ) {

g_errno = ENOMEM;

log("MemPool::malloc: no memory");

return NULL;

}

}

// split node into 2 halves, each half has 2 nodes actually

//log("addOffset/Size ptr=%li size=%li",(long)ptr,need);

MemNode *n0 = m_tree.addOffsetNode ( ptr , need , true );

MemNode *n1 = m_tree.addSizeNode ( need , ptr , true );

// add upper, unused half

//log("addOffset/Size ptr=%li size=%li",(long)ptr+need,size-need);

MemNode *n2 = m_tree.addOffsetNode ( ptr + need , size - need, false );

MemNode *n3 = m_tree.addSizeNode ( size - need, ptr + need , false );

// remove all on any errors

if ( ! n0 || ! n1 || ! n2 || ! n3 ) {

m_tree.deleteNode ( n0 );

m_tree.deleteNode ( n1 );

m_tree.deleteNode ( n2 );

m_tree.deleteNode ( n3 );

return NULL;

}

// boost m_top

if ( ptr + need > m_top ) m_top = ptr + need;

// Sanity check, if new floor breeches, that's a bad engineer

if ( m_tree.getFloor() < m_top ) {

g_errno = EBADENGINEER;

log("MemPool::malloc: bad engineer");

return NULL;

}

// keep track

m_memUsedByData += need;

// remove old node from size-sorted tree

//log("removeSize/Offset ptr=%li size=%li",(long)ptr, oldSize);

m_tree.deleteNode ( node );

// remove old node from offset-sorted tree

k.setOffsetKey ( ptr , oldSize , false );

m_tree.deleteNode ( k );

return ptr;

}

bool MemPool::gbfree ( void *data ) {

}