d
/
bond
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

not quite working stuff. Rethinking memory allocator. Maybe not buddy allocator. Basically use salloc for heap for now and talloc with O(log n) for system page allocation. A linear external allocator is not necessarily needed. Todo: finish talloc and add lock/alignment to salloc

This commit is contained in:
secXsQuared 2016-06-16 18:13:57 -07:00
parent 95bb791d71
commit 0b6b0a46b4
9 changed files with 555 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
x64/src/common/lib/avl_tree/avl_tree.c
View File

@ -3,7 +3,6 @@
* See COPYING under root for details
*/
#include <stdbool.h>
#include "avl_tree.h"
static inline int32_t KAPI _avl_tree_node_get_height(avl_tree_node_t *node)
@ -31,7 +30,8 @@ static avl_tree_node_t *KAPI _avl_tree_node_right_rotate(avl_tree_node_t *root)
left_children->right = root;
//adjust height
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
left_children->height = max_32(_avl_tree_node_get_height(left_children->left), _avl_tree_node_get_height(left_children->right)) + 1;
left_children->height =
max_32(_avl_tree_node_get_height(left_children->left), _avl_tree_node_get_height(left_children->right)) + 1;
return left_children;
}
@ -48,7 +48,9 @@ static avl_tree_node_t *KAPI _avl_tree_node_left_rotate(avl_tree_node_t *root)
right_children->left = root;
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
right_children->height = max_32(_avl_tree_node_get_height(right_children->left), _avl_tree_node_get_height(right_children->right)) + 1;
right_children->height =
max_32(_avl_tree_node_get_height(right_children->left), _avl_tree_node_get_height(right_children->right)) +
1;
return right_children;
}
@ -89,7 +91,9 @@ static avl_tree_node_t *KAPI _avl_tree_node_balance(avl_tree_node_t *node)
}
static avl_tree_node_t *KAPI _avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node, int32_t(*compare)(avl_tree_node_t *, avl_tree_node_t *), avl_tree_node_t *parent)
static avl_tree_node_t *KAPI _avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node,
avl_tree_node_compare_func_t compare,
avl_tree_node_t *parent)
{
if (node == NULL || compare == NULL)
return root;
@ -134,26 +138,26 @@ static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
if (parent != NULL && child != NULL)
{
//connected case
if(parent->parent != NULL)
if (parent->parent != NULL)
{
if(parent->parent->left == parent)
if (parent->parent->left == parent)
parent->parent->left = child;
else
parent->parent->right = child;
}
//update left/right for parent
if(parent->left != NULL && child != parent->left)
if (parent->left != NULL && child != parent->left)
{
parent->left->parent = child;
}
if(parent->right != NULL && child != parent->right)
if (parent->right != NULL && child != parent->right)
{
parent->right->parent = child;
}
//update left/right for children
if(child->left != NULL)
if (child->left != NULL)
child->left->parent = parent;
if(child->right != NULL)
if (child->right != NULL)
child->right->parent = parent;
child->parent = parent->parent;
@ -187,27 +191,27 @@ static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
{
//not connected case
//adjust all the nodes other than node1,node2
if(node1->left != NULL)
if (node1->left != NULL)
node1->left->parent = node2;
if(node1->right != NULL)
if (node1->right != NULL)
node1->right->parent = node2;
if(node2->left != NULL)
if (node2->left != NULL)
node2->left->parent = node1;
if(node2->right != NULL)
if (node2->right != NULL)
node2->right->parent = node1;
if(node1->parent != NULL)
if (node1->parent != NULL)
{
if(node1->parent->left == node1)
if (node1->parent->left == node1)
node1->parent->left = node2;
else
node1->parent->right = node2;
}
if(node2->parent != NULL)
if (node2->parent != NULL)
{
if(node2->parent->left == node2)
if (node2->parent->left == node2)
node2->parent->left = node1;
else
node2->parent->right = node1;
@ -235,23 +239,23 @@ static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
}
static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root, avl_tree_node_t *node,
int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
avl_tree_node_compare_func_t compare)
{
if (root == NULL || node == NULL || compare == NULL)
return root;
const int32_t comp = compare(root, node);
if (comp < 0)
root->right = _avl_tree_node_delete(root->right, node, compare);
else if(comp > 0)
else if (comp > 0)
root->left = _avl_tree_node_delete(root->left, node, compare);
else
{
// node with only one child or no child
if( (root->left == NULL) || (root->right == NULL) )
if ((root->left == NULL) || (root->right == NULL))
{
avl_tree_node_t *child = root->left != NULL ? root->left : root->right;
if(child == NULL)
if (child == NULL)
{ // 0 child
root = NULL;
}
@ -283,9 +287,9 @@ static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root, avl_tr
}
static avl_tree_node_t *KAPI _avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t *node,
int32_t(*compare)(avl_tree_node_t *, avl_tree_node_t *))
avl_tree_node_compare_func_t compare)
{
if(root == NULL || compare == NULL)
if (root == NULL || compare == NULL)
return NULL;
const int32_t comp = compare(root, node);
if (comp < 0)
@ -296,9 +300,10 @@ static avl_tree_node_t *KAPI _avl_tree_node_search(avl_tree_node_t *root, avl_tr
return _avl_tree_node_search(root->left, node, compare);
}
static void KAPI _avl_tree_node_init(avl_tree_node_t * it)
static void KAPI _avl_tree_node_init(avl_tree_node_t *it)
{
if(it != NULL)
if (it != NULL)
{
it->height = 0;
it->left = NULL;
@ -313,8 +318,8 @@ avl_tree_node_t *KAPI avl_tree_smallest(avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
avl_tree_node_t* entry = tree->root;
if(entry == NULL)
avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->left != NULL)
entry = entry->left;
@ -325,8 +330,8 @@ avl_tree_node_t *KAPI avl_tree_largest(avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
avl_tree_node_t* entry = tree->root;
if(entry == NULL)
avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->right != NULL)
entry = entry->right;
@ -338,7 +343,7 @@ avl_tree_node_t *KAPI avl_tree_larger(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
avl_tree_node_t * root = it;
avl_tree_node_t *root = it;
if (root->right != NULL)
{
root = root->right;
@ -362,7 +367,7 @@ avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
avl_tree_node_t * root = it;
avl_tree_node_t *root = it;
if (root->left != NULL)
{
root = root->left;
@ -382,40 +387,40 @@ avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *it)
}
}
avl_tree_node_t * KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t * node, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
avl_tree_node_t *KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t *node)
{
return _avl_tree_node_search(tree->root, node, compare);
return _avl_tree_node_search(tree->root, node, tree->compare);
}
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t* data, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *data)
{
if(tree != NULL && data != NULL)
if (tree != NULL && data != NULL)
{
_avl_tree_node_init(data);
tree->root = _avl_tree_node_insert(tree->root, data, compare, NULL);
tree->root = _avl_tree_node_insert(tree->root, data, tree->compare, NULL);
}
return;
}
void KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *data, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
void KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *data)
{
if(tree != NULL && data != NULL)
if (tree != NULL && data != NULL)
{
tree->root = _avl_tree_node_delete(tree->root, data, compare);
tree->root = _avl_tree_node_delete(tree->root, data, tree->compare);
}
return;
}
int32_t KAPI avl_tree_size(avl_tree_t *tree)
{
if(tree == NULL)
if (tree == NULL)
return -1;
if(tree->root == NULL)
if (tree->root == NULL)
return 0;
int32_t size= 0;
avl_tree_node_t* entry = avl_tree_smallest(tree);
while(entry != NULL)
int32_t size = 0;
avl_tree_node_t *entry = avl_tree_smallest(tree);
while (entry != NULL)
{
size++;
entry = avl_tree_larger(entry);
@ -423,10 +428,11 @@ int32_t KAPI avl_tree_size(avl_tree_t *tree)
return size;
}
void KAPI avl_tree_init(avl_tree_t * tree)
void KAPI avl_tree_init(avl_tree_t *tree, avl_tree_node_compare_func_t compare)
{
if(tree != NULL)
if (tree != NULL)
{
tree->compare = compare;
tree->root = NULL;
}
return;
@ -443,33 +449,35 @@ static int32_t KAPI _avl_tree_node_calculate_height(avl_tree_node_t *tree)
return max_32(_avl_tree_node_calculate_height(tree->left), _avl_tree_node_calculate_height(tree->right)) + 1;
}
static bool KAPI _avl_tree_node_test(avl_tree_node_t *tree, int32_t (*compare)(avl_tree_node_t*, avl_tree_node_t*))
static bool KAPI _avl_tree_node_test(avl_tree_node_t *tree, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
{
if (tree == NULL)
return true;
if (_avl_tree_node_get_balance_factor(tree) < -1 || _avl_tree_node_get_balance_factor(tree) > 1 || _avl_tree_node_calculate_height(tree) != tree->height)
if (_avl_tree_node_get_balance_factor(tree) < -1 || _avl_tree_node_get_balance_factor(tree) > 1 ||
_avl_tree_node_calculate_height(tree) != tree->height)
return false;
if(tree->left != NULL)
if (tree->left != NULL)
{
if(tree->left->parent != tree)
if (tree->left->parent != tree)
return false;
}
if(tree->right != NULL)
if (tree->right != NULL)
{
if(tree->right->parent != tree)
if (tree->right->parent != tree)
return false;
}
if(compare != NULL)
if (compare != NULL)
{
if((tree->right != NULL && compare(tree,tree->right) > 0) || (tree->left != NULL && compare(tree,tree->left) < 0))
if ((tree->right != NULL && compare(tree, tree->right) > 0) ||
(tree->left != NULL && compare(tree, tree->left) < 0))
return false;
}
return _avl_tree_node_test(tree->left,compare) && _avl_tree_node_test(tree->right,compare);
return _avl_tree_node_test(tree->left, compare) && _avl_tree_node_test(tree->right, compare);
}
bool KAPI avl_tree_validate(avl_tree_t *tree, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
bool KAPI avl_tree_validate(avl_tree_t *tree)
{
if(tree == NULL)
if (tree == NULL)
return true;
return _avl_tree_node_test(tree->root, compare);
return _avl_tree_node_test(tree->root, tree->compare);
}

28
x64/src/common/lib/avl_tree/inc/avl_tree.h
View File

@ -8,30 +8,40 @@
#include "std_lib.h"
typedef struct _avl_tree_node_t
{
struct _avl_tree_node_t *left;
struct _avl_tree_node_t *right;
struct _avl_tree_node_t *parent;
int32_t height;
} avl_tree_node_t;
/*
* A comparison function between tree_node and your_node
* Returns:
* < 0 if tree_node < your_node
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
typedef int32_t (*avl_tree_node_compare_func_t)(avl_tree_node_t* tree_node, avl_tree_node_t* your_node);
typedef struct
{
avl_tree_node_compare_func_t compare;
avl_tree_node_t *root;
} avl_tree_t;
avl_tree_node_t *KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t *entry);
avl_tree_node_t *KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t *entry,
int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *));
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *entry);
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *entry,
int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *));
void KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *entry);
void KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *entry,
int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *));
void KAPI avl_tree_init(avl_tree_t *tree);
void KAPI avl_tree_init(avl_tree_t *tree, avl_tree_node_compare_func_t);
avl_tree_node_t *KAPI avl_tree_largest(avl_tree_t *tree);
@ -41,7 +51,7 @@ avl_tree_node_t *KAPI avl_tree_larger(avl_tree_node_t *entry);
avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *entry);
bool KAPI avl_tree_validate(avl_tree_t *tree, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *));
bool KAPI avl_tree_validate(avl_tree_t *tree);
int32_t KAPI avl_tree_size(avl_tree_t *tree);

53
x64/src/common/lib/lalloc/inc/lalloc.h
View File

@ -1,53 +0,0 @@
#ifndef _LALLOC_H_
#define _LALLOC_H_
#include "linked_list.h"
#define LALLOC_STATUS_SUCCESS 0
#define LALLOC_STATUS_INVALID_ARGUMENTS 1
#define LALLOC_STATUS_NOT_ENOUGH_MEM 2
#define LALLOC_STATUS_CANT_ALLOC_NODE 3
#define LALLOC_STATUS_INVALID_REIGON 4
typedef void *(*lalloc_alloc_func)(uint64_t size);
typedef void (*lalloc_free_func)(void* ptr);
typedef struct
{
linked_list_t free_list;
linked_list_t used_list;
lalloc_alloc_func alloc;
lalloc_free_func free;
} lalloc_desc_t;
int32_t lalloc_aligned(lalloc_desc_t* desc,
uint64_t size,
uint64_t alignment,
void** out);
int32_t lalloc_set_alloc(lalloc_desc_t* desc, lalloc_alloc_func alloc);
int32_t lalloc_set_free(lalloc_desc_t* desc, lalloc_free_func free);
int32_t lalloc(lalloc_desc_t* desc,
uint64_t size,
void** out);
int32_t lalloc_init(lalloc_desc_t *desc,
void *base,
uint64_t size,
lalloc_alloc_func alloc,
lalloc_free_func free);
int32_t lalloc_mark_used(lalloc_desc_t *desc,
void *base,
uint64_t size);
int32_t lalloc_mark_free(lalloc_desc_t* desc,
void *base,
uint64_t size);
int32_t lfree(lalloc_desc_t *desc,
void *base);
#endif

95
x64/src/common/lib/lalloc/lallo.c
View File

@ -1,95 +0,0 @@
#include <lalloc.h>
#include "lalloc.h"
typedef struct
{
linked_list_node_t list_node;
void *base;
uint64_t size;
} lalloc_desc_node_t;
static void _lalloc_merge_nodes(lalloc_desc_node_t* node)
{
}
int32_t lalloc_aligned(lalloc_desc_t* desc,
uint64_t size,
uint64_t alignment,
void** out)
{
if(desc == NULL || size == 0 || alignment == 0 || out == NULL)
return LALLOC_STATUS_INVALID_ARGUMENTS;
linked_list_node_t* each_list_node = linked_list_first(&desc->free_list);
while(each_list_node != NULL)
{
each_list_node = linked_list_next(each_list_node);
}
}
int32_t lalloc_set_alloc(lalloc_desc_t* desc, lalloc_alloc_func alloc)
{
if(alloc != NULL && desc != NULL)
{
desc->alloc = alloc;
return LALLOC_STATUS_SUCCESS;
}
else
return LALLOC_STATUS_INVALID_ARGUMENTS;
}
int32_t lalloc_set_free(lalloc_desc_t* desc, lalloc_free_func free)
{
if(free != NULL && desc != NULL)
{
desc->free = free;
return LALLOC_STATUS_SUCCESS;
}
else
return LALLOC_STATUS_INVALID_ARGUMENTS;
}
int32_t lalloc(lalloc_desc_t* desc,
uint64_t size,
void** out)
{
return lalloc_aligned(desc, size, 1, out);
}
int32_t lalloc_init(lalloc_desc_t *desc,
void *base,
uint64_t size,
lalloc_alloc_func alloc,
lalloc_free_func free)
{
if (desc == NULL || alloc == NULL || free == NULL || base == NULL)
return LALLOC_STATUS_INVALID_ARGUMENTS;
linked_list_init(&desc->free_list);
linked_list_init(&desc->used_list);
desc->alloc = alloc;
desc->free = free;
lalloc_desc_node_t *node = desc->alloc(sizeof(lalloc_desc_node_t));
if (node == NULL)
return LALLOC_STATUS_CANT_ALLOC_NODE;
node->size = size;
node->base = base;
linked_list_push_back(&desc->free_list, &node->list_node);
return LALLOC_STATUS_SUCCESS;
}
int32_t lalloc_mark_used(lalloc_desc_t *desc,
void *base,
uint64_t size);
int32_t lalloc_mark_free(lalloc_desc_t* desc,
void *base,
uint64_t size);
int32_t lfree(lalloc_desc_t *desc,
void *base);

8
x64/src/common/lib/linked_list/inc/linked_list.h
View File

@ -20,6 +20,12 @@ typedef struct _linked_list_t
linked_list_node_t *tail;
} linked_list_t;
/*
* Returns true if other == your node
* false otherwise
*/
typedef _Bool (*linked_list_node_equals_func_t)(linked_list_node_t * others, linked_list_node_t * yours);
void KAPI linked_list_init(linked_list_t *list);
int KAPI linked_list_size(linked_list_t *list);
@ -50,6 +56,6 @@ linked_list_node_t *KAPI linked_list_first(linked_list_t *list);
linked_list_node_t *KAPI linked_list_last(linked_list_t *list);
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t* target, bool (*equals)(linked_list_node_t*, linked_list_node_t*));
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t* target, linked_list_node_equals_func_t equals);
#endif

6
x64/src/common/lib/linked_list/linked_list.c
View File

@ -283,7 +283,7 @@ linked_list_node_t *KAPI linked_list_last(linked_list_t *list)
return result;
}
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t *target, bool (*equals)(linked_list_node_t *, linked_list_node_t *))
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t *target, linked_list_node_equals_func_t equals)
{
if(list == NULL || target == NULL)
return -1;
@ -291,9 +291,9 @@ int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t *target,
linked_list_node_t* node = linked_list_first(list);
while(node != NULL)
{
if(equals !=NULL)
if(equals != NULL)
{
if (equals(target, node))
if (equals(node, target))
{
return result;
}

64
x64/src/common/lib/talloc/inc/talloc.h Normal file
View File

@ -0,0 +1,64 @@
#ifndef _TALLOC_H_
#define _TALLOC_H_
#include "avl_tree.h"
/*
* A tree allocator for page-size allocation
* All
*/
#define TALLOC_STATUS_SUCCESS 0
#define TALLOC_STATUS_INVALID_ARGUMENTS 1
#define TALLOC_STATUS_NOT_ENOUGH_MEM 2
#define TALLOC_STATUS_CANT_ALLOC_NODE 3
#define TALLOC_STATUS_INVALID_REIGON 4
typedef void *(*talloc_alloc_func)(uint64_t size);
typedef void (*talloc_free_func)(void* ptr);
typedef void (*talloc_lock_func)(void);
typedef void (*talloc_unlock_func)(void);
typedef struct
{
avl_tree_t used_base_tree;
avl_tree_t free_size_tree;
avl_tree_t free_start_tree;
avl_tree_t free_end_tree;
uint64_t page_size;
talloc_alloc_func alloc;
talloc_free_func free;
talloc_lock_func lock;
talloc_unlock_func unlock;
} talloc_desc_t;
int32_t talloc(talloc_desc_t* desc,
uint64_t size,
uint64_t alignment,
void** out);
int32_t talloc_init(talloc_desc_t *desc,
void *base,
uint64_t size,
uint64_t page_size,
talloc_alloc_func alloc,
talloc_free_func free,
talloc_lock_func lock,
talloc_unlock_func unlock);
int32_t talloc_mark_used(talloc_desc_t *desc,
void *base,
uint64_t size);
int32_t talloc_mark_free(talloc_desc_t* desc,
void *base,
uint64_t size);
int32_t tfree(talloc_desc_t *desc,
void *base);
#endif

192
x64/src/common/lib/talloc/talloc.c Normal file
View File

@ -0,0 +1,192 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#include "linked_list.h"
#include "talloc.h"
#include "std_lib.h"
typedef struct
{
avl_tree_node_t tree_node;
uint64_t size;
linked_list_t free_size_list;
} lalloc_free_list_node_t;
typedef struct
{
avl_tree_node_t used_base_tree_node;
linked_list_node_t free_size_list_node;
avl_tree_node_t free_start_tree_node;
avl_tree_node_t free_end_tree_node;
void *base;
uint64_t size;
void *end;
} lalloc_desc_node_t;
static int32_t _lalloc_desc_node_size_compare(avl_tree_node_t *others, avl_tree_node_t *yours)
{
uint64_t osize = OBTAIN_STRUCT_ADDR(others, free_size_tree_node, lalloc_desc_node_t)->size;
uint64_t ysize = OBTAIN_STRUCT_ADDR(yours, free_size_tree_node, lalloc_desc_node_t)->size;
if (osize == ysize)
return 0;
else if (osize > ysize)
return 1;
else
return -1;
}
static int32_t _lalloc_desc_node_start_compare(avl_tree_node_t *others, avl_tree_node_t *yours)
{
uint64_t osize = (uint64_t) (OBTAIN_STRUCT_ADDR(others, free_size_tree_node, lalloc_desc_node_t)->base);
uint64_t ysize = (uint64_t) (OBTAIN_STRUCT_ADDR(yours, free_size_tree_node, lalloc_desc_node_t)->base);
if (osize == ysize)
return 0;
else if (osize > ysize)
return 1;
else
return -1;
}
static int32_t _lalloc_desc_node_end_compare(avl_tree_node_t *others, avl_tree_node_t *yours)
{
uint64_t osize = (uint64_t) (OBTAIN_STRUCT_ADDR(others, free_size_tree_node, lalloc_desc_node_t)->end);
uint64_t ysize = (uint64_t) (OBTAIN_STRUCT_ADDR(yours, free_size_tree_node, lalloc_desc_node_t)->end);
if (osize == ysize)
return 0;
else if (osize > ysize)
return 1;
else
return -1;
}
static void _lalloc_merge_nodes(lalloc_desc_node_t *node)
{
}
static int32_t _lalloc_node_alloc(talloc_desc_t *desc, lalloc_desc_node_t *node, uint64_t size, uint64_t alignment,
void **out)
{
if (desc == NULL || node == NULL || size == 0 || alignment == 0 || out == NULL)
{
return LALLOC_STATUS_INVALID_ARGUMENTS;
}
int32_t result = LALLOC_STATUS_NOT_ENOUGH_MEM;
uint64_t real_base = align_up((uint64_t) node->base, alignment);
uint64_t real_size = node->size - ((uint64_t) real_base - (uint64_t) node->base);
if (real_size >= size)
{
// we've got a hit
uint64_t prev_size = real_base - (uint64_t) node->base;
uint64_t next_size = (uint64_t) node->base + node->size - real_base;
if (prev_size == 0 && next_size == 0)
{
// if the block is just enough
// detach the block and
linked_list_remove_ref(&desc->free_list, &each_desc_node->list_node);
desc->free();
}
result = LALLOC_STATUS_SUCCESS;
}
return result;
}
static inline _Bool _lalloc_is_desc_valid(talloc_desc_t *desc)
{
return desc != NULL && desc->unlock != NULL && desc->lock != NULL && desc->alloc != NULL && desc->free != NULL;
}
int32_t lalloc(talloc_desc_t *desc,
uint64_t size,
uint64_t alignment,
void **out)
{
if (!_lalloc_is_desc_valid(desc) || size == 0 || alignment == 0 || out == NULL)
return LALLOC_STATUS_INVALID_ARGUMENTS;
int32_t result = LALLOC_STATUS_NOT_ENOUGH_MEM;
desc->lock();
linked_list_node_t *each_list_node = linked_list_first(&desc->free_list);
while (each_list_node != NULL)
{
// calculate real base/size w.r.t. alignment
lalloc_desc_node_t *each_desc_node = OBTAIN_STRUCT_ADDR(each_list_node, list_node, lalloc_desc_node_t);
if (_lalloc_node_alloc(desc, each_desc_node, size, alignment, out) == LALLOC_STATUS_SUCCESS)
{
result = LALLOC_STATUS_SUCCESS;
break;
}
each_list_node = linked_list_next(each_list_node);
}
desc->unlock();
return result;
}
int32_t talloc_init(talloc_desc_t *desc,
void *base,
uint64_t size,
uint64_t page_size,
talloc_alloc_func alloc,
talloc_free_func free,
talloc_lock_func lock,
talloc_unlock_func unlock)
{
if (desc == NULL || alloc == NULL || free == NULL ||
size == 0 || page_size == 0 || base == NULL ||
lock == NULL || unlock == NULL || (uint64_t) base % page_size != 0)
return TALLOC_STATUS_INVALID_ARGUMENTS;
avl_tree_init(&desc->used_base_tree);
avl_tree_init(&desc->free_size_tree);
avl_tree_init(&desc->free_start_tree);
avl_tree_init(&desc->free_end_tree,);
avl_tree_init(&desc->used_tree, _lalloc_desc_node_size_compare);
desc->alloc = alloc;
desc->free = free;
desc->lock = lock;
desc->unlock = unlock;
desc->page_size = page_size;
lalloc_desc_node_t *node = desc->alloc(sizeof(lalloc_desc_node_t));
if (node == NULL)
return LALLOC_STATUS_CANT_ALLOC_NODE;
node->size = size;
node->base = base;
linked_list_push_back(&desc->free_list, &node->list_node);
return LALLOC_STATUS_SUCCESS;
}
int32_t lalloc_mark_used(talloc_desc_t *desc,
void *base,
uint64_t size)
{
}
int32_t lalloc_mark_free(talloc_desc_t *desc,
void *base,
uint64_t size);
int32_t lfree(talloc_desc_t *desc,
void *base);

406
x64/src/test/k_avl_tree_test.c
View File

@ -77,18 +77,18 @@ static bool insert_simple_l()
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {1, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_simple_r()
@ -101,18 +101,18 @@ static bool insert_simple_r()
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {3, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_simple_ll()
@ -124,18 +124,18 @@ static bool insert_simple_ll()
//3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
int val1[] = {2, 4};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_simple_rr()
@ -147,18 +147,18 @@ static bool insert_simple_rr()
// 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {4, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_complex_1()
@ -172,21 +172,21 @@ static bool insert_complex_1()
// 15 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
int val2[] = {9, 4, 3, 20, 15, 26};
result = result && pre_order_assert(&tree, val2, 6);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_complex_2()
@ -200,21 +200,21 @@ static bool insert_complex_2()
// 8 3 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
int val2[] = {9, 4, 3, 8, 20, 26};
result = result && pre_order_assert(&tree, val2, 6);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_complex_3()
@ -230,26 +230,26 @@ static bool insert_complex_3()
// 15 2
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
int val2[] = {9, 4, 3, 2, 7, 20, 11, 15, 26, 21, 30};
result = result && pre_order_assert(&tree, val2, 11);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_complex_4()
@ -265,26 +265,26 @@ static bool insert_complex_4()
// 8 2 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
int val2[] = {9, 4, 3, 2, 7, 8, 20, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val2, 11);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool insert_duplicate()
@ -300,28 +300,28 @@ static bool insert_duplicate()
// 8 2 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
result = result && pre_order_assert(&tree, val1, 10);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
@ -335,22 +335,22 @@ static bool delete_simple_l()
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
int val1[] = {2, 1, 3, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_simple_r()
@ -363,22 +363,22 @@ static bool delete_simple_r()
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_simple_ll()
@ -390,22 +390,22 @@ static bool delete_simple_ll()
// 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val1[] = {2, 1, 4, 3};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_simple_rr()
@ -417,22 +417,22 @@ static bool delete_simple_rr()
// 1
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_1()
@ -448,18 +448,18 @@ static bool delete_complex_1()
// empty tree
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry);
int val1[] = {10};
result = result && pre_order_assert(&tree, val1, 1);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
result = result && pre_order_assert(&tree, val1, 0);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_2()
@ -486,23 +486,23 @@ static bool delete_complex_2()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(20);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
int val1[] = {20, 10, 30, 25, 35};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {25, 10, 30, 35};
result = result && pre_order_assert(&tree, val2, 4);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_3()
@ -525,24 +525,24 @@ static bool delete_complex_3()
// 5 25
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 15, 5, 30, 25};
result = result && pre_order_assert(&tree, val2, 5);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_4()
@ -564,7 +564,7 @@ static bool delete_complex_4()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *delete5 = create_tree_node(5);
int_tree_node *delete10 = create_tree_node(10);
@ -573,25 +573,25 @@ static bool delete_complex_4()
int_tree_node *delete30 = create_tree_node(30);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &delete10->tree_entry, compare);
avl_tree_insert(&tree, &delete30->tree_entry, compare);
avl_tree_insert(&tree, &delete5->tree_entry, compare);
avl_tree_insert(&tree, &delete15->tree_entry, compare);
avl_tree_insert(&tree, &delete25->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &delete10->tree_entry);
avl_tree_insert(&tree, &delete30->tree_entry);
avl_tree_insert(&tree, &delete5->tree_entry);
avl_tree_insert(&tree, &delete15->tree_entry);
avl_tree_insert(&tree, &delete25->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &delete5->tree_entry, compare);
avl_tree_delete(&tree, &delete15->tree_entry, compare);
avl_tree_delete(&tree, &delete25->tree_entry, compare);
avl_tree_delete(&tree, &delete10->tree_entry, compare);
avl_tree_delete(&tree, &delete30->tree_entry, compare);
avl_tree_delete(&tree, &delete5->tree_entry);
avl_tree_delete(&tree, &delete15->tree_entry);
avl_tree_delete(&tree, &delete25->tree_entry);
avl_tree_delete(&tree, &delete10->tree_entry);
avl_tree_delete(&tree, &delete30->tree_entry);
int val2[] = {20};
result = result && pre_order_assert(&tree, val2, 1);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_single_rotation()
@ -623,30 +623,30 @@ static bool delete_complex_single_rotation()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(50);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 10, 5, 15, 12, 30, 25, 22, 35, 31, 40};
result = result && pre_order_assert(&tree, val2, 11);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_double_rotation()
@ -678,30 +678,30 @@ static bool delete_complex_double_rotation()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(22);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 10, 5, 15, 12, 35, 30, 25, 31, 40, 50};
result = result && pre_order_assert(&tree, val2, 11);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_complex_multiple_rotation()
@ -733,30 +733,30 @@ static bool delete_complex_multiple_rotation()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(5);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &deleted->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry, compare);
avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {30, 20, 12, 10, 15, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val2, 11);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
static bool delete_DNE()
@ -781,25 +781,25 @@ static bool delete_DNE()
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
int_tree_node *delete100 = create_tree_node(100);
int_tree_node *delete24 = create_tree_node(24);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &delete24->tree_entry, compare);
avl_tree_delete(&tree, &delete100->tree_entry, compare);
avl_tree_delete(&tree, &delete24->tree_entry);
avl_tree_delete(&tree, &delete100->tree_entry);
result = result && pre_order_assert(&tree, val1, 6);
return result && avl_tree_validate(&tree, compare);
return result && avl_tree_validate(&tree);
}
#define AVL_APOCALYPSE_NUM 500
@ -810,21 +810,21 @@ static bool test_apocalypse()
{
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree);
avl_tree_init(&tree, compare);
// insert test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
apocalypse[i].val = rand();
while(avl_tree_search(&tree, &apocalypse[i].tree_entry,compare) != NULL)
while(avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL)
{
apocalypse[i].val += rand() % 32765;
}
avl_tree_insert(&tree, &apocalypse[i].tree_entry, compare);
avl_tree_insert(&tree, &apocalypse[i].tree_entry);
}
// integrity test
result = result && avl_tree_validate(&tree, compare);
result = result && avl_tree_validate(&tree);
result = result && avl_tree_size(&tree) == AVL_APOCALYPSE_NUM;
// smaller and bigger test
@ -877,10 +877,10 @@ static bool test_apocalypse()
// delete and search test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry, compare) != NULL);
avl_tree_delete(&tree,&apocalypse[i].tree_entry, compare);
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry, compare) == NULL);
result = result && avl_tree_validate(&tree, compare);
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry) != NULL);
avl_tree_delete(&tree,&apocalypse[i].tree_entry);
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry) == NULL);
result = result && avl_tree_validate(&tree);
}
result = result && (avl_tree_size(&tree) == 0);