static wtreeNode_t* insert_rc(wtreeRoot_t* root, wtreeNode_t* parent, wtreeNode_t* item, BOOL compact, int* depth) {
if(!root || !item)
return parent;
if(!parent) {
if(root->adapter->onadded) root->adapter->onadded(item, root->ext_ctx);
return item;
}
if(depth) {
(*depth)++;
}
if(parent->top < item->top) {
if((item->top - item->size) == parent->top) {
if(item->base_size) {
item->base_size += parent->base_size;
}
else if(parent->base_size) {
parent->right = insert_rc(root, parent->right, item, compact,depth);
parent = merge_next(root,parent);
parent = resolve(root, parent, compact);
return parent;
}
item->size += parent->size;
item->left = parent->left;
item->right = parent->right;
if(root->adapter->onremoved) root->adapter->onremoved(parent, root->ext_ctx, TRUE);
if(root->adapter->onadded) root->adapter->onadded(item, root->ext_ctx);
parent = item;
} else {
parent->right = insert_rc(root, parent->right, item, compact,depth);
parent = merge_next(root, parent);
parent = resolve(root, parent, compact);
}
return parent;
} else {
if((parent->top - parent->size) == item->top) {
if(parent->base_size) {
parent->base_size += item->base_size;
}
else if(item->base_size) {
parent->left = insert_rc(root, parent->left, item, compact,depth);
parent = merge_prev(root, parent);
parent = resolve(root, parent, compact);
return parent;
}
parent->size += item->size;
} else {
parent->left = insert_rc(root, parent->left, item, compact,depth);
parent = merge_prev(root, parent);
parent = resolve(root, parent, compact);
return parent;
}
return parent;
}
}
static wtreeNode_t* merge_next(wtreeRoot_t* root, wtreeNode_t* merger) {
/*
* merger merger merger
* \ \ \
* r (nm) --> r (nm) -> r (nm) -> stop
* / / /
* rl (nm) rl (nm) rl (m)
* / / / \
* rll (m) rllr (m) rllrr(nm) rlr
* / \ / \
* 0 rllr 0 rllrr
*
*/
if(!merger)
return NULL;
if(!merger->right)
return merger;
merger->right = merge_next(root, merger->right);
merger->right = merge_from_leftend(root, merger->right, merger);
wtreeNode_t* node = (wtreeNode_t*) (merger->top - root->hdr_sz);
node->top = merger->top;
node->base_size = merger->base_size;
node->size = merger->size;
node->left = merger->left;
node->right = merger->right;
if(root->adapter->onremoved) root->adapter->onremoved(merger, root->ext_ctx, TRUE);
if(root->adapter->onadded) root->adapter->onadded(node, root->ext_ctx);
return node;
}
static wtreeNode_t* purge_rc(wtreeRoot_t* root, wtreeNode_t* node) {
if(!root)
return NULL;
if(node->right) {
node->right = purge_rc(root, node->right);
node = merge_next(root, node);
}
if(node->left) {
node->left = purge_rc(root, node->left);
node = merge_prev(root, node);
}
if (node->size == node->base_size) {
if(node->left && (node->left->base_size != node->left->size)) {
node = rotate_right(node);
node->right = purge_rc(root, node->right);
} else if(node->right && (node->right->base_size != node->right->size)) {
node = rotate_left(node);
node->left = purge_rc(root, node->left);
} else if(!node->left && !node->right) {
if(root->adapter->onfree) {
if(root->adapter->onremoved) root->adapter->onremoved(node, root->ext_ctx, FALSE);
root->adapter->onfree(node->top - node->base_size, node->base_size,node, root->ext_ctx);
return NULL;
}
}
}
return node;
}
static wtreeNode_t* grows_node(wtreeRoot_t* root, wtreeNode_t* parent, wtreeNode_t** grown, uint32_t nsz) {
if(!parent) {
parent = *grown;
*grown = NULL;
if(root->adapter->onadded) root->adapter->onadded(parent, root->ext_ctx);
return parent;
}
if((*grown)->top == (parent->top - parent->size)) {
if((parent->size + root->hdr_sz) > (nsz - (*grown)->size)) {
parent->size -= (nsz - (*grown)->size);
return parent;
}
// return requested node to its base node or neighbor
parent->size += (*grown)->size;
grown = NULL;
return parent;
} else if((*grown)->top > parent->top) {
parent->right = grows_node(root, parent->right, grown, nsz);
parent = merge_next(root, parent);
parent = resolve(root, parent, FALSE);
} else {
parent->left = grows_node(root, parent->left, grown, nsz);
parent = merge_prev(root, parent);
parent = resolve(root, parent, FALSE);
}
return parent;
}
static wtreeNode_t* resolve(wtreeRoot_t* root, wtreeNode_t* parent, BOOL compact) {
if (!parent)
return NULL;
if (parent->right && parent->left) {
if (!(parent->right->size > parent->size)
&& !(parent->left->size > parent->size))
return parent;
if (parent->right->size > parent->left->size) {
parent = rotate_left(parent);
parent->left = resolve(root,parent->left,compact);
parent = merge_prev(root, parent);
} else {
parent = rotate_right(parent);
parent->right = resolve(root,parent->right,compact);
parent = merge_next(root, parent);
}
return parent;
} else if (parent->right) {
if (parent->right->size > parent->size) {
parent = rotate_left(parent);
parent->left = resolve(root,parent->left,compact);
parent = merge_prev(root, parent);
}
return parent;
} else if (parent->left) {
if (parent->left->size > parent->size) {
parent = rotate_right(parent);
parent->right = resolve(root, parent->right,compact);
parent = merge_next(root, parent);
}
return parent;
} else {
if (!parent->size && !parent->base_size){
return NULL;
}else if(parent->size == parent->base_size) {
if(root->adapter->onfree && compact) {
if(root->adapter->onremoved) root->adapter->onremoved(parent,root->ext_ctx, FALSE);
root->adapter->onfree(parent->top - parent->base_size, parent->base_size, parent, root->ext_ctx);
return NULL;
}
}
}
return parent;
}
TEST_F(MemoryTest, MergeNext) {
Region *r;
void *ptr1, *ptr2;
unsigned int free_space;
ptr1 = test_myMalloc(test_mmr, 100);
ptr2 = test_myMalloc(test_mmr, 100);
r = region_for_pointer(ptr1);
EXPECT_LE(100, r->size);
free_space = remaining_space(test_mmr);
merge_next(test_mmr, r);
EXPECT_LE(100 + 100 + sizeof(Region), r->size);
EXPECT_EQ(free_space + sizeof(Region), remaining_space(test_mmr));
}
void kfree(void *ptr)
{
struct header *header = (struct header *)((u32)ptr - sizeof(struct header));
if (header->magic != MAGIC_CHECK) {
printk ("Memory corruption!\n");
return;
}
header->used = 0;
if (header->next && header->next->used == 0)
merge_next(header);
if(header->prev && header->prev->used == 0)
merge_prev(header);
print_blocks();
}
