void uid2grp_cache_init(void)
{
avltree_init(&uname_tree, uname_comparator, 0);
avltree_init(&uid_tree, uid_comparator, 0);
memset(uid_grplist_cache, 0,
id_cache_size * sizeof(struct avltree_node *));
}
void gweakref_destroy(gweakref_table_t *wt)
{
struct avltree_node *node, *onode;
gweakref_partition_t *wp;
gweakref_priv_t *tref;
int ix;
/* quiesce the server, then... */
for (ix = 0; ix < wt->npart; ++ix) {
wp = &wt->partition[ix];
onode = NULL;
node = avltree_first(&wp->t);
do {
if (onode) {
tref = avltree_container_of(onode, gweakref_priv_t, node_k);
gsh_free(tref);
}
} while ((onode = node) && (node = avltree_next(node)));
if (onode) {
tref = avltree_container_of(onode, gweakref_priv_t, node_k);
gsh_free(tref);
}
avltree_init(&wp->t, wk_cmpf, 0 /* must be 0 */);
if (wp->cache)
gsh_free(wp->cache);
}
gsh_free(wt->partition);
gsh_free(wt);
}
/**
* @brief Initialize the package.
*/
void cih_pkginit(void)
{
pthread_rwlockattr_t rwlock_attr;
cih_partition_t *cp;
uint32_t npart;
uint32_t cache_sz = 32767; /* XXX */
int ix;
/* avoid writer starvation */
pthread_rwlockattr_init(&rwlock_attr);
#ifdef GLIBC
pthread_rwlockattr_setkind_np(
&rwlock_attr,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
#endif
npart = nfs_param.cache_param.nparts;
cih_fhcache.npart = npart;
cih_fhcache.partition = gsh_calloc(npart, sizeof(cih_partition_t));
for (ix = 0; ix < npart; ++ix) {
cp = &cih_fhcache.partition[ix];
cp->part_ix = ix;
pthread_rwlock_init(&cp->lock, &rwlock_attr);
avltree_init(&cp->t, cih_fh_cmpf, 0 /* must be 0 */);
cih_fhcache.cache_sz = cache_sz;
cp->cache = gsh_calloc(cache_sz, sizeof(struct avltree_node *));
}
initialized = true;
}
void avltree_clean(struct avltree *tree)
{
struct avltree_node *i;
for (i = avltree_first(tree); i; i = avltree_next(i))
i->tree = NULL;
avltree_init(tree, tree->cmp_fn);
}
/*
* The suite initialization function.
* Initializes resources to be shared across tests.
* Returns zero on success, non-zero otherwise.
*
*/
int init_suite1(void)
{
avltree_init(&avl_tree_1, avl_unit_cmpf, 0 /* flags */);
return 0;
}
void check_min_2(void)
{
avl_unit_val_t *v;
unsigned long mval, rv;
struct avltree_node *node;
int ix;
srand(time(0));
avl_unit_clear_and_destroy_tree(&avl_tree_1);
avltree_init(&avl_tree_1, avl_unit_cmpf, 0 /* flags */);
mval = ULONG_MAX;
for (ix = 0; ix < 100000; ix++) {
rv = rand();
/* in solaris avl, inserting an value that compares equal
* to an already inserted value is illegal */
insert_long_val_safe(&avl_tree_1, rv);
if ((mval < 0) || (rv < mval))
mval = rv;
}
node = avltree_first(&avl_tree_1);
v = avltree_container_of(node, avl_unit_val_t, node_k);
printf("rv: %lu mval: %lu val: %lu\n", rv, mval, v->val - 1);
CU_ASSERT(v->val == (mval + 1));
}
void check_min_1(void)
{
avl_unit_val_t *v;
struct avltree_node *node;
avl_unit_clear_and_destroy_tree(&avl_tree_1);
avltree_init(&avl_tree_1, avl_unit_cmpf, 0 /* flags */);
insert_long_val(&avl_tree_1, 4);
insert_long_val(&avl_tree_1, 10);
insert_long_val(&avl_tree_1, 10010);
insert_long_val(&avl_tree_1, 267);
insert_long_val(&avl_tree_1, 3382);
insert_long_val(&avl_tree_1, 22);
insert_long_val(&avl_tree_1, 82);
node = avltree_first(&avl_tree_1);
v = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v->val == (4 + 1));
/* insert new min */
insert_long_val(&avl_tree_1, 3);
node = avltree_first(&avl_tree_1);
v = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v->val == (3 + 1));
/* delete current min */
delete_long_val(&avl_tree_1, 3);
node = avltree_first(&avl_tree_1);
v = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v->val == (4 + 1));
}
static void
osm_wr_init(const char *fname)
{
fout = gbfopen(fname, "w", MYNAME);
osm_init_icons();
waypoints = avltree_init(0, MYNAME);
node_id = 0;
}
static void
osm_features_init(void)
{
int i;
keys = avltree_init(AVLTREE_STATIC_KEYS, MYNAME);
values = avltree_init(0, MYNAME);
/* the first of osm_features is a place holder */
for (i = 1; osm_features[i]; i++)
avltree_insert(keys, osm_features[i], gb_int2ptr(i));
for (i = 0; osm_icon_mappings[i].value; i++) {
char buff[128];
buff[0] = osm_icon_mappings[i].key;
strncpy(&buff[1], osm_icon_mappings[i].value, sizeof(buff) - 1);
avltree_insert(values, buff, (const void *)&osm_icon_mappings[i]);
}
}
static void
osm_init_icons(void)
{
int i;
if (icons) return;
icons = avltree_init(AVLTREE_STATIC_KEYS, MYNAME);
for (i = 0; osm_icon_mappings[i].value; i++)
avltree_insert(icons, osm_icon_mappings[i].icon, (const void *)&osm_icon_mappings[i]);
}
static void
mmo_rd_init(const char *fname)
{
int i;
fin = gbfopen_le(fname, "rb", MYNAME);
category_ids = avltree_init(0, MYNAME);
objects = avltree_init(0, MYNAME);
icons = avltree_init(0, MYNAME);
ico_object_id = pos_object_id = txt_object_id = cat_object_id = 0;
wpt_object_id = rte_object_id = trk_object_id = 0;
mmo_object_id = 0x8001;
i = 0;
while (mmo_icon_value_table[i].icon) {
mmo_register_icon(mmo_icon_value_table[i].value, mmo_icon_value_table[i].icon);
i++;
}
}
static void
osm_rd_init(const char *fname)
{
wpt = NULL;
rte = NULL;
wpt_loaded = 0;
rte_loaded = 0;
waypoints = avltree_init(0, MYNAME);
if (! keys)
osm_features_init();
xml_init(fname, osm_map, NULL);
}
void check_delete_1(void)
{
struct avltree_node *node;
avl_unit_val_t *v, *v2;
avl_unit_clear_and_destroy_tree(&avl_tree_1);
avltree_init(&avl_tree_1, avl_unit_cmpf, 0 /* flags */);
insert_long_val(&avl_tree_1, 4);
insert_long_val(&avl_tree_1, 1);
insert_long_val(&avl_tree_1, 10010);
insert_long_val(&avl_tree_1, 267);
insert_long_val(&avl_tree_1, 3382);
insert_long_val(&avl_tree_1, 22);
insert_long_val(&avl_tree_1, 82);
insert_long_val(&avl_tree_1, 3);
node = avltree_first(&avl_tree_1);
v2 = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v2->val == (1 + 1));
delete_long_val(&avl_tree_1, 1);
/* new key */
v = avl_unit_new_val(4);
v->key = 4;
node = avltree_lookup(&v->node_k, &avl_tree_1);
v2 = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v2->val == (4 + 1));
delete_long_val(&avl_tree_1, 267);
v->key = 3382;
node = avltree_lookup(&v->node_k, &avl_tree_1);
v2 = avltree_container_of(node, avl_unit_val_t, node_k);
CU_ASSERT(v2->val == (3382 + 1));
avl_unit_free_val(v);
}
struct file_list_s *enterfile(struct file_s *file, linepos_t epoint) {
struct avltree_node *b;
if (!lastfl) {
lastfl = (struct file_list_s *)malloc(sizeof(struct file_list_s));
if (!lastfl) err_msg_out_of_memory();
}
lastfl->file = file;
lastfl->epoint = *epoint;
b = avltree_insert(&lastfl->node, ¤t_file_list->members, file_list_compare);
if (!b) {
lastfl->parent = current_file_list;
avltree_init(&lastfl->members);
current_file_list = lastfl;
lastfl = NULL;
return current_file_list;
}
current_file_list = avltree_container_of(b, struct file_list_s, node);
return current_file_list;
}
static void
humminbird_wr_init(const char *fname)
{
fout = gbfopen_be(fname, "wb", MYNAME);
wptname_sh = mkshort_new_handle();
setshort_length(wptname_sh, WPT_NAME_LEN - 1);
setshort_badchars(wptname_sh, BAD_CHARS);
setshort_mustupper(wptname_sh, 0);
setshort_mustuniq(wptname_sh, 0);
setshort_whitespace_ok(wptname_sh, 1);
setshort_repeating_whitespace_ok(wptname_sh, 1);
setshort_defname(wptname_sh, "WPT");
rtename_sh = mkshort_new_handle();
setshort_length(rtename_sh, RTE_NAME_LEN - 1);
setshort_badchars(rtename_sh, BAD_CHARS);
setshort_mustupper(rtename_sh, 0);
setshort_mustuniq(rtename_sh, 0);
setshort_whitespace_ok(rtename_sh, 1);
setshort_repeating_whitespace_ok(rtename_sh, 1);
setshort_defname(rtename_sh, "Route");
trkname_sh = mkshort_new_handle();
setshort_length(trkname_sh, RTE_NAME_LEN - 1);
setshort_badchars(trkname_sh, BAD_CHARS);
setshort_mustupper(trkname_sh, 0);
setshort_mustuniq(trkname_sh, 0);
setshort_whitespace_ok(trkname_sh, 1);
setshort_repeating_whitespace_ok(trkname_sh, 1);
setshort_defname(trkname_sh, "Track");
waypoints = avltree_init(0, MYNAME);
waypoint_num = 0;
rte_num = 0;
}
gweakref_table_t *gweakref_init(uint32_t npart, uint32_t cache_sz)
{
int ix = 0;
pthread_rwlockattr_t rwlock_attr;
gweakref_partition_t *wp = NULL;
gweakref_table_t *wt = NULL;
wt = gsh_calloc(1, sizeof(gweakref_table_t));
if (!wt)
goto out;
/* prior versions of Linux tirpc are subject to default prefer-reader
* behavior (so have potential for writer starvation) */
pthread_rwlockattr_init(&rwlock_attr);
#ifdef GLIBC
pthread_rwlockattr_setkind_np(
&rwlock_attr,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
#endif
/* npart should be a small integer */
wt->npart = npart;
wt->partition = gsh_calloc(npart, sizeof(gweakref_partition_t));
for (ix = 0; ix < npart; ++ix) {
wp = &wt->partition[ix];
pthread_rwlock_init(&wp->lock, &rwlock_attr);
avltree_init(&wp->t, wk_cmpf, 0 /* must be 0 */);
if (cache_sz > 0) {
wt->cache_sz = cache_sz;
wp->cache = gsh_calloc(cache_sz, sizeof(struct avltree_node *));
}
wp->genctr = 0;
}
out:
return (wt);
}
void deletes_tree_1(void)
{
avl_unit_clear_tree(&avl_tree_1);
avltree_init(&avl_tree_1, avl_unit_hk_cmpf, 0 /* flags */);
}
static void
humminbird_rd_init(const char *fname)
{
fin = gbfopen_be(fname, "rb", MYNAME);
waypoints = avltree_init(0, MYNAME);
}
/*
* The suite initialization function.
* Initializes resources to be shared across tests.
* Returns zero on success, non-zero otherwise.
*
*/
int init_supremum(void)
{
avltree_init(&avl_tree_2, avl_unit_cmpf, 0 /* flags */);
return 0;
}
