void avl_tree_test_delete ( void ) {
AVLTree * t = init_avl_tree(sizeof(IntBucket), &bucket_int_compare);
BTNode * median_node;
IntBucket x;
IntBucket ib[] = {
{30272}, {16274}, {11768}, {10231}, {28474}, { 7272}, {15032}, {13196}, {29825}, { 6840},
{18444}, {18793}, {13786}, {21125}, {25311}, {23414}, {18374}, {24110}, {15465}, {26300},
{ 1181}, { 6297}, { 3693}, {20957}, {22585}, { 8915}, {30371}, { 2036}, {18499}, {18391},
{15360}, {32509}, {23336}, {18848}, {25712}, { 6162}, { 1483}, { 4309}, {13482}, {14809},
{ 5596}, {22524}, {13958}, {16918}, {25668}, {31621}, {30060}, {24637}, {28116}, {15994},
{30595}, {30642}, {30017}, { 7221}, { 2916}, { 7010}, {29356}, {22282}, {30649}, {17493},
{28780}, { 6725}, {26998}, {28805}, {24689}, {25547}, {17625}, {14250}, {11250}, {16195},
{ 9542}, {26029}, { 2734}, {23373}, {21176}, {28102}, { 1894}, { 325}, { 9406}, { 4915},
{ 8759}, {32413}, {14144}, { 5394}, { 3495}, {32030}, {23904}, { 4260}, {11579}, {11100},
{27212}, {20562}, {30264}, {30850}, {22393}, {28107}, {21299}, {25306}, { 2668}, { 3894},
};
int i;
for ( i = 0; i < 100; i += 1 ) {
avl_tree_insert(t, ib+i);
}
ASSERT(avl_verify_consistency(t, t->root), "Tree starting inconsistent.");
median_node = avl_tree_get_median(t);
avl_delete_node(t, median_node);
ASSERT(avl_verify_consistency(t, t->root), "Tree inconsistent after delete.");
median_node = avl_tree_get_median(t);
ASSERT( ((IntBucket*)(median_node->bucket))->p == 18374, "Wrong median after delete." );
while ( t->root->count > 1 ) {
avl_delete_node(t, t->root);
ASSERT(avl_verify_consistency(t, t->root), "Tree inconsistent after delete.");
}
avl_delete_node(t, t->root);
x.p = 99; avl_tree_insert(t, &x);
x.p = 199; avl_tree_insert(t, &x);
x.p = 299; avl_tree_insert(t, &x);
x.p = 399; avl_tree_insert(t, &x);
x.p = 499; avl_tree_insert(t, &x);
ASSERT(5 == t->root->count, "Wrong count after 5 inserts.");
ASSERT(avl_verify_consistency(t, t->root), "Tree inconsistent after 5 inserts.");
avl_delete_node(t, t->root->right);
ASSERT(4 == t->root->count, "Wrong count after first delete.");
ASSERT(avl_verify_consistency(t, t->root), "Tree inconsistent after first delete.");
destroy_avl_tree(t);
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ GLPCOL *col;
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_col_name: j = %d; column name too long\n",
j);
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_row_name: i = %d; row name too long\n", i);
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ glp_tree *tree = lp->tree;
GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (tree != NULL && tree->reason != 0)
{ xassert(tree->curr != NULL);
xassert(row->level == tree->curr->level);
}
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_row_name: i = %d; row name too long\n",
i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_row_name: i = %d: row name contains inva"
"lid character(s)\n", i);
}
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ glp_tree *tree = lp->tree;
GLPCOL *col;
if (tree != NULL && tree->reason != 0)
xerror("glp_set_col_name: operation not allowed\n");
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_col_name: j = %d; column name too long\n"
, j);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_col_name: j = %d: column name contains i"
"nvalid character(s)\n", j);
}
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_vertex_name(glp_graph *G, int i, const char *name)
{ /* assign (change) vertex name */
glp_vertex *v;
if (!(1 <= i && i <= G->nv))
xerror("glp_set_vertex_name: i = %d; vertex number out of rang"
"e\n", i);
v = G->v[i];
if (v->name != NULL)
{ if (v->entry != NULL)
{ xassert(G->index != NULL);
avl_delete_node(G->index, v->entry);
v->entry = NULL;
}
dmp_free_atom(G->pool, v->name, strlen(v->name)+1);
v->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_vertex_name: i = %d; vertex name too lon"
"g\n", i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_vertex_name: i = %d; vertex name contain"
"s invalid character(s)\n", i);
}
v->name = dmp_get_atom(G->pool, strlen(name)+1);
strcpy(v->name, name);
if (G->index != NULL)
{ xassert(v->entry == NULL);
v->entry = avl_insert_node(G->index, v->name);
avl_set_node_link(v->entry, v);
}
}
return;
}
int main(int argc, char ** argv)
{
unsigned int i;
pthread_t * threads;
unsigned int * ids;
double maxval;
double curval;
struct s_rule_link * root;
struct s_rule_link * prevlink;
struct s_rule_link * curlink;
struct s_rule_link * tmplink;
struct s_rule_link * maxlink;
int maxrulelen = 500;
avl_tree_t * oldcoverage;
avl_node_t * scoverage;
avl_node_t * scoverage2;
BLOOM_TYPE * bloom;
uint64_t curindex;
uint64_t nbleft;
double wordlistProcessingTime, candidateProcessingTime;
char * endptr;
setlimits();
if(argc<6)
usage();
matchlimit = atoi(argv[1]);
if(matchlimit == 0)
usage();
nbthreads = atoi(argv[2]);
if(nbthreads == 0)
nbthreads = 1;
wordlistProcessingTime = strtod(argv[3], &endptr);
// weak check
if(endptr == argv[3])
{
fprintf(stderr, "Could not parse wordlistProcessingTime\n");
usage();
}
candidateProcessingTime = strtod(argv[4], &endptr);
if(endptr == argv[4])
{
fprintf(stderr, "Could not parse candidateProcessingTime: %s\n", argv[4]);
usage();
}
fprintf(stderr, "Wordlist processing time: %es / Candidate processing time: %es/candidate\n", wordlistProcessingTime, candidateProcessingTime);
nbfiles = argc-5;
threads = xmalloc(sizeof(pthread_t)*nbthreads);
memset(threads, 0, sizeof(pthread_t)*nbthreads);
ids = xmalloc(sizeof(unsigned int)*nbthreads);
rulejob = xmalloc(sizeof(struct s_rulejob)*nbfiles);
bloom = xmalloc(BLOOM_STORAGE);
for(i=0;i<nbfiles;i++)
{
rulejob[i].root = NULL;
rulejob[i].tail = NULL;
rulejob[i].done_by = -1;
rulejob[i].filename = argv[i+5];
}
for(i=0;i<nbthreads;i++)
{
ids[i] = i;
if(pthread_create(&threads[i], NULL, load_rules, &ids[i]))
{
fprintf(stderr, "error, could not create thread for file %s\n", argv[i+4]);
perror("pthread_create");
return 1;
}
}
for(i=0;i<nbthreads;i++)
pthread_join( threads[i], NULL );
root = NULL;
for(i=0;i<nbfiles;i++)
{
if(rulejob[i].tail == NULL)
continue;
rulejob[i].tail->next = root;
root = rulejob[i].root;
}
free(rulejob);
fprintf(stderr, "start crunching\n");
oldcoverage = NULL;
while(1)
{
maxval = 0;
curlink = root;
prevlink = NULL;
maxlink = NULL;
nbleft = 0;
while(curlink)
{
if(curlink->coverage == NULL)
curval = 1e50;
else
{
if(oldcoverage)
{
/* coverage cleanup */
scoverage = curlink->coverage->head;
while(scoverage)
{
curindex = (uint64_t) scoverage->item;
if(GETBIT(bloom, curindex) && avl_search(oldcoverage, (void *) curindex))
{
scoverage2 = scoverage->next;
avl_delete_node(curlink->coverage, scoverage);
scoverage = scoverage2;
}
else
{
nbleft++;
scoverage = scoverage->next;
}
}
}
curval = ((double) avl_count(curlink->coverage)) / ( ((double) curlink->pwtested )*candidateProcessingTime + wordlistProcessingTime) ;
}
if( (curlink->coverage == NULL) || (avl_count(curlink->coverage) <matchlimit))
{
if(curlink->rule)
{
free(curlink->rule);
}
if(curlink->coverage)
{
avl_free_tree(curlink->coverage);
}
if(prevlink)
prevlink->next = curlink->next;
else
root = curlink->next;
tmplink = curlink;
curlink = curlink->next;
free(tmplink);
continue;
}
if(curval>maxval || (curval == maxval && strlen(curlink->rule) < maxrulelen ) )
{
maxrulelen = strlen(curlink->rule);
maxval = curval;
maxlink = curlink;
}
prevlink = curlink;
curlink = curlink->next;
}
if(maxlink == NULL)
break;
if(oldcoverage)
avl_free_tree(oldcoverage);
oldcoverage = maxlink->coverage;
/* build bloom filter */
memset(bloom, 0, BLOOM_STORAGE);
scoverage = oldcoverage->head;
while(scoverage)
{
//pcurindex = scoverage->item;
//curindex = *pcurindex;
curindex = (uint64_t) scoverage->item;
SETBIT(bloom, curindex);
scoverage = scoverage->next;
}
maxlink->coverage = NULL;
printf("%s NBPWD=%d [%f]\n", maxlink->rule, avl_count(oldcoverage), maxval);
fprintf(stderr, "%s NBPWD=%d [%f] NBRULES=%ld\n", maxlink->rule, avl_count(oldcoverage), maxval, nbleft);
}
return 0;
}
/*
* This function deletes the node which contains specified value
*/
avl_st *avl_delete_node(avl_st *root,
void *data,
size_t len,
bst_data_compare_t compare)
{
int rc = EOK;
avl_st *temp;
/*
* First traverse to the node of deletion.
*/
CHECK_RC_ASSERT((data == NULL), 0);
if (root == NULL)
{
return root;
}
rc = compare(root->bst_data, data);
if (rc == FIRST_GREATER)
{
root->bst_left = avl_delete_node(root->bst_left,
data, len, compare);
}
else if (rc == FIRST_LESS)
{
root->bst_right = avl_delete_node(root->bst_right,
data, len, compare);
}
else
{
CHECK_RC_ASSERT((root == NULL), 0);
if ((root->bst_left == NULL) ||
(root->bst_right == NULL))
{
temp = root->bst_left ? root->bst_left : root->bst_right;
/*
* No child case.
*/
if (temp == NULL)
{
temp = root;
root = NULL;
}
else
{
memcpy(root->bst_data, temp->bst_data, len);
root->bst_left = NULL;
root->bst_right = NULL;
}
if (avl_root == temp)
{
avl_root = NULL;
}
avl_dealloc_node(&temp);
}
else
{
temp = avl_get_min_value(root->bst_right);
memcpy(root->bst_data, temp->bst_data, len);
root->bst_right = avl_delete_node(root->bst_right,
root->bst_data, len, compare);
}
}
if (root == NULL)
{
return root;
}
bst_update_node_height(root);
return (avl_do_balance_after_delete_internal(root));
}
