コード例 #1
0
/*TODO test this function*/
char *btree_find(BTree *tree, char *str)
{
  int diff = strcmp(tree->str, str);
  if (diff > 0) {
    if (tree->left == NULL) return NULL;
    return btree_find(tree->left, str);
  } else if (diff < 0) {
    if (tree->right == NULL) return NULL;
    return btree_find(tree->right, str);
  } else {
    return tree->str;
  }
  return NULL;
}
コード例 #2
0
int test_insert() {
  BTree *tree;
  BTree *find;
  int depth; 
  tree = NULL;
  
  printf("The numbers should be in ascending order.\n");
  
  btree_insert(&tree, "5");
  btree_insert(&tree, "1");
  btree_insert(&tree, "6");
  btree_insert(&tree, "9");
  btree_insert(&tree, "0");
  btree_insert(&tree, "4");
  btree_insert(&tree, "3");
  btree_insert(&tree, "8");
  btree_insert(&tree, "2");
  btree_insert(&tree, "7");
  btree_insert(&tree, "4");

  /*print_preorder(tree);*/
  printLevelOrder(tree,5);
  depth  = btree_depth(tree);
  printf("d_single:%d\n", depth);
  find = btree_find(tree, "Z");
  /*print_preorder(find);*/
  if(find == NULL){
    printf("Not found.\n");
  }else{
    printLevelOrder(find,5);
  }
  btree_free(tree);
  return 0;
}
コード例 #3
0
ファイル: incore.c プロジェクト: Claruarius/stblinux-2.6.37
int
get_bmap_ext(
	xfs_agnumber_t		agno,
	xfs_agblock_t		agbno,
	xfs_agblock_t		maxbno,
	xfs_extlen_t		*blen)
{
	int			*statep;
	unsigned long		key;

	statep = btree_find(ag_bmap[agno], agbno, &key);
	if (!statep)
		return -1;

	if (key == agbno) {
		if (blen) {
			if (!btree_peek_next(ag_bmap[agno], &key))
				return -1;
			*blen = MIN(maxbno, key) - agbno;
		}
		return *statep;
	}

	statep = btree_peek_prev(ag_bmap[agno], NULL);
	if (!statep)
		return -1;
	if (blen)
		*blen = MIN(maxbno, key) - agbno;

	return *statep;
}
コード例 #4
0
ファイル: pdb.c プロジェクト: BackupTheBerlios/bonephone
int
pdb_item_create(pdb_t *p, uint16_t freq, uint32_t id)
{
    pdb_entry_t *item;
    timestamp_t         zero_ts;

    if (btree_find(p->db, id, (void**)&item)) {
        debug_msg("Item already exists\n");
        return FALSE;
    }

    item = (pdb_entry_t*)xmalloc(sizeof(pdb_entry_t));
    if (item == NULL) {
        return FALSE;
    }

    /* Initialize elements of item here as necesary **********************/

    item->magic           = 0xc001babe;
    item->ssrc            = id;
    item->render_3D_data  = NULL;
    item->enc             = -1;
    item->enc_fmt_len     = 2 * (CODEC_LONG_NAME_LEN + 1);
    item->enc_fmt         = xmalloc(item->enc_fmt_len);
    item->sample_rate     = freq;
    item->gain            = 1.0;
    item->mute            = 0;
    zero_ts               = ts_map32(8000, 0);
    item->last_ui_update  = zero_ts;
    item->first_mix       = TRUE;

    /* Initial jitter estimate (30ms)                                    */
    item->jitter            = ts_map32(8000, 240);
    item->transit           = zero_ts;
    item->last_transit      = zero_ts;
    item->last_last_transit = zero_ts;
    item->avg_transit       = zero_ts;
    item->playout           = zero_ts;
    item->last_arr          = zero_ts;
    item->last_rtt          = 0.0;
    item->avg_rtt           = 0.0;
    /* Packet stats initialization                                       */
    item->received        = 0;
    item->duplicates      = 0;
    item->misordered      = 0;
    item->jit_toged       = 0;
    item->spike_toged     = 0;
    item->spike_events    = 0;

    pdb_item_validate(item);
    /*********************************************************************/

    if (btree_add(p->db, id, (void*)item) == FALSE) {
        debug_msg("failed to add item to persistent database!\n");
        return FALSE;
    }

    p->nelem++;
    return TRUE;
}
コード例 #5
0
int main() {
  BTree *tree;
  BTree *find;
  int depth;
  char *array[11];
  
  array[0] = "5";
  array[1] = "1";
  array[2] = "6";
  array[3] = "9";
  array[4] = "0";
  array[5] = "4";
  array[6] = "3";
  array[7] = "8";
  array[8] = "2";
  array[9] = "7";
  array[10] = "4";
  
  tree = array_to_btree(array);
  /*print_preorder(tree);*/
  printLevelOrder(tree,5);
  depth  = btree_depth(tree);
  printf("d_array:%d\n", depth);
  find = btree_find(tree, "A");
  /*print_preorder(find);*/
  if(find == NULL){
    printf("Not found.\n");
  }else{
    printLevelOrder(find,5);
  }
  btree_free(tree);
  test_insert();
  return 0;
}
コード例 #6
0
ファイル: core.c プロジェクト: jakobwesthoff/lucie
static int L_readini( lua_State* L ) 
{
    const char* filename;
    inifile_t* inifile            = NULL;
    inireader_iterator_t* iter    = NULL;
    inireader_entry_t* current    = NULL;
    btree_element_t* root         = NULL;
    btree_element_t* groupelement = NULL;
    btree_element_t* grouproot    = NULL;

    PARAM_STRING( filename );

    if ( ( inifile = inireader_open( filename ) ) == NULL ) 
    {
        return_error();
    }

    // Add every entry into a btree to get the arrays and groups in one piece later
    DEBUGLOG( "Creating btree" );
    root = btree_create();
    iter = inireader_get_iterator( inifile, 0, 0, 0, 0 );
    DEBUGLOG( "Filling up btree" );
    for ( current = inireader_iterate( iter ); current != NULL; current = inireader_iterate( iter ) )         
    {
        DEBUGLOG( "Searching for or adding group: %s", current->group );
        // Find group element
        groupelement = btree_find( root, current->group );        
        if ( groupelement == NULL ) 
        {
            // A new grouproot needs to be created
            DEBUGLOG( "Creating new grouproot" );
            grouproot = btree_create();
            btree_add( &root, current->group, grouproot );
        }
        else 
        {
            // Retrieve the already added grouproot
            DEBUGLOG( "Setting grouproot" );
            grouproot = ( btree_element_t* )groupelement->data;
        }

        // Add the new element to the grouptree
        btree_add( &grouproot, current->identifier, current );
    }
    
    // Traverse the tree and put our inivalues onto the lua stack
    DEBUGLOG( "Creating initial lua table" );
    lua_newtable( L );    
    readini_tree_traverse( L, root );
    DEBUGLOG( "Freeing the btree data" );
    // Free the group trees
    readini_tree_free( root );
    // Free the main tree
    btree_free( root );
    // Close the inifile
    inireader_close( inifile );
    
    return 1;
}
コード例 #7
0
ファイル: uid2s.c プロジェクト: ThomasDickey/td_lib-snapshots
char *
uid2s(uid_t user)
{
    static UID_DATA data;
    data.user = user;
    memcpy((char *) &data, (char *) btree_find(&uid2s_tree, &data), sizeof(UID_DATA));
    return data.name;
}
コード例 #8
0
/**
 * btree_find - Given a string, finds the leaf in a binary tree which has that
 * same string as it's key value
 *
 * @tree: Pointer to the root leaf of binary tree
 * @str:  The string to be search for in the binary tree
 *
 * Description:  Uses strcmp to compare passed to string to the key value in a
 * leaf and then recursively runs the function on the left- or right-pointed
 * leaf until a match is found.
 */
