bdd_ptr makepath(bdd_manager *bddm, int n, unsigned leaf_value,
void (*update_bddpaths) (unsigned (*new_place) (unsigned node)))
{
bdd_ptr res, sub_res, default_state_ptr;
unsigned index;
while ((n < offsets_size) && (sorted_path[n] == 'X'))
n++;
if (n >= offsets_size)
return (bdd_find_leaf_hashed(bddm, leaf_value, SEQUENTIAL_LIST(sub_results), update_bddpaths));
sub_res = makepath(bddm, n+1, leaf_value, update_bddpaths);
PUSH_SEQUENTIAL_LIST(sub_results, unsigned, sub_res);
default_state_ptr = bdd_find_leaf_hashed(bddm, default_state, SEQUENTIAL_LIST(sub_results), update_bddpaths);
POP_SEQUENTIAL_LIST(sub_results, unsigned, sub_res);
index = global_offsets[sorted_indices[n]];
if (sorted_path[n] == '0')
res = bdd_find_node_hashed(bddm, sub_res, default_state_ptr, index, SEQUENTIAL_LIST(sub_results), update_bddpaths);
else
res = bdd_find_node_hashed(bddm, default_state_ptr, sub_res, index, SEQUENTIAL_LIST(sub_results), update_bddpaths);
return res;
}
void makebdd(bdd_manager *bddm)
{
bdd_manager *tmp_bddm;
bdd_ptr united_bdds, default_ptr;
int i;
tmp_bddm = bdd_new_manager(8, 4);
/*
** insert a leaf with value 'default_state' in tmp_bddm,
** if not already present
*/
default_ptr = bdd_find_leaf_hashed(tmp_bddm, default_state, SEQUENTIAL_LIST(sub_results), &update_bddpaths);
for (exp_count = 0; exp_count < no_exceptions; exp_count++) {
for (i = 0; i < offsets_size; i++)
sorted_path[i] = exceptions[exp_count].path[sorted_indices[i]];
/* clear the cache */
bdd_kill_cache(tmp_bddm);
bdd_make_cache(tmp_bddm, 8, 4);
tmp_bddm->cache_erase_on_doubling = TRUE;
bddpaths[exp_count] = makepath(tmp_bddm, 0, exceptions[exp_count].value, &update_bddpaths);
PUSH_SEQUENTIAL_LIST(tmp_bddm->roots, unsigned, bddpaths[exp_count]);
}
if (no_exceptions == 0)
united_bdds = default_ptr;
else if (no_exceptions == 1)
united_bdds = TOP_SEQUENTIAL_LIST(tmp_bddm->roots);
else
united_bdds = unite_roots(tmp_bddm);
bdd_prepare_apply1(tmp_bddm);
bdd_apply1(tmp_bddm, united_bdds, bddm, &fn_identity); /* store the result in bddm->roots */
bdd_kill_manager(tmp_bddm);
}
void double_table_and_cache_hashed(bdd_manager *bddm,
unsigned* some_roots,
void (*update_fn)(unsigned (*new_place)(unsigned node)),
unsigned *p_of_find, unsigned *q_of_find,
boolean rehash_p_and_q) {
unsigned *p;
old_bddm = mem_alloc((size_t) sizeof (bdd_manager));
*old_bddm = *bddm;
/*make new bigger table, but only if a bigger one is possible */
if (bddm->table_total_size > BDD_MAX_TOTAL_TABLE_SIZE) {
printf("\nBDD too large (>%d nodes)\n", BDD_MAX_TOTAL_TABLE_SIZE);
abort();
}
bddm->table_log_size++;
bddm->table_size *= 2;
bddm->table_overflow_increment *= 2;
{
unsigned desired_size = bddm->table_size + BDD_NUMBER_OF_BINS +
bddm->table_overflow_increment;
bddm->table_total_size = (desired_size <= BDD_MAX_TOTAL_TABLE_SIZE)?
desired_size: BDD_MAX_TOTAL_TABLE_SIZE;
}
bddm->node_table = (bdd_record*)
mem_alloc( (size_t)
bddm->table_total_size
* (sizeof (bdd_record)));
bddm->table_mask = bddm->table_size - BDD_NUMBER_OF_BINS;
bddm->table_double_trigger *= 2;
bddm->table_overflow = bddm->table_size + BDD_NUMBER_OF_BINS;
#ifdef _BDD_STAT_
bddm->number_double++;
#endif
/* initialize to unused */
bddm->table_elements = 0;
mem_zero(&bddm->node_table[BDD_NUMBER_OF_BINS], (size_t)
bddm->table_size * (sizeof (bdd_record)));
/* initialize bddm roots to the empty list, this new list will
contain the rehashed addresses of old_bddm->roots*/
MAKE_SEQUENTIAL_LIST(bddm->roots, unsigned, 1024);
/*now rehash all nodes reachable from the old roots; we must be sure
that the apply1 operation does not entail doubling of bddm node
table: this is achieved by our having just doubled the size of the
table*/
bdd_prepare_apply1(old_bddm);
for (p = SEQUENTIAL_LIST(old_bddm->roots); *p ; p++) {
bdd_apply1(old_bddm, *p, bddm, &double_leaf_fn);
}
/*also make sure to rehash portion that is accessible from some_roots*/
for (p = some_roots; *p; p++) {
if (*p != BDD_UNDEF)
*p = bdd_apply1_dont_add_roots(old_bddm, *p, bddm, &double_leaf_fn);
}
/*and fix values p_of_find and q_of_find if indicated*/
if (rehash_p_and_q) {
*p_of_find =
bdd_apply1_dont_add_roots(old_bddm, *p_of_find, bddm, &double_leaf_fn);
*q_of_find =
bdd_apply1_dont_add_roots(old_bddm, *q_of_find, bddm, &double_leaf_fn);
}
/*perform user supplied updates*/
if (update_fn)
(*update_fn)(&get_new_r);
/*old_table now contains nodes whose mark field designates the
new position of the node*/
if (bddm->cache) {
if (bddm->cache_erase_on_doubling) {
bdd_kill_cache(bddm);
bdd_make_cache(bddm, 2 * bddm->cache_size * CACHE_NUMBER_OF_BINS,
2 * bddm->cache_overflow_increment * CACHE_NUMBER_OF_BINS);
}
else /*this is only a good idea when bddm is different from the managers
the current apply operation is performed over*/
double_cache(bddm, &get_new_r);
}
old_bddm->cache = (cache_record*) 0; /* old cache has been deallocated by now*/
/*deallocated old table and old roots*/
bdd_kill_manager(old_bddm);
}