static int lookup_element(unsigned int *seedp)
{
char keybuf[100];
struct ht_element *el, lookup;
int x;
/* pick a random element from 0 to highwater-1 */
x = my_rand(0,glob_highwater-1,seedp);
sprintf(keybuf, "key%08d", x);
lookup.key = keybuf;
el = ast_hashtab_lookup(glob_hashtab, &lookup);
els_lookedup++;
if (el)
els_found++;
if (el)
return 1;
return 0;
}
void permute( int *set, int len, char *vals, int lev, int *currset, int print_it)
{
int i;
match_count=0;
if( lev == len )
{
if(print_it)
{
/* print out the set */
for(i=0;i<len;i++)
{
printf("%c", vals[currset[i]]);
}
printf("\n");
}
else
{
char buf1[20];
for(i=0;i<len;i++)
{
buf1[i] = vals[currset[i]];
}
buf1[i] = 0;
if( ast_hashtab_lookup(dict, buf1) )
{
match_count++;
printf(" Found: %s in the dictionary!\n", buf1);
}
}
return;
}
for(i=0;i<len;i++)
{
if( !in_set(currset, lev, i) )
{
currset[lev] = i;
permute( set, len, vals, lev+1, currset, print_it );
}
}
}
/*! Randomly lookup data in the hash */
static void *hash_test_lookup(void *d)
{
struct hash_test *data = d;
int max;
unsigned seed = time(NULL);
/* ast_atomic_fetchadd_int provide a memory fence so that the optimizer doesn't
* optimize away reads.
*/
while ((max = ast_atomic_fetchadd_int(&data->grow_count, 0)) < data->max_grow) {
int i;
char *obj;
int is_in_hashtab;
if (is_timed_out(data)) {
return "Lookup timed out";
}
if (max == 0) {
/* No data yet; yield and try again */
sched_yield();
continue;
}
/* Randomly lookup one object from the hash */
i = rand_r(&seed) % max;
obj = ht_new(i);
if (obj == NULL) {
return "Allocation failed.";
}
is_in_hashtab = (ast_hashtab_lookup(data->to_be_thrashed, obj) != NULL);
ht_delete(obj);
if (!is_in_hashtab) {
return "key unexpectedly missing";
}
}
return NULL;
}
int main(int argc,char **argv)
{
char linebuffer[300];
FILE *ifile = fopen("/tmp/refs", "r");
char *t;
unsigned int un;
struct rc_obj *curr_obj, *count1_obj;
struct rc_obj lookup;
struct ast_hashtab_iter *it;
struct ast_hashtab *objhash;
if (!ifile) {
printf("Sorry, Cannot open /tmp/refs!\n");
exit(10);
}
objhash = ast_hashtab_create(9000, hashtab_compare_rc, ast_hashtab_resize_java, ast_hashtab_newsize_java, hashtab_hash_rc, 1);
while (fgets(linebuffer, sizeof(linebuffer), ifile)) {
/* collect data about the entry */
un = strtoul(linebuffer, &t, 16);
lookup.addr = un;
lookup.count = 1;
count1_obj = ast_hashtab_lookup(objhash, &lookup);
if (count1_obj) {
/* there IS a count1 obj, so let's see which one we REALLY want */
if (*(t+1) == '=') {
/* start a new object! */
curr_obj = alloc_obj(un, ++count1_obj->last_count);
/* put it in the hashtable */
ast_hashtab_insert_safe(objhash, curr_obj);
} else {
if (count1_obj->last_count > 1) {
lookup.count = count1_obj->last_count;
curr_obj = ast_hashtab_lookup(objhash, &lookup);
} else {
curr_obj = count1_obj;
}
}
} else {
/* NO obj at ALL? -- better make one! */
if (*(t+1) != '=') {
printf("BAD: object %x appears without previous allocation marker!\n", un);
}
curr_obj = count1_obj = alloc_obj(un, 1);
/* put it in the hashtable */
ast_hashtab_insert_safe(objhash, curr_obj);
}
if (*(t+1) == '+' || *(t+1) == '-' ) {
curr_obj->total_refcount += strtol(t+1, NULL, 10);
} else if (*(t+1) == '*') {
curr_obj->destroy_count++;
}
add_to_hist(linebuffer, curr_obj);
}
fclose(ifile);
/* traverse the objects and check for problems */
it = ast_hashtab_start_traversal(objhash);
while ((curr_obj = ast_hashtab_next(it))) {
if (curr_obj->total_refcount != 0 || curr_obj->destroy_count != 1) {
struct rc_hist *h;
if (curr_obj->total_refcount != 0)
printf("Problem: net Refcount not zero for object %x\n", curr_obj->addr);
if (curr_obj->destroy_count > 1 )
printf("Problem: Object %x destroyed more than once!\n", curr_obj->addr);
printf("Object %x history:\n", curr_obj->addr);
for(h=curr_obj->hist;h;h=h->next) {
printf(" %s", h->desc);
}
printf("==============\n");
}
}
ast_hashtab_end_traversal(it);
return 0;
}
int print_result(int *currset, int len, char **vals)
{
char solutionstring[1000];
/* print out the set */
/* int i;
for(i=0;i<len;i++)
{
printf("%s", vals[currset[i]]);
}
printf("\n"); */
/* test to see if each of the 6 lines of numbers adds to 26 */
if( (char)vals[currset[0]][0] + (char)vals[currset[2]][0] + (char)vals[currset[5]][0] + (char)vals[currset[7]][0] == 26
&& (char)vals[currset[0]][0] + (char)vals[currset[3]][0] + (char)vals[currset[6]][0] + (char)vals[currset[10]][0] == 26
&& (char)vals[currset[1]][0] + (char)vals[currset[2]][0] + (char)vals[currset[3]][0] + (char)vals[currset[4]][0] == 26
&& (char)vals[currset[1]][0] + (char)vals[currset[5]][0] + (char)vals[currset[8]][0] + (char)vals[currset[11]][0] == 26
&& (char)vals[currset[7]][0] + (char)vals[currset[8]][0] + (char)vals[currset[9]][0] + (char)vals[currset[10]][0] == 26
&& (char)vals[currset[4]][0] + (char)vals[currset[6]][0] + (char)vals[currset[9]][0] + (char)vals[currset[11]][0] == 26)
{
char *lookup_result;
/* yay! we found a solution! Check in the hashtab for it--
forming a string of the list of numbers should make for
fairly quick way of checking */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[0]][0],
(char)vals[currset[1]][0],
(char)vals[currset[2]][0],
(char)vals[currset[3]][0],
(char)vals[currset[4]][0],
(char)vals[currset[5]][0],
(char)vals[currset[6]][0],
(char)vals[currset[7]][0],
(char)vals[currset[8]][0],
(char)vals[currset[9]][0],
(char)vals[currset[10]][0],
(char)vals[currset[11]][0]);
lookup_result = ast_hashtab_lookup(solutions, solutionstring);
if (!lookup_result)
{
printf("\n Solution: 1=%d; 2=%d; 3=%d; 4=%d; 5=%d; 6=%d, 7=%d; 8=%d; 9=%d; 10=%d; 11=%d; 12=%d\n",
(char)vals[currset[0]][0],
(char)vals[currset[1]][0],
(char)vals[currset[2]][0],
(char)vals[currset[3]][0],
(char)vals[currset[4]][0],
(char)vals[currset[5]][0],
(char)vals[currset[6]][0],
(char)vals[currset[7]][0],
(char)vals[currset[8]][0],
(char)vals[currset[9]][0],
(char)vals[currset[10]][0],
(char)vals[currset[11]][0]);
solution_count++;
/* really, we don't need to insert the unrotated solution;
it will never come up again. But, oh, well.... */
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
/* How do I come up the index numbers? just take the drawing, rotate it to the
right one step, and now read off the position numbers on the rotated set... */
/* rotate 1/6 to the right */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[1]][0],
(char)vals[currset[7]][0],
(char)vals[currset[5]][0],
(char)vals[currset[2]][0],
(char)vals[currset[0]][0],
(char)vals[currset[8]][0],
(char)vals[currset[3]][0],
(char)vals[currset[11]][0],
(char)vals[currset[9]][0],
(char)vals[currset[6]][0],
(char)vals[currset[4]][0],
(char)vals[currset[10]][0]);
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
/* rotate 2/6 to the right */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[7]][0],
(char)vals[currset[11]][0],
(char)vals[currset[8]][0],
(char)vals[currset[5]][0],
(char)vals[currset[1]][0],
(char)vals[currset[9]][0],
(char)vals[currset[2]][0],
(char)vals[currset[10]][0],
(char)vals[currset[6]][0],
(char)vals[currset[3]][0],
(char)vals[currset[0]][0],
(char)vals[currset[4]][0]);
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
/* rotate 3/6 to the right */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[11]][0],
(char)vals[currset[10]][0],
(char)vals[currset[9]][0],
(char)vals[currset[8]][0],
(char)vals[currset[7]][0],
(char)vals[currset[6]][0],
(char)vals[currset[5]][0],
(char)vals[currset[4]][0],
(char)vals[currset[3]][0],
(char)vals[currset[2]][0],
(char)vals[currset[1]][0],
(char)vals[currset[0]][0]);
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
/* rotate 4/6 to the right */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[10]][0],
(char)vals[currset[4]][0],
(char)vals[currset[6]][0],
(char)vals[currset[9]][0],
(char)vals[currset[11]][0],
(char)vals[currset[3]][0],
(char)vals[currset[8]][0],
(char)vals[currset[0]][0],
(char)vals[currset[2]][0],
(char)vals[currset[5]][0],
(char)vals[currset[7]][0],
(char)vals[currset[1]][0]);
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
/* rotate 5/6 to the right */
sprintf(solutionstring,"%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
(char)vals[currset[4]][0],
(char)vals[currset[0]][0],
(char)vals[currset[3]][0],
(char)vals[currset[6]][0],
(char)vals[currset[10]][0],
(char)vals[currset[2]][0],
(char)vals[currset[9]][0],
(char)vals[currset[1]][0],
(char)vals[currset[5]][0],
(char)vals[currset[8]][0],
(char)vals[currset[11]][0],
(char)vals[currset[7]][0]);
ast_hashtab_insert_immediate(solutions, strdup(solutionstring));
}
else
non_unique_solutions_count++;
}
permutation_count++;
if( ((permutation_count+1) % 1000000) == 0 )
{
printf("."); fflush(stdout); /* show progress to keep the impatient calm -- you should get around 470 of these, each standing for a million generated permutations */
}
}
