int LCUIMM_Free( void *mem_ptr )
{
int size;
rb_node_t *node;
mem_data_t mem_data;
mem_data.mem_blk.mem_addr = mem_ptr;
/* 先查找该地址的内存块信息 */
node = rb_search( global_mem_data.root,
&mem_data, RB_DATA_TYPE_ADDR );
if( node ) {
/* 记录该内存块的类别ID，以及内存块的大小 */
mem_data.mem_info.class_id = node->mem_data.mem_blk.class_id;
size = node->mem_data.mem_blk.mem_size;
/* 找到与类别ID对应的类别结点指针 */
node = rb_search( global_mem_class_info.root,
&mem_data, RB_DATA_TYLE_INFO );
if( node ) {
/* 更新该类别内存块的总内存用量的大小 */
node->mem_data.mem_info.total_size -= size;
}
} else {
DEBUG_MSG("%p can not be released !\n");
return -1;
}
mem_data.mem_blk.mem_addr = mem_ptr;
if( -1 == rb_erase( &global_mem_data,
&mem_data, RB_DATA_TYPE_ADDR ) ) {
printf("%p can not be released !\n");
return -1;
}
return 0;
}
void *LCUIMM_Alloc( size_t size, unsigned int class_id )
{
rb_node_t *node;
mem_data_t mem_data;
mem_data.mem_info.class_id = class_id;
/* 查找该类别的结点 */
node = rb_search( global_mem_class_info.root,
&mem_data, RB_DATA_TYLE_INFO );
/* 如果不存在，则用默认类别的结点 */
if( node == NULL ) {
mem_data.mem_info.class_id = 0;
node = rb_search( global_mem_class_info.root,
&mem_data, RB_DATA_TYLE_INFO );
/* 如果默认类别的结点不存在，则说明出问题了 */
if( node == NULL ) {
abort();
}
}
/* 分配内存空间，并记录它 */
mem_data.mem_blk.mem_addr = malloc( size );
/* 分配失败则返回NULL */
if( mem_data.mem_blk.mem_addr == NULL ) {
return NULL;
}
mem_data.mem_blk.mem_size = size;
/* 累计该类别的总内存空间大小 */
node->mem_data.mem_info.total_size += size;
/* 插入该内存的信息 */
rb_insert( &global_mem_data, &mem_data, RB_DATA_TYPE_ADDR );
return mem_data.mem_blk.mem_addr;
}
rbn* rb_search(rbn *x, int k)
{
if (x == NULL || k == x->key)
return x;
if (k < x->key)
return rb_search(x->left, k);
else
return rb_search(x->right, k);
}
rb_node_t* rb_search(rb_node_t* root,int key)
{
rb_node_t* nodes = NULL;
if(root == &nil) return nodes;
if(key == root->key)
return root;
if(key<root->key)
nodes = rb_search(root->lchild,key);
else
nodes = rb_search(root->rchild,key);
return nodes;
}
static NEINT32 clean_user(unsigned long id)
{
user_info_t *user_info;
rb_node_t *usernode;
ne_rdlock(&id_map_lock);
usernode = rb_search(id, userid_map);
if (!usernode || !usernode->data) {
ne_rwunlock(&id_map_lock);
LOG_ERROR(mycat, "%s %d: can not find usernode[%d]", __FUNC__, __LINE__, id);
return (-1);
}
user_info = usernode->data;
ne_rwunlock(&id_map_lock);
ne_wrlock(&id_map_lock);
userid_map = rb_erase(id, userid_map);
ne_rwunlock(&id_map_lock);
ne_wrlock(&name_map_lock);
username_map = rb_erase_v2(user_info->base.rolename, username_map);
ne_rwunlock(&name_map_lock);
ne_mutex_lock(&map_lock);
list_del(&user_info->quad_lst);
ne_mutex_unlock(&map_lock);
LOG_DEBUG(mycat, "%s %d: user[%s] id[%d] x[%lf] y[%lf]",
__FUNC__, __LINE__, user_info->base.rolename, user_info->id, user_info->base.pos_x, user_info->base.pos_y);
free(user_info);
return (0);
}
int
main(void)
{
rbt root;
int i;
int key[] = { 1, 2, 4, 5, 7, 8, 11, 14, 15, 39, 29, 73, 24, 18, 18, 18, 18};
int key2[] = {15, 14, 11, 8, 7, 5, 4, 2, 1, 18, 73, 24, 39, 29, 18, 18, 18};
/*int key[] = {41, 38, 31, 12, 19, 8};
int key2[] = { 8, 12, 19, 31, 38, 41};*/
rbn nil = { BLACK, 0, NULL, NULL, NULL};
root.nil = &nil;
root.root = &nil;
rbn *tmp;
for (i = 0; i < sizeof(key2) / sizeof(int); i++) {
tmp = malloc(sizeof(rbn));
tmp->key = key2[i];
rb_insert(&root, tmp);
printf("insert:%d\n", tmp->key);
}
for (i = 0; i < sizeof(key) / sizeof(int); i++) {
tmp = rb_search(root.root, key[i]);
rb_delete(&root, tmp);
printf("deleted:%d\n", tmp->key);
}
printf("\n");
return 0;
}
tree_data *rb_insert(rb_tree * tree, long int distance)
{
rb_node *n;
tree_data *data;
/* We search for the right place to insert */
data = rb_search(tree, distance);
/* If the node doesn't exists */
if (!data) {
/* we create the node */
n = new_rb_node(tree);
(n->data).queue.first = NULL;
(n->data).queue.last = NULL;
/* then we rebalance the tree */
rb_insert_rebalancing(tree);
return &(n->data);
}
return data;
}
static struct vdi_state_entry *vdi_state_search(struct rb_root *root,
uint32_t vid)
{
struct vdi_state_entry key = { .vid = vid };
return rb_search(root, &key, node, vdi_state_cmp);
}
/* Checks that TREE's structure is kosher and verifies that the values
in ARRAY are actually in the tree. There must be as many elements
in ARRAY as there are nodes in the tree. Exits the program if an
error was encountered. */
void verify_tree(struct rb_tree *tree, int array[])
{
int count = 0;
int okay = 1;
recurse_tree(tree->root, &count, INT_MIN, 0, &okay);
if (count != tree->count) {
printf(" Tree has %d nodes, but tree count is %d.\n", count, tree->count);
okay = 0;
}
if (okay) {
int i;
for (i = 0; i < tree->count; i++)
if (!rb_search(tree, array[i])) {
printf("Tree does not contain expected value %d.\n", array[i]);
okay = 0;
}
}
if (!okay) {
printf("Error(s) encountered, aborting execution.\n");
exit(EXIT_FAILURE);
}
}
void rb_insert(rbtree* tree, int data) {
rbnode* pn = rb_search(tree, data);
rbnode* nn = create_rbnode(data);
if (!pn) {
tree->root = nn;
nn->color = BLACK;
return;
}
else if (data == pn->data) {
return;
}
else if (data < pn->data) {
pn->left = nn;
nn->parent = pn;
}
else if (data > pn->data) {
pn->right = nn;
nn->parent = pn;
}
while (pn && pn->color == RED) {
if (IS_LEFT(pn)) {
rbnode* uncle = pn->parent->right;
if (uncle && uncle->color == RED) {
pn->color = uncle->color = BLACK;
pn->parent->color = RED;
nn = pn->parent;
pn = nn->parent;
continue;
}
if (IS_RIGHT(nn)) {
LEFT_ROTATE(tree, pn);
SWAP(nn, pn, rbnode*);
}
RIGHT_ROTATE(tree, pn->parent);
pn->color = BLACK;
pn->right->color = RED;
break;
}
else {
rbnode* uncle = pn->parent->left;
if (uncle && uncle->color == RED) {
pn->color = uncle->color = BLACK;
pn->parent->color = RED;
nn = pn->parent;
pn = nn->parent;
continue;
}
if (IS_LEFT(nn)) {
RIGHT_ROTATE(tree, pn);
SWAP(nn, pn, rbnode*);
}
LEFT_ROTATE(tree, pn->parent);
pn->color = BLACK;
pn->left->color = RED;
break;
}
}
// nn is root
if (!pn) nn->color = BLACK;
}
static NEINT32 user_scene_req(NEUINT16 sessionid, ne_usermsgbuf_t *msg , ne_handle listener)
{
NEUINT32 id;
user_info_t *user_info = NULL;
monster *mon = NULL;
rb_node_t *usernode;
struct list_head *retlist[MAX_QUAD_SEARCH];
struct list_head *pos;
ne_usermsgbuf_t buf, buf_monster;// = NE_USERMSG_INITILIZER;
user_scene_ack_t *ack = (user_scene_ack_t *)buf.data;
monster_scene_ack_t *ack_monster = (monster_scene_ack_t *)buf_monster.data;
user_scene_req_t *req = (user_scene_req_t *)msg->data;
NEINT32 ret;
NEINT32 index;
NEINT32 i;
assert(NE_USERMSG_MAXID(msg) == MAXID_SERVER_SERVER);
assert(NE_USERMSG_MINID(msg) == MSG_USER_SCENE_REQ);
id = NE_USERMSG_PARAM(msg);
ne_rdlock(&id_map_lock);
usernode = rb_search(id, userid_map);
if (!usernode || !usernode->data) {
ne_rwunlock(&id_map_lock);
LOG_ERROR(mycat, "%s %d: can not find usernode[%d]", __FUNC__, __LINE__, id);
return (-1);
}
user_info = usernode->data;
ne_rwunlock(&id_map_lock);
user_info->rollcall = 0;
quadbox_t box = {user_info->base.pos_x - 100,
user_info->base.pos_y - 100,
user_info->base.pos_x + 100,
user_info->base.pos_y + 100};
index = 0;
ne_mutex_lock(&map_lock);
ne_rdlock(&monster_lock);
quadtree_search(mapobj_tree, &box, retlist, &index, MAX_QUAD_SEARCH);
ack->num = 0;
for (i = 0; i < index; ++i) {
list_for_each(pos, retlist[i]) {
user_info = list_entry(pos, user_info_t, quad_lst);
if (user_info->base.type & 0xf) {
memcpy(&ack->player[ack->num], &user_info->base, sizeof(player_base_t));
++ack->num;
} else {
mon = list_entry(pos, monster, quad_lst);
memcpy(&ack_monster->monster[ack->num], &mon->base, sizeof(monster_base_t));
mon->observered = NETRUE;
++ack_monster->num;
}
}
}
/*
Invoked when flushing is complete.
*/
INT32 vmm_fmap_flushed_callback(struct fsio_event_source *iosrc, INT32 ioret)
{
struct vmm_fmap_descriptor *fm = MEMREGNODE2FMAPDESC(rb_search(&vmm.fmap_descriptors, iosrc->id));
struct pm_task *task = tsk_get(fm->creating_task);
if(task == NULL) return 0;
if(task->command_inf.callback != NULL)
task->command_inf.callback(task, ioret, 0);
return 1;
}
void delete_Sedgewick(NODE * t, int v)
{
assert(rb_search(t, v));
if (dbg_level == 0) {
fprintf(stderr, "%s~%d%s, ", RED, v, NOCOLOR);
Sedgewick_rb_delete(t, v);
verify_rbtree(t->L, 0);
} else {
printf("%sdelete %d%s\n", RED, v, NOCOLOR);
Sedgewick_rb_delete(t, v);
______________________________("./fig/", t, t, "deleted %d", v);
}
}
/* Swap two files on the playlist. */
void plist_swap_files (struct plist *plist, const char *file1,
const char *file2)
{
struct rb_node *x1, *x2;
assert (plist != NULL);
assert (file1 != NULL);
assert (file2 != NULL);
x1 = rb_search (plist->search_tree, file1);
x2 = rb_search (plist->search_tree, file2);
if (!rb_is_null(x1) && !rb_is_null(x2)) {
const void *t;
plist_swap (plist, (intptr_t)rb_get_data (x1),
(intptr_t)rb_get_data (x2));
t = rb_get_data (x1);
rb_set_data (x1, rb_get_data (x2));
rb_set_data (x2, t);
}
}
/* Find an item in the list. Return the index or -1 if not found. */
int plist_find_fname (struct plist *plist, const char *file)
{
struct rb_node *x;
assert (plist != NULL);
x = rb_search (plist->search_tree, file);
if (rb_is_null(x))
return -1;
return !plist_deleted(plist, (intptr_t)rb_get_data (x)) ?
(intptr_t)rb_get_data (x) : -1;
}
INT32 vmm_fmap_flush_seek_callback(struct fsio_event_source *iosrc, INT32 ioret)
{
struct vmm_fmap_descriptor *fm = MEMREGNODE2FMAPDESC(rb_search(&vmm.fmap_descriptors, iosrc->id));
struct pm_task *task = tsk_get(fm->creating_task);
struct vmm_memory_region *mreg;
struct vmm_page_directory *pdir = task->vmm_info.page_directory;
struct vmm_page_table *tbl = NULL;
struct vmm_pman_assigned_record *assigned = NULL;
if(task == NULL) return 0;
mreg = vmm_region_get_bydesc(task, (struct vmm_descriptor*)fm);
if(mreg == NULL) return 0;
tbl = (struct vmm_page_table *)PHYSICAL2LINEAR(PG_ADDRESS(pdir->tables[PM_LINEAR_TO_TAB(fm->release_addr)].b));
if(ioret == IO_RET_OK)
{
/* If flushing save assigned record */
if(fm->io_finished.params[0] == 1)
{
assigned = vmm_get_assigned(task->id, fm->release_addr);
fm->io_finished.params[1] = *((UINT32*)assigned);
}
/*
Map page onto pman space. (assigned record is preserved on fm->io_finished.params[1])
*/
page_in(PMAN_TASK, (ADDR)PHYSICAL2LINEAR(PG_ADDRESS(tbl->pages[PM_LINEAR_TO_TAB(fm->release_addr)].entry.phy_page_addr)),
(ADDR)tbl->pages[PM_LINEAR_TO_TAB(fm->release_addr)].entry.phy_page_addr, 2, PGATT_WRITE_ENA);
/* Write and set callback to continue. */
fm->io_finished.callback = vmm_fmap_flush_callback;
io_begin_write(&fm->iosrc, 0x1000, (ADDR)PHYSICAL2LINEAR(PG_ADDRESS(tbl->pages[PM_LINEAR_TO_TAB(fm->release_addr)].entry.phy_page_addr)));
return 1;
}
else
{
/* Remove IOLOCK */
vmm_set_flags(fm->creating_task, (ADDR)PHYSICAL2LINEAR(PG_ADDRESS(tbl->pages[PM_LINEAR_TO_TAB(fm->release_addr)].entry.phy_page_addr)), TRUE, TAKEN_EFLAG_IOLOCK, FALSE);
/* Failed */
if(task->command_inf.callback != NULL)
task->command_inf.callback(task, ioret, 0);
}
return 0;
}
size_t LCUIMM_GetMemSize( unsigned int class_id )
{
rb_node_t *node;
mem_data_t mem_data;
mem_data.mem_info.class_id = class_id;
/* 查找该类别的结点 */
node = rb_search( global_mem_class_info.root,
&mem_data, RB_DATA_TYLE_INFO );
/* 如果不存在，则用默认类别的结点 */
if( node == NULL ) {
return 0;
}
return node->mem_data.mem_info.total_size;
}
static bool rb_has(struct rbtree **tree, uint64_t key)
{
struct rbtree *node;
node = rb_search(*tree, key);
if (node && node->key == key)
return true;
node = malloc(sizeof *node);
if (node) {
node->key = key;
*tree = rb_insert(*tree, node);
}
return false;
}
void delete_CLRS(NODE * t, int v)
{
NODE * to_del = rb_search(t, v);
assert(to_del);
if (dbg_level == 0) {
fprintf(stderr, "%s~%d%s, ", RED, v, NOCOLOR);
rb_delete(t, to_del);
verify_rbtree(t->L, 0);
} else {
printf("%sdelete %d%s\n", RED, v, NOCOLOR);
rb_delete(t, to_del);
______________________________("./fig/", t, t, "deleted %d", v);
}
}
int main(void) {
nil.color = BLACK;
int arr[10] = {2,3,4,1,6,5,7,9,8};
rb_node_t* root1 = rb_create(9,arr);
inordertraverse(root1);
// printf("%d",root1->lchild->key);
printf("\n");
rb_node_t* nodedele = rb_search(root1,4);
if(nodedele!=NULL)
{
root1 = rb_delete(root1,nodedele);
}
inordertraverse(root1);
return EXIT_SUCCESS;
}
/*
Function invoked when the file has been taken over for mapping.
NOTE: IO src belongs to fmap descriptor!
*/
INT32 fmap_takeover_callback(struct fsio_event_source *iosrc, INT32 ioret)
{
struct pm_task *task = NULL;
struct vmm_fmap_descriptor *fm = MEMREGNODE2FMAPDESC(rb_search(&vmm.fmap_descriptors, iosrc->id));
struct vmm_memory_region *mreg;
struct pm_thread *thr = NULL;
if(fm == NULL) return 0;
task = tsk_get(fm->io_finished.params[0]); // params[0] has the task id
if(task == NULL) return 0;
/* If file open succeded send a successful response. */
if(ioret == IO_RET_ERR)
{
/* Takeover failed, remove the memory region from it's trees */
ma_remove(&task->vmm_info.regions, &fm->regions->tsk_node);
rb_remove(&task->vmm_info.regions_id, &fm->regions->tsk_id_node);
kfree(fm);
kfree(mreg);
}
else
{
/* Get our file id for this file */
fm->iosrc.file_id = fm->gnode.value = task->io_finished.params[0];
/* Add the FMAP descriptor to the global list */
rb_insert(&vmm.fmap_descriptors, &fm->gnode, FALSE);
}
/* Activate task threads again. */
task->state = TSK_NORMAL;
thr = task->first_thread;
while(thr != NULL)
{
sch_deactivate(thr);
thr = thr->next_thread;
}
if(task->command_inf.callback != NULL)
task->command_inf.callback(task, ioret, 0);
return 1;
}
void rb_delete (struct rb_tree *t, const void *key)
{
struct rb_node *z;
assert (t != NULL);
assert (t->root != NULL);
assert (key != NULL);
z = rb_search (t, key);
if (z != &rb_null) {
struct rb_node *x, *y, *parent;
if (z->left == &rb_null || z->right == &rb_null)
y = z;
else
y = rb_next (z);
if (y->left != &rb_null)
x = y->left;
else
x = y->right;
parent = y->parent;
if (x != &rb_null)
x->parent = parent;
if (y->parent == &rb_null)
t->root = x;
else {
if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
}
if (y != z)
z->data = y->data;
if (y->color == RB_BLACK)
rb_delete_fixup (&t->root, x, parent);
free (y);
}
}
void su_peer_reply_ignore_act(su_peer_t *psar)
{
rb_key_cache_t key;
memcpy(&key.destaddr, &psar->nowsynframe->srcaddr, sizeof(SAUN));
key.destlen = psar->nowsynframe->srclen;
key.seq = psar->nowsynframe->recvhdr.seq;
key.sid = psar->nowsynframe->recvhdr.sid;
struct rb_node *cachenode;
cache_t *frees;
if ((cachenode = rb_search(&psar->rbackcache, &key))) {
frees = rb_entry(cachenode, cache_t, rbn);
list_remove (&frees->frame.node);
rb_erase (&frees->rbn, &psar->rbackcache);
free(frees);
return;
}
}
int main (int argc, const char * argv[])
{
int i = 0;
int count = 100000;
key_t key;
rb_node_t *root = NULL;
rb_tree *tree = rb_new_tree();
srand(time(NULL));
for (i = 1; i < count; i++) {
key = rand() % count;
rb_node_t *node = rb_new_node(key, i);
if (rb_insert(tree,node) != tree->nil) {
printf("[i = %d] insert key %d success!\n",i,key);
} else {
printf("[i = %d] insert key %d failed!\n",i,key);
exit(1);
}
if (rb_search(tree, key) != tree->nil) {
printf("[i = %d] search key %d success!\n", i, key);
}else {
exit(1);
}
if (!(i%10)) {
if (rb_delete(tree, node)) {
printf("[i = %d] delete key %d success!\n", i, key);
} else {
printf("[i = %d] delete key %d failed!\n", i, key);
}
}
}
printf("Hello, World!\n");
return 0;
}
INT32 vmm_fmap_realeased_callback(struct fsio_event_source *iosrc, INT32 ioret)
{
struct vmm_fmap_descriptor *fm = MEMREGNODE2FMAPDESC(rb_search(&vmm.fmap_descriptors, iosrc->id));
struct pm_task *task = tsk_get(fm->creating_task);
struct vmm_memory_region *mreg;
if(task == NULL) return 0;
mreg = vmm_region_get_bydesc(task, (struct vmm_descriptor*)fm);
if(mreg == NULL) return 0;
if(ioret == IO_RET_OK)
{
/* Remove memory region from trees */
ma_remove(&task->vmm_info.regions, &mreg->tsk_node);
rb_remove(&task->vmm_info.regions_id, &mreg->tsk_id_node);
kfree(mreg);
/* Remove FMAP descriptor from global list */
rb_remove(&vmm.fmap_descriptors, &fm->gnode);
/* Free structures */
kfree(fm);
kfree(mreg);
/* Invoke command module callback */
if(task->command_inf.callback != NULL)
task->command_inf.callback(task, ioret, 0);
return 1;
}
else
{
/* Failed */
if(task->command_inf.callback != NULL)
task->command_inf.callback(task, ioret, 0);
return 0;
}
}
unsigned int LCUIMM_NewClass( char *class_name )
{
rb_node_t *node;
mem_data_t mem_data;
mem_data.mem_info.class_id = BKDRHash(class_name);
strncpy( mem_data.mem_info.class_name, class_name, 32 );
mem_data.mem_info.class_name[31] = 0;
mem_data.mem_info.total_size = 0;
node = rb_search( global_mem_class_info.root,
&mem_data, RB_DATA_TYLE_INFO );
if( node == NULL ) {
rb_insert( &global_mem_class_info,
&mem_data, RB_DATA_TYLE_INFO );
global_mem_class_info.total_node += 1;
} else {
DEBUG_MSG( "%s class is exist !", class_name );
}
return mem_data.mem_info.class_id;
}
void vm_insert_vma(ProcVM *proc, ProcVMA *vma) {
kassert(vma->vm_start < vma->vm_end);
rb_insert(&(proc->mmap_root), &(vma->vm_link));
#if defined(__PCORE_NO_OPTIMIZE__)
// Check overlap.
RBNode *x = rb_search(&(proc->mmap_root), vma_key_compare, &(vma->vm_start));
kassert(x != NULL);
RBNode *y = rb_node_prev(&(proc->mmap_root), x);
if (y != NULL) {
vma_check_overlap(rbn2vma(y, vm_link), vma);
}
y = rb_node_next(&(proc->mmap_root), x);
if (y != NULL) {
vma_check_overlap(vma, rbn2vma(y, vm_link));
}
#endif // __PCORE_NO_OPTIMIZE__
atomic_add(&(proc->map_count), 1);
}
int freeConn(int fd, connTree *tree) {
rb_node_t *nd = NULL;
conn *connection = NULL;
if(tree->connCnt > 0 && (nd = rb_search(fd, tree->root))) {
connection = nd->data;
if(!connection) {
printf("free connection error!\n");
return -1;
}
tree->connCnt -= 1;
if(!(tree->root = rb_erase(fd, tree->root)) && tree->connCnt != 0) {
printf("rb_erase connection node failed!\n");
return -1;
}
free(connection->buf);
free(connection);
if(tree->connCnt == 0) tree->root = NULL;
writeLog(1, "connection fd %d closed.", fd);
}
return 1;
}
int add_vnode(rb_node_t *root, pnode *mac_node)
{
rb_node_t *node = NULL;
int ret, i;
for(i = 0; i < vns; i++)
{
if (rb_insert(mac_node->vkey[i], mac_node->ipv4, root))
{
printf("rbtree insert vkey[%u], %s success.\n",
mac_node->vkey[i], mac_node->ipv4);
node = rb_search(mac_node->vkey[i], root);
printf("search result %u\t%s.\n", node->key, node->data);
ret = 0;
}
else
{
printf("rbtree insert vkey[%u] error.\n", mac_node->vkey[i]);
ret = -1;
}
}
return ret;
}
void plot_succ_rb(int n, int cutoff, FILE *gnuplot_ins, FILE *gnuplot_succ, FILE *gnuplot_total){
printf("RBt: %d elements\n",n);
srandom(235423);
struct timespec succ, ins, start, end;
succ.tv_nsec = 0;
succ.tv_sec = 0;
ins.tv_nsec = 0;
ins.tv_sec = 0;
rb_tree * rbt = rb_init();
int i;
for (i = 0; i < n; i++){
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
rb_insert(i, rbt);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
increment(&ins, &start, &end);
}
linked_list * ll = get_key_list(rbt, cutoff);
linked_list_node * node= ll->first;
int ii = 0;
while(node){
ii++;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
rb_search(node->data, rbt);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
node = node->next;
increment(&succ, &start, &end);
}
printf("searched %d keys\n", ii);
if(gnuplot_ins)
fprintf(gnuplot_ins, "%d %ld\n", n, ((ins.tv_sec* 1000000000)+(ins.tv_nsec))/n);
if(gnuplot_succ)
fprintf(gnuplot_succ, "%d %ld\n", n, ((succ.tv_sec*1000000000)+(succ.tv_nsec))/(ii));
if(gnuplot_total)
fprintf(gnuplot_total, "%d %ld\n", n, (((ins.tv_sec + succ.tv_sec) * 1000)+(ins.tv_nsec + succ.tv_nsec)/1000000));
rb_destruct(rbt);
linked_list_destruct(ll);
}
