int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
tmp = btree_create("test.mmap", 3, 400, 1024);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
setup(tmp);
btree_insert(tmp, 'd', &data_idx);
btree_insert(tmp, 'f', &data_idx);
btree_insert(tmp, 'v', &data_idx);
btree_delete(tmp, 'i');
btree_delete(tmp, 'f');
btree_delete(tmp, 'e');
btree_delete(tmp, 'y');
btree_delete(tmp, 't');
btree_dump_dot(tmp);
btree_free(tmp);
return 0;
}
/*!-----------------------------------------------------------------------
i n s e r t M e m o r y C h u n k
@brief Insert a chunk of memory into both indices.
This function will insert a chunk of memory into both indices.
@param[in] - The header of the memory chunk to insert
@return 0 = Success
~0 = Failure (errno value)
------------------------------------------------------------------------*/
static int insertMemoryChunk ( memoryChunk_t* chunk )
{
int status = 0;
//
// Go insert the given memory chunk into the bySize index.
//
status = btree_insert ( &sysControl->availableMemoryBySize, chunk );
if ( status != 0 )
{
printf ( "Error: Could not insert memory chunk by size at offset %lx "
"- Aborting\n", chunk->offset );
return status;
}
//
// Go insert the given memory chunk into the byOffset index.
//
status = btree_insert ( &sysControl->availableMemoryByOffset, chunk );
if ( status != 0 )
{
printf ( "Error: Could not insert memory chunk by offset at %lx - "
"Aborting\n", chunk->offset );
}
return status;
}
int main(void)
{
btree_tree *tmp;
int error = 0;
tmp = btree_create("test.mmap", 3, 400, 1024, &error);
if (!tmp) {
printf("Couldn't create tree from disk image error %d.\n", error);
exit(1);
}
setup(tmp);
btree_insert(tmp, 'd');
btree_insert(tmp, 'f');
btree_insert(tmp, 'v');
btree_delete(tmp, 'i');
btree_delete(tmp, 'f');
btree_delete(tmp, 'e');
btree_delete(tmp, 'y');
btree_delete(tmp, 't');
btree_dump_dot(tmp);
btree_close(tmp);
return 0;
}
R_API void btree_insert(struct btree_node **T, struct btree_node *p, BTREE_CMP(cmp))
{
int ret = cmp (p->data, (*T)->data);
if (ret<0) {
if ((*T)->left) btree_insert (&(*T)->left, p, cmp);
else (*T)->left = p;
} else if (ret>0) {
if ((*T)->right) btree_insert (&(*T)->right, p, cmp);
else (*T)->right = p; } }
int main()
{
int arr[] = {18, 31, 12, 10, 15, 48, 45, 47, 50, 52, 23, 30, 20};
// int arr[] = {18, 31, 12, 10};
btree_node *root = btree_create();
for(int i = 0; i < sizeof(arr) / sizeof(int); i++)
{
root = btree_insert(root, arr[i]);
btree_level_display(root);
btree_linear_print(root);
}
//int todel[] = {15, 18, 23, 30, 31, 52, 50};
int todel[] = {45, 30, 12, 10};
for(int i = 0; i < sizeof(todel) / sizeof(int); i++)
{
printf("after delete %d\n", todel[i]);
root = btree_delete(root, todel[i]);
btree_level_display(root);
btree_linear_print(root);
}
return 0;
}
void db_write_test()
{
uint8_t key[KEYSIZE];
int v_len=strlen(val);
start_timer();
int i;
for (i = 0; i < NUM; ++i)
{
memset(key,0,sizeof(key));
sprintf((char *) key, "%dkey", i);
btree_insert(&btree, key, val, v_len);
if((i%10000)==0)
{
fprintf(stderr,"finished %d ops%30s\r",i,"");
fflush(stderr);
}
}
printf(LINE);
double cost=get_timer();
printf("|write (succ:%ld): %.6f sec/op; %.1f writes/sec(estimated); %.1f MB/sec; cost:%.6f(sec)\n"
,NUM
,(double)(cost/NUM)
,(double)(NUM/cost)
,(_file_size/cost)
,(double)cost);
}
int vfs_mount(struct vnode *node, int fsnum, u32 dev, u32 flags)
{
ASSERT(V_ISDIR(node->v_flags));
ASSERT(fstypes[fsnum].vfs_ops);
ASSERT(node->v_count == 1);
struct vfs *new_vfs = create_empty_vfs(fsnum);
struct vnode *new_root = create_empty_vnode(new_vfs);
new_vfs->vfs_flags = flags;
new_vfs->vfs_dev = dev;
new_vfs->v_root = new_root;
new_root->v_name[0] = '/';
new_root->v_flags = V_DIR;
int ret = fstypes[fsnum].vfs_ops->vfs_mount(new_vfs);
if (!ret)
{
btree_insert(node->v_vfs->vfs_mounts, (void*) node->v_inode, new_vfs);
vget(new_root);
}
return ret;
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
size_t size;
time_t ts;
char *data;
int i;
char testdata[11];
// testing too large data
tmp = btree_create("test.mmap", 102, 204, 10);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
for (i = 0; i < 205; i++) {
if (btree_insert(tmp, i * 3, &data_idx)) {
sprintf(testdata, "H: %07d", i);
btree_set_data(tmp, data_idx, testdata, 10, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
}
btree_dump(tmp);
btree_free(tmp);
return 0;
}
int main(int argc, char *argv[])
{
btree_tree *tmp;
FILE *f;
char urlBuffer[2048], *data;
uint64_t id;
uint64_t i = 0;
uint32_t data_idx;
tmp = btree_create("test.mmap", 128, 700000, 2048);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
f = fopen(argv[1], "r");
while (!feof(f)) {
fgets(urlBuffer, 2048, f);
data = strchr(urlBuffer, ' ');
if (data) {
data++;
data[-1] = '\0';
id = atoll(urlBuffer);
if (btree_insert(tmp, id, &data_idx) == 1) {
btree_set_data(tmp, data_idx, data, strlen(data), time(NULL));
}
}
i++;
}
btree_free(tmp);
return 0;
}
/**
* @brief test case for random number insert, search and delete.
*/
void testcase_for_random() {
TREE* T = btree_create();
int i = 0, n = 100;
int _t = 0;
srand(time(NULL));
for (i = 0; i < n; i ++) {
_t = rand() % n;
printf("btree_insert(T, %d) = %d\n", _t, btree_insert(T, _t));
}
for (i = 0; i < n; i ++) {
_t = rand() % n;
printf("btree_search(T, %d) = %d\n", _t, btree_search(T, _t));
}
printf("btree_traveral: ");
btree_traveral(T, printout_node);
printf("\n");
for (i = 0; i < n; i ++) {
_t = rand() % n;
printf("btree_delete(T, %d) = %d\n", _t, btree_delete(T, _t));
}
printf("btree_traveral: ");
btree_traveral(T, printout_node);
printf("\n");
btree_destory(T);
}
void smbtree_import(BTree* tree, char* url)
{
FILE* file = fopen(url, "r");
char* word_to_insert = calloc(STRING_SIZE, sizeof(char));
while (fscanf(file, "%s", word_to_insert) != EOF)
{
char* word = calloc(STRING_SIZE, sizeof(char));
strcpy(word, word_to_insert);
Vector* vec = vector_newVector();
int i, n_docs = 0;
fscanf(file, "%d", &n_docs);
for (i = 0; i < n_docs; i++)
{
char* doc_url = calloc(STRING_SIZE, sizeof(char));
int n_pos = 0, j;
fscanf(file, "%s%d", doc_url, &n_pos);
VectorNode* vec_node = vector_newVectorNode(doc_url);
for (j = 0; j < n_pos; j++)
{
int pos = 0;
fscanf(file, "%d", &pos);
addPositionVectorNode(vec_node, pos);
}
vector_push(vec, vec_node);
//Check possible bugs
free(doc_url);
}
BTreeKey* key = btree_newBTreeKey(word, vec);
btree_insert(tree, tree->root, key);
}
free(word_to_insert);
fclose(file);
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
size_t *size;
time_t *ts;
char *data;
int i, tmp_key;
char testdata[11];
int error = 0;
/* testing too large data */
tmp = btree_create("test.mmap", 3, 6, 10, &error);
if (!tmp) {
printf("Couldn't create tree from disk image, errno %d.\n", error);
exit(1);
}
for (i = 0; i < 205; i++) {
tmp_key = i * 3;
if (0 == btree_insert(tmp, tmp_key)) {
sprintf(testdata, "H: %07d", i);
btree_set_data(tmp, tmp_key, testdata, 10, time(NULL));
btree_get_data(tmp, tmp_key, &data_idx, (void **)&data, &size, &ts);
printf("%s %zd\n", data, *size);
btree_data_unlock(tmp, data_idx);
}
}
btree_dump(tmp);
btree_close(tmp);
return 0;
}
R_API void btree_add(struct btree_node **T, void *e, BTREE_CMP(cmp)) {
struct btree_node *p = (struct btree_node*)
malloc(sizeof(struct btree_node));
p->data = e;
p->hits = 0;
p->left = p->right = NULL;
if (*T==NULL) *T = p;
else btree_insert (T, p, cmp);
}
void
reset_bmaps(xfs_mount_t *mp)
{
xfs_agnumber_t agno;
xfs_agblock_t ag_size;
int ag_hdr_block;
ag_hdr_block = howmany(4 * mp->m_sb.sb_sectsize, mp->m_sb.sb_blocksize);
ag_size = mp->m_sb.sb_agblocks;
for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
if (agno == mp->m_sb.sb_agcount - 1)
ag_size = (xfs_extlen_t)(mp->m_sb.sb_dblocks -
(xfs_drfsbno_t)mp->m_sb.sb_agblocks * agno);
#ifdef BTREE_STATS
if (btree_find(ag_bmap[agno], 0, NULL)) {
printf("ag_bmap[%d] btree stats:\n", i);
btree_print_stats(ag_bmap[agno], stdout);
}
#endif
/*
* We always insert an item for the first block having a
* given state. So the code below means:
*
* block 0..ag_hdr_block-1: XR_E_INUSE_FS
* ag_hdr_block..ag_size: XR_E_UNKNOWN
* ag_size... XR_E_BAD_STATE
*/
btree_clear(ag_bmap[agno]);
btree_insert(ag_bmap[agno], 0, &states[XR_E_INUSE_FS]);
btree_insert(ag_bmap[agno],
ag_hdr_block, &states[XR_E_UNKNOWN]);
btree_insert(ag_bmap[agno], ag_size, &states[XR_E_BAD_STATE]);
}
if (mp->m_sb.sb_logstart != 0) {
set_bmap_ext(XFS_FSB_TO_AGNO(mp, mp->m_sb.sb_logstart),
XFS_FSB_TO_AGBNO(mp, mp->m_sb.sb_logstart),
mp->m_sb.sb_logblocks, XR_E_INUSE_FS);
}
reset_rt_bmap();
}
Btree btree_insert(String key, String val, Btree t)
{
Btree a = (struct tnode *)malloc(sizeof(struct tnode));
String b = (char *)malloc(50);
String c = (char *)malloc(50);
strcpy(b, key);
strcpy(c, val);
a->key = b;
a->value = c;
a->left = btree_empty();
a->right = btree_empty();
if (btree_isempty(t) == 4){
return a;
}
else if (strcmp(key, t->key) < 0){
if (btree_isempty(t->left)){
t->left = a;
return t;
}
else{
t->left = btree_insert(key, val, t->left);
free(a);
return t;
}
}
else if (strcmp(key, t->key) > 0){
if (btree_isempty(t->right)){
t->right = a;
return t;
}
else{
t->right = btree_insert(key, val, t->right);
free(a);
return t;
}
}
else{
t->key = key;
t->value = val;
free(a);
return t;
}
}
void
h_table_insert( h_table_t *table, char *key, void *data )
{
/* Move the pointer to a new position */
table->curr++;
/* Store the data */
table->data_arr[ table->curr ] = data;
table->tree = btree_insert( table->tree, key, table->curr );
}
/** Enable piece of physical memory for mapping by physmem_map().
*
* @param parea Pointer to physical area structure.
*
*/
void ddi_parea_register(parea_t *parea)
{
mutex_lock(&parea_lock);
/*
* We don't check for overlaps here as the kernel is pretty sane.
*/
btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
mutex_unlock(&parea_lock);
}
static uint32_t insert_item(btree_tree *tmp, uint64_t index) {
uint32_t data_idx;
size_t *size;
time_t *time;
void *data;
btree_insert(tmp, index);
btree_get_data(tmp, index, &data_idx, &data, &size, &time);
printf("%u\n", data_idx);
btree_data_unlock(tmp, data_idx);
return data_idx;
}
BTree *array_to_btree(char **array)
{
BTree *tree;
int i;
tree = NULL;
for(i = 0; array[i] != '\0'; i++)
{
btree_insert(&tree, array[i]);
}
return (tree);
}
int main(void) {
btree_t bt;
btree_node_t *n;
char datatbl[] = {'a', 'b', 'd', 'd', 'a'};
btree_create(&bt);
btree_insert(&bt, btree_node_create(&datatbl[0]));
btree_insert(&bt, btree_node_create(&datatbl[1]));
btree_insert(&bt, btree_node_create(&datatbl[2]));
n = btree_node_create(&datatbl[3]);
btree_insert(&bt, n);
btree_remove(&bt, n, false);
btree_node_release(n);
btree_insert(&bt, btree_node_create(&datatbl[4]));
btree_release(&bt);
printf("Last Error: %s (%d)\r\n",
libnet_str_error(libnet_error_get()), libnet_error_get());
return 0;
}
BTree *array_to_btree(char **array)
{
BTree *tree;
int i;
tree = NULL;
while (array[i])
{
btree_insert(&tree, array[i]);
i++;
}
return (tree);
}
/**
* btree_inc_data
* @access public
* @param btree struct
* @param key
* @return int 0 on success or error value
*
* Increments the data at key
*/
BTREE_API int btree_inc_data(btree_tree *t, uint64_t key)
{
void *location;
int error;
uint32_t idx;
uint64_t value;
size_t data_size = sizeof(uint64_t);
/* already exists? */
if (1 == btree_search_internal(t, t->root, key, &idx)) {
error = btree_data_lockw(t, idx);
if (error != 0) {
return error;
}
location = btree_get_data_location(t, idx);
value = *(uint64_t *) (location + sizeof(size_t) + sizeof(time_t));
value++;
} else {
/* doesn't exist, create */
error = btree_insert(t, key);
if (error != 0) {
return error;
}
if (1 == btree_search_internal(t, t->root, key, &idx)) {
error = btree_data_lockw(t, idx);
if (error != 0) {
return error;
}
} else {
return 404; /* Node not found */
}
error = btree_data_lockw(t, idx);
if (error != 0) {
return error;
}
location = btree_get_data_location(t, idx);
value = *(uint64_t *) (location + sizeof(size_t) + sizeof(time_t));
value = 1;
}
*((size_t*)location) = data_size;
*(time_t*) (location + sizeof(size_t)) = time(NULL);
*(uint64_t *) (location + sizeof(size_t) + sizeof(time_t)) = value;
error = btree_data_unlock(t, idx);
if (error != 0) {
return error;
}
return 0;
}
TEST(BTree, Insert)
{
struct btree_s tree;
btree_init(&tree, 3);
int i;
for (i = 0; i < 10; i++) {
btree_insert(&tree, i);
}
btree_dump(&tree);
btree_destroy(&tree);
}
void updateTree(BTree* tree, char* word, int pos, char* urlDoc)
{
BTreeKey* existingKey = btree_search(tree->root, word);
if (existingKey)
{
addPositionVector(existingKey->mInfo, urlDoc, pos);
free(word);
} else {
Vector* bkey_info = vector_newVector();
addPositionVector(bkey_info, urlDoc, pos);
BTreeKey* bkey = btree_newBTreeKey(word, bkey_info);
btree_insert(tree, tree->root, bkey);
}
}
/**
* btree_insert - Inserts a new leaf in a binary tree. Makes a recursive call
* function based on value.
*
* @tree: Pointer to the binary tree in which to insert a new node
* @data: Pointer to string which will be the key value of the node.
*
* Description: Inserts a leaf into a tree, given a pointer to a pointer to
* a leaf of the tree. If the first pointer points to NULL, the tree is empty
* and a memory space for a new leaf is allocated. The new leaf's key value is
* populated and it's left and right pointers are set to NULL. If the tree is
* not empty, the key value received as argument is compared to the key value
* of the node and btree_insert is run recursively on on the left or right
* pointer of the node for less than, or greater than, respectively.
*/
int btree_insert(BTree **tree, char *data)
{
if (*tree == NULL)
{
*tree = (struct BTree *)malloc(sizeof(struct BTree));
if (tree == NULL)
return 1;
(*tree)->str = strdup(data);
if ((*tree)->str == NULL)
return 1;
(*tree)->left = NULL;
(*tree)->right = NULL;
}
else if ((strcmp(data, (*tree)->str)) < 0)
{
btree_insert(&(*tree)->left, data);
}
else if ((strcmp(data, (*tree)->str)) > 0)
{
btree_insert(&(*tree)->right, data);
}
return 0;
}
/**
* btree_insert - Inserts node in a binary tree
* @tree: pointer to structure
* @data: points to array of elements
*/
int btree_insert(BTree **tree, char *data)
{
if (*tree == NULL)
{
*tree = (BTree *) malloc(sizeof(BTree));
if (tree == NULL)
{
return (1);
}
(*tree)->str = strdup(data);
(*tree)->left = NULL;
(*tree)->right = NULL;
return (0);
}
else if (strcmp(data, (*tree)->str) > 0)
{
btree_insert(&(*tree)->left, data);
}
else if (strcmp(data, (*tree)->str) <= 0)
{
btree_insert(&(*tree)->right, data);
}
return (0);
}
int
add_dup_extent(
xfs_agnumber_t agno,
xfs_agblock_t startblock,
xfs_extlen_t blockcount)
{
int ret;
#ifdef XR_DUP_TRACE
fprintf(stderr, "Adding dup extent - %d/%d %d\n", agno, startblock,
blockcount);
#endif
pthread_mutex_lock(&dup_extent_tree_locks[agno]);
ret = btree_insert(dup_extent_trees[agno], startblock,
(void *)(uintptr_t)(startblock + blockcount));
pthread_mutex_unlock(&dup_extent_tree_locks[agno]);
return ret;
}
/**
* @brief test case for single insert, search and delete method.
*/
void testcase_for_single() {
TREE* T = btree_create();
printf("btree_insert(T, 32) = %d\n", btree_insert(T, 32));
printf("btree_search(T, 32) = %d\n", btree_search(T, 32));
printf("btree_delete(T, 32) = %d\n", btree_delete(T, 32));
printf("btree_search(T, 32) = %d\n", btree_search(T, 32));
printf("btree_traveral: ");
btree_traveral(T, printout_node);
printf("\n");
btree_destory(T);
}
static BI_DATA *
find_elapsed(const char *txt)
{
BI_DATA *result = 0;
char temp[80];
char *s = strchr(mktrimmed(strcpy(temp, txt)), L_PAREN);
if (s != 0)
*s = EOS;
if (*temp != EOS) {
if ((result = btree_search(&elapsed_tree, temp)) == 0) {
BI_DATA data;
memset(&data, 0, sizeof(data));
data.bi_key = temp;
result = btree_insert(&elapsed_tree, &data);
}
}
return result;
}
TEST(BTree, RemoveALot)
{
struct btree_s tree;
btree_init(&tree, 3);
int i;
for (i = 0; i < 1000000; i++) {
btree_insert(&tree, i);
}
for (i = 10; i < 999992; i++) {
btree_remove(&tree, i);
}
btree_dump(&tree);
btree_destroy(&tree);
}