BTree *btree_find(BTree *tree, char *str)
{
	if (tree != NULL)
	{
		if (strcmp(str, tree->str) == 0)
		{
			return tree;
		}
		else if (strcmp(str, tree->str) < 0)
		{
			return btree_find(tree->left, str);
		}
		else
		{
			return btree_find(tree->right, str);
		}
	}
	else
	{
		return NULL;
	}
}
コード例 #9
0
ファイル: pdb.c プロジェクト: uclmediatools/rat
int
pdb_item_get(pdb_t *p, uint32_t id, pdb_entry_t **item)
{
        void *v;
        if (btree_find(p->db, id, &v) == FALSE) {
                *item = NULL;
                return FALSE;
        }
        assert(v != NULL);
        *item = (pdb_entry_t*)v;
	pdb_item_validate(*item);
        return TRUE;
}
コード例 #10
0
ファイル: incore.c プロジェクト: Claruarius/stblinux-2.6.37
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();
}
コード例 #11
0
// Perform timed batch queries in random order
char *test_perf_query_rand()
{
	srand(time(NULL));

	clock_t start = clock(), diff;
	struct bt_cur cur;
	for (int i=0; i<n; i++) {
		int item = rand();
		cur = btree_find(s, root, item);
	}
	diff = clock() - start;
	int msec = diff * 1000 / CLOCKS_PER_SEC;
	double ops = n * 1000;
	ops /= msec;
	printf("Time to query %u items: %u ms\n", n, msec);
	printf("Time per operation: %u us\n", (1000*msec)/n);
	printf("Operations per second: %f\n", ops);

	return NULL;
}
コード例 #12
0
ファイル: draw_tree.c プロジェクト: dmitru/red-black-tree
int main(int argc, char **argv)
{
  BTree *tree = btree_create(int_compare);
  int n = atoi(argv[1]);
  int a[n];
  //int a[] = {1, 3, 2, 5, -1, 19, 15, 45, 9, 6, -4};
  n = sizeof(a) / sizeof(a[0]);
  //n = 3;
  for (int i = 0; i < n; ++i) {
    //a[i] = i + 1;
    a[i] = rand() % 1000;
    btree_insert(tree, (void*)&a[i]);
  }
  for (int i = 0; i < n / 2; ++i) {
    btree_remove(btree_find(tree, &a[i]));
  }
  int expected_height = 2 * ceil(log(n + 1) / log(2)) + 1;
  btree_dump_dot(tree, node_attrs);
  btree_destroy(tree);
}
コード例 #13
0
ファイル: incore_ext.c プロジェクト: chandanr/xfsprogs-dev
int
search_dup_extent(
	xfs_agnumber_t		agno,
	xfs_agblock_t		start_agbno,
	xfs_agblock_t		end_agbno)
{
	unsigned long	bno;
	int		ret;

	pthread_mutex_lock(&dup_extent_tree_locks[agno]);
	if (!btree_find(dup_extent_trees[agno], start_agbno, &bno)) {
		ret = 0;
		goto out;	/* this really shouldn't happen */
	}
	if (bno < end_agbno) {
		ret = 1;
		goto out;
	}
	ret = (uintptr_t)btree_peek_prev(dup_extent_trees[agno], NULL) >
								start_agbno;
out:
	pthread_mutex_unlock(&dup_extent_tree_locks[agno]);
	return ret;
}
コード例 #14
0
ファイル: main.c プロジェクト: falcaopetri/B-Tree
int running_screen() {
	int n_items = 5;
	// Itens no menu
	char list[5][15] = { "Inserir", "Pesquisar", "Remover", "Imprimir DFS", "Voltar" };
	int opt;

	print_header();

	int i;
	for (i = 0; i < n_items; ++i) {
		printf(" %d) %s\n", i+1, list[i]);
	}

	printf("\n");
	printf(" Digite uma opção: ");
	scanf("%d%*c", &opt);

	int key;
	node_position pos;
	switch (opt) {
	case 1:                 // Inserir
		if (n_keys == max_keys) {
			snprintf(msg, MSG_LEN, " O máximo de chaves adicionáveis para essa demo é %d.", max_keys);
		}
		else {
			printf(" Digite uma CHAVE que será associada ao VALOR \'%s\': ", values[n_keys]);
			scanf("%d", &key);
			pos = btree_insert(tree, key, values[n_keys]);
			if (pos.node == NULL) {
				snprintf(msg, MSG_LEN, " Inserção falhou. A CHAVE %d já existe na B-Tree.", key);
			}
			else {
				snprintf(msg, MSG_LEN, " Inserção da CHAVE %d associada ao VALOR \'%s\' realizada com sucesso.",
				         key, values[n_keys]);
				n_keys++;
			}
		}
		break;
	case 2:                 // Pesquisar
		printf(" Digite uma CHAVE para pesquisar: ");
		scanf("%d", &key);
		pos = btree_find(tree, key);
		if (pos.node == NULL) {
			snprintf(msg, MSG_LEN, " A CHAVE %d não foi encontrada na B-Tree.", key);
		}
		else {
			snprintf(msg, MSG_LEN, " A CHAVE %d foi encontrada associada ao VALOR \'%s\'.",
			         key, (char*) pos.node->keys[pos.index]->value);
		}

		break;
	case 3:                 // Remover
		printf(" Digite uma CHAVE para remover: ");
		scanf("%d", &key);
		pos = btree_remove(tree, key);
		if (pos.node == NULL) {
			snprintf(msg, MSG_LEN, " A CHAVE %d não foi encontrada na B-Tree.", key);
		}
		else {
			snprintf(msg, MSG_LEN, " A CHAVE %d foi removida com sucesso.", key);
		}
		break;
	case 4:                 // Imprimir
		printf(" Executando uma DFS na B-Tree:\n");
		btree_dfs(tree);
		printf(" Pressione ENTER para continuar. ");
		getchar();
		break;
	case 5:                 // Voltar/Sair
		snprintf(msg, MSG_LEN, " Deletando B-Tree e voltando ao menu");
		goodbye();
		// Única deleção de uma B-Tree
		btree_delete_h(tree);
		return HOME;
		break;
	default:
		snprintf(msg, MSG_LEN, " Opção inválida");
		return RUNNING;
		break;
	}

	return RUNNING;
}
コード例 #15
0
ファイル: treebench.c プロジェクト: Acovea/libacovea
int main(int argc, char ** argv)
{
    int i;
    
    // do we have verbose output?
    bool ga_testing = false;
    
    if (argc > 1)
    {
        for (i = 1; i < argc; ++i)
        {
            if (!strcmp(argv[1],"-ga"))
            {
                ga_testing = true;
                break;
            }
        }
    }
    
    // initialize
    btree * tree = create_btree(16);
    
    bool flags[MAX_KEY];
    
    for (i = 0; i < MAX_KEY; ++i)
        flags[i] = false;
    
    // get starting time    
    struct timespec start, stop;
    clock_gettime(CLOCK_REALTIME,&start);

    // what we're timing
    for (int n = 0; n < TEST_SIZE; ++n)
    {
        // pick a key
        btree_key_t key = random_key(MAX_KEY);
        
        // is the key in the tree?
        btree_data_t data = btree_find(tree,key);
        
        if (data == NULL_DATA)
        {
            btree_insert(tree,key,(btree_data_t)key);
            flags[key] = true;
        }
        else
        {
            btree_remove(tree,key);
            flags[key] = false;
        }
    }
    
    // calculate run time
    clock_gettime(CLOCK_REALTIME,&stop);        
    double run_time = (stop.tv_sec - start.tv_sec) + (double)(stop.tv_nsec - start.tv_nsec) / 1000000000.0;
    
#if defined(VERIFY)
    // verify
    for (btree_key_t k = 0; k < MAX_KEY; ++k)
    {
        if (NULL_DATA == btree_find(tree,k))
        {
            if (flags[k])
                fprintf(stderr,"VERIFICATION ERROR: %l found, and shouldn't have been\n",k);
        }
        else
        {
            if (!flags[k])
                fprintf(stderr,"VERIFICATION ERROR: %l not found, and should have been\n",k);
        }
    }
#endif
    
    // clean up
    free_btree(tree);

    // report runtime
    if (ga_testing)
        fprintf(stdout,"%f",run_time);
    else        
        fprintf(stdout,"\ntreebench (Std. C) run time: %f\n\n",run_time);
    
    fflush(stdout);
    
    // done
    return 0;
}
コード例 #16
0
ファイル: incore.c プロジェクト: Claruarius/stblinux-2.6.37
static void
update_bmap(
	struct btree_root	*bmap,
	unsigned long		offset,
	xfs_extlen_t		blen,
	void			*new_state)
{
	unsigned long		end = offset + blen;
	int			*cur_state;
	unsigned long		cur_key;
	int			*next_state;
	unsigned long		next_key;
	int			*prev_state;

	cur_state = btree_find(bmap, offset, &cur_key);
	if (!cur_state)
		return;

	if (offset == cur_key) {
		/* if the start is the same as the "item" extent */
		if (cur_state == new_state)
			return;

		/*
		 * Note: this may be NULL if we are updating the map for
		 * the superblock.
		 */
		prev_state = btree_peek_prev(bmap, NULL);

		next_state = btree_peek_next(bmap, &next_key);
		if (next_key > end) {
			/* different end */
			if (new_state == prev_state) {
				/* #1: prev has same state, move offset up */
				btree_update_key(bmap, offset, end);
				return;
			}

			/* #4: insert new extent after, update current value */
			btree_update_value(bmap, offset, new_state);
			btree_insert(bmap, end, cur_state);
			return;
		}

		/* same end (and same start) */
		if (new_state == next_state) {
			/* next has same state */
			if (new_state == prev_state) {
				/* #3: merge prev & next */
				btree_delete(bmap, offset);
				btree_delete(bmap, end);
				return;
			}

			/* #8: merge next */
			btree_update_value(bmap, offset, new_state);
			btree_delete(bmap, end);
			return;
		}

		/* same start, same end, next has different state */
		if (new_state == prev_state) {
			/* #5: prev has same state */
			btree_delete(bmap, offset);
			return;
		}

		/* #6: update value only */
		btree_update_value(bmap, offset, new_state);
		return;
	}

	/* different start, offset is in the middle of "cur" */
	prev_state = btree_peek_prev(bmap, NULL);
	ASSERT(prev_state != NULL);
	if (prev_state == new_state)
		return;

	if (end == cur_key) {
		/* end is at the same point as the current extent */
		if (new_state == cur_state) {
			/* #7: move next extent down */
			btree_update_key(bmap, end, offset);
			return;
		}

		/* #9: different start, same end, add new extent */
		btree_insert(bmap, offset, new_state);
		return;
	}

	/* #2: insert an extent into the middle of another extent */
	btree_insert(bmap, offset, new_state);
	btree_insert(bmap, end, prev_state);
}
コード例 #17
0
ファイル: sbtree_ui.c プロジェクト: chinaktv/fastmerge
static int btree_ui_find(struct btree_info *ui, const char *key)
{
	return btree_find(ui->tree, key);
}
コード例 #18
0
ファイル: main_bstree.c プロジェクト: yannikab/algorithms
int main_bstree(int argc, char** argv)
{
    bool ok = true;

    /* Load forums from file into list. */

    list_t *list_p = NULL;

    if (ok)
        ok = (list_p = list_init()) != NULL;

    if (ok)
    {
        printf("-> Loading forum.csv...\n");
        ok = load_file("forum" ".csv", list_p);
    }

    printf("Forums: %d\n", list_size(list_p));

    /* Timing variables. */

    double t1, t2, real_time;
    struct tms tb;
    double tickspersec = (double) sysconf(_SC_CLK_TCK);

    /* Lookup a specific forum in the list for some iterations. */

    t1 = (double) times(&tb);

    unsigned int iter1, m;

    iter1 = 4 * 0;

    for (m = 0; m < iter1; m++)
    {
        unsigned int i, size;

        char *forum_name = "Wall of Eric Wilby";

        size = list_size(list_p);

        for (i = 0; i < size; i++)
        {
            forum_t *forum_p = NULL;
            list_get(list_p, (void **) &forum_p, i);
            if (!strcmp(forum_get_title(forum_p), forum_name))
            {
                //                printf("%s\n", forum_get_title(forum_p));
                break;
            }
        }
    }

    t2 = (double) times(&tb);
    real_time = (double) (t2 - t1) / tickspersec;
    printf("Completed %u list lookups in %.3f sec\n", m, real_time);

    /* Load all forums in list to binary search tree. */

    btree_t *btree_p = btree_init(forum_dstr, forum_cmp);
    if (btree_p == NULL)
        return (EXIT_FAILURE);

    unsigned int i, size;

    size = list_size(list_p);

    for (i = 0; i < size; i++)
    {
        forum_t *f_p = NULL;
        list_get(list_p, (void **) &f_p, i);
        btree_ins(btree_p, f_p);
    }
    
    printf("Loaded %u forums.\n", btree_size(btree_p));

    /* Print forums in alphabetical order, exec print function with INORDER mode. */

    unsigned int limit = 1500;
    bool ret = btree_exec(btree_p, INORDER, forum_print, &limit);
    printf("%u\n", ret);

    /* Perform lookups in binary search tree */

    forum_t *forum_p = forum_init(0, "Wall of Eric Wilby", 0);

    t1 = (double) times(&tb);

    unsigned int n, iter2;

    iter2 = 667;

    for (n = 0; n < iter2; n++)
    {
        btree_node_t *btree_node_p = btree_find(btree_p, forum_p);
        if (btree_node_p != NULL)
        {
            forum_t *f_p = (forum_t *) btree_node_get_data(btree_node_p);
            forum_get_title(f_p);
            // printf("%s\n", forum_get_title(f_p));
        }
    }

    t2 = (double) times(&tb);
    real_time = (double) (t2 - t1) / tickspersec;
    printf("Completed %u bstree lookups in %.3f sec\n", n, real_time);

    /* Free all memory */

    forum_destroy(&forum_p);
    btree_destroy(&btree_p); // btree destroys forums, which are also on the list

    //    size = list_size(list_p);
    //
    //    for (i = 0; i < size; i++)
    //    {
    //        forum_t *f_p = NULL;
    //        list_get(list_p, (void **) &f_p, i);
    //        forum_destroy(&f_p);
    //    }

    list_destroy(&list_p);

    return (EXIT_SUCCESS);
}
コード例 #19
0
ファイル: searchcache.c プロジェクト: xiangbai/HITS
void setcache(char *folder, char *searchstring, url_llist *urls)
{
	long i, j;
	urlinfo *url;
	indexed_url *iurl;
	url_node *node = urls->front;
	btree indexed_urls;
	btree_init(&indexed_urls, (void *)indexed_urlcompare);
	
	// loop 1: index urls
	for (i = 0; i < urls->size; i++)
	{
		indexed_url *iurl = malloc(sizeof(indexed_url));
		iurl->url = node->url;
		iurl->index = i;

		btree_insert(&indexed_urls, iurl);
				
		node = node->next;
	}

	// open file for write
	char *modifiedsearch = tounderline(searchstring);
	char *path = getpath(folder, modifiedsearch);
	
	FILE *file = fopen(path, "w");
	
	// write number of links
	fprintf(file, "%d\n", urls->size);

	// loop 2: write data
	node = urls->front;
	indexed_url urltofind;
	for (i = 0; i < urls->size; i++)
	{
		url = node->url;
		
		/*
		 * Write url data
		 * format:	index url numlinks
		 *		link1 link2 link3
		 */
		// write header
		char *urlstring = url_tostring(url);
		fprintf(file, "%s %d\n", urlstring, url->outlinks.size);
		free(urlstring);
		// write links
		lnode *outlink_node = url->outlinks.front;
		for (j = 0; j < url->outlinks.size; j++)
		{	
			// find indexed url so its index can be recorded
			urltofind.url = outlink_node->data;
			indexed_url *iurl = btree_find(&indexed_urls, &urltofind);
			
			// write it, followed by a space
			fprintf(file, "%lu ", iurl->index);
			outlink_node = outlink_node->next;
		}
		if (url->outlinks.size)
			fprintf(file, "\n");
		node = node->next;
	}

	btree_free(&indexed_urls, 1);
	free(modifiedsearch);
	free(path);
	close(file);
}
コード例 #20
0
ファイル: btree_example.c プロジェクト: Jarvishappy/otree
int main(int argc, char **argv) {
    struct btree *bt;
    uint64_t ptr;
    int j, count, op, arg;

    if (argc != 4) {
        fprintf(stderr,"Usage: btree_example <op> <size/ptr> <count>\n");
        exit(1);
    }
    count = atoi(argv[3]);
    arg = atoi(argv[2]);
    if (!strcasecmp(argv[1],"alloc")) {
        op = OP_ALLOC;
    } else if (!strcasecmp(argv[1],"free")) {
        op = OP_FREE;
    } else if (!strcasecmp(argv[1],"allocfree")) {
        op = OP_ALLOCFREE;
    } else if (!strcasecmp(argv[1],"add")) {
        op = OP_ADD;
    } else if (!strcasecmp(argv[1],"walk")) {
        op = OP_WALK;
    } else if (!strcasecmp(argv[1],"fill")) {
        op = OP_FILL;
    } else if (!strcasecmp(argv[1],"find")) {
        op = OP_FIND;
    } else {
        printf("not supported op %s\n", argv[1]);
        exit(1);
    }

    bt = btree_open(NULL, "./btree.db", BTREE_CREAT);
    btree_clear_flags(bt,BTREE_FLAG_USE_WRITE_BARRIER);
    if (bt == NULL) {
        perror("btree_open");
        exit(1);
    }
   
    for (j = 0; j < count; j++) {
        if (op == OP_ALLOC) {
            ptr = btree_alloc(bt,arg);
            printf("PTR: %llu\n", ptr);
        } else if (op == OP_FREE) {
            btree_free(bt,arg);
        } else if (op == OP_ALLOCFREE) {
            ptr = btree_alloc(bt,arg);
            printf("PTR: %llu\n", ptr);
            btree_free(bt,ptr);
        }
    }

    if (op == OP_ADD) {
        int retval;
        char key[16];
        memset(key,0,16);
        strcpy(key,argv[2]);

        retval = btree_add(bt,(unsigned char*)key,
            (unsigned char*)argv[3],strlen(argv[3]),1);
        printf("retval %d\n", retval);
        if (retval == -1) {
            printf("Error: %s\n", strerror(errno));
        }
    } else if (op == OP_WALK) {
        btree_walk(bt,bt->rootptr);
    } else if (op == OP_FILL) {
        for (j = 0; j < count; j++) {
            int r = random()%arg;
            int retval;
            char key[64];
            char val[64];

            memset(key,0,64);
            snprintf(key,64,"k%d",r);
            snprintf(val,64,"val:%d",r);
            retval = btree_add(bt,(unsigned char*)key,
                            (unsigned char*)val, strlen(val), 1);
            if (retval == -1) {
                printf("Error: %s\n", strerror(errno));
                goto err;
            }
        }
    } else if (op == OP_FIND) {
        int retval;
        char key[16], *data;
        memset(key,0,16);
        strcpy(key,argv[2]);
        uint64_t voff;
        uint32_t datalen;

        retval = btree_find(bt,(unsigned char*)key,&voff);
        if (retval == -1) {
            if (errno == ENOENT) {
                printf("Key not found\n");
                exit(0);
            } else {
                perror("Error searching for key");
                exit(1);
            }
        }
        printf("Key found at %llu\n", voff);

        btree_alloc_size(bt,&datalen,voff);
        data = malloc(datalen+1);
        btree_pread(bt,(unsigned char*)data,datalen,voff);
        data[datalen] = '\0';
        printf("Value: %s\n", data);
        free(data);
    }
    btree_close(bt);
    return 0;

err:
    btree_close(bt);
    return 1;
}
コード例 #21
0
/*!----------------------------------------------------------------------------

    s m _ m a l l o c

    @brief Allocate a chunk of shared memory for a user.

    This function will allocate a chunk of shared memory of the specified size
    (in bytes).  If no memory is available of the specified size, a NULL
    pointer will be returned, otherwise, the address (not the offset) of the
    allocated chunk will be returned to the caller.

    This function operates identically to the system "malloc" function and can
    be used the same way.

    @param[in] size - The size in bytes of the memory desired.

    @return The address of the allocated memory chunk.
            NULL if the request could not be honored.

-----------------------------------------------------------------------------*/
void* sm_malloc ( size_t size )
{
#ifdef VSI_DEBUG
    LOG ( "In sm_malloc[%lu]\n", size );

    //dumpSM();
#endif

    memoryChunk_t  needed = { 0 };
    memoryChunk_t* found;
    memoryChunk_t* availableChunk;
    unsigned long  neededSize;
    int            status;

    //
    //  Initialize the size of the memory we need.  Note that we need enough
    //  space to insert the chunkHeader_t at the beginning of the block the
    //  user wants.
    //
    neededSize = size + CHUNK_HEADER_SIZE;

    //
    //  Make sure the memory we are going to allocate is a multiple of 8 bytes
    //  by rounding it up to the next multiple of 8.  Note that since we start
    //  with a properly aligned block of memory, all of the allocated blocks
    //  will also be properly aligned as long as we make sure they are all a
    //  multiple of 8 bytes.
    //
    //  TODO: Do we need to generalize this?  (like using "sizeof(long)", etc.
    //
    neededSize = ( neededSize + 7 ) & 0xfffffffffffffff8;

    //
    //  If the shared memory memory management system has not yet been
    //  initialized, just grab what we need from the beginning of the shared
    //  memory segment.
    //
    if ( ! sysControl->systemInitialized )
    {
        printf ( "Error: sm_malloc called before init finished for size: [%zu]\n",
                 size );
        exit ( 255 );
    }
    //
    //  If we got here we are operating in "normal" mode rather than
    //  "infrastructure initialization" mode.
    //
    //  Lock the mutex that controls the shared memory manager.
    //
    SM_LOCK;

    //
    //  Set up the data structure that we need to search for the appropriately
    //  sized chunk of memory.
    //
    needed.segmentSize = neededSize;
    needed.offset      = 0;

    //
    //  Go find the first block in the available B-tree that is equal to or
    //  greater than the size we need.
    //
    btree_iter iter = btree_find ( &sysControl->availableMemoryBySize, &needed );

    //
    //  If the search didn't find anything then we don't have any memory
    //  chunks large enough to fulfill the request so there is something
    //  seriously wrong and we should just abort for the time being.
    //
    //  TODO: In the future we should be able to extend the shared memory
    //  segment with little overhead.
    //
    if ( btree_iter_at_end ( iter ) )
    {
        printf ( "Error: No memory block of size %zu is available! Aborting\n",
                 size );
        goto mallocEnd;
    }
    //
    //  Get the address of the chunk of memory that we found.
    //
    found = availableChunk = btree_iter_data ( iter );

    //
    //  Go remove the chunk of memory we found from the indices.
    //
    (void)deleteMemoryChunk ( found );

    //
    //  If the memory chunk we found is much larger than what we asked for
    //  then we will need to split the chunk into 2 pieces.  The split
    //  threashold is here to keep us from splitting off a piece of memory
    //  that is so small that it's not useful.  Anything less than the split
    //  threshold will just be left as a single block with some unused space
    //  at the end to cut down on memory fragmentation.
    //
    if ( found->segmentSize - neededSize > SPLIT_THRESHOLD )
    {
        //
        //  Remove the size of the memory chunk we need from the beginning of
        //  what was found and put the remainder back into the "available"
        //  B-tree.
        //
        //  Increment our pointer to the beginning of the leftover memoryChunk
        //  header structure location.
        //
        found = (void*)found + neededSize;

        //
        //  Populate the new header with all the new information for the
        //  leftover piece of memory.
        //
        found->marker      = SM_FREE_MARKER;
        found->offset      = availableChunk->offset + neededSize;
        found->segmentSize = availableChunk->segmentSize - neededSize;
        found->type        = TYPE_SYSTEM;

        //
        //  Go insert the leftover piece of memory back into the indices.
        //
        (void)insertMemoryChunk ( found );

        //
        //  Fix the fields of the initial piece that we split off to be correct
        //  now.
        //
        availableChunk->marker      = SM_IN_USE_MARKER;
        availableChunk->segmentSize = neededSize;
    }
    //
    //  If there is no need to split the piece that we found, just mark it as
    //  "in use".
    //
    else
    {
        availableChunk->marker = SM_IN_USE_MARKER;
    }

mallocEnd:

    //
    //  Go clean up all of the iterator data and memory.
    //
    btree_iter_cleanup ( iter );

    //
    //  Go unlock our shared memory mutex.
    //
    SM_UNLOCK;

#ifdef VSI_DEBUG
    //
    //  Return the address of the user data part of the available memory chunk
    //  to the caller.
    //
    LOG ( "  sm_malloc returning[%p]\n", &availableChunk->data );

    //
    //  Perform a sanity check on this chunk of memory by checking to make
    //  sure it is not past the end of the shared memory segment.
    //
    //  TODO: Check for greater than start of SM also!
    //
    if ( (void*)&availableChunk->data >=
         (void*)sysControl + sysControl->sharedMemorySegmentSize )
    {
        printf ( "\n\nERROR!!! sm_malloc retuning a bad address!!\n\n" );
        printf ( "    %lu past end of shared memory segment!\n",
                 (void*)&availableChunk->data -
                 (void*)sysControl->sharedMemorySegmentSize );
    }
#endif
    //
    //  Return the address of the shared memory chunk just allocated to the
    //  caller.
    //
    return &availableChunk->data;
}
コード例 #22
0
ファイル: namei.c プロジェクト: qpig/sfs
int find_file_in_dir( char *name, int dev, int dir_inode_nr )
{
	struct m_inode *inode = get_inode( dev, dir_inode_nr );
	return btree_find( inode, name );
}