EdgeList generateEdgeList(int argc, char** argv, packed_edge** output){
int log_numverts;
int64_t nedges;
packed_edge* result;
log_numverts = 16; /* In base 2 */
if (argc >= 2) log_numverts = atoi(argv[1]);
make_graph(log_numverts, INT64_C(16) << log_numverts, 1, 2, &nedges, &result);
printf("nedges=%ld before\n",nedges);
//remove loops:
#if rmdup
tic();
packed_edge* end=thrust::remove_if(result, result+nedges, is_loop());
//sort packed_edge twice:
thrust::sort(result,end,pe_less1());
thrust::sort(result,end,pe_less2());
//nedges=(end-result);
//printf("nedges=%d after loop\n",nedges);
//remove duplicates:
end=thrust::unique(result,end);
cudaDeviceSynchronize();
elapsed_time+=toc();
printf("remove dup took %f ms\n", elapsed_time);
//TEMP: reset elapsed time:
elapsed_time=0;
nedges=(end-result);
printf("nedges=%ld after dup\n",nedges);
//
#endif
uusi::EdgeList el=graph500ToEdgeList((const packed_edge*)result,nedges);
*output=result;
return el;
}
bool term_is_observable_for_special_reasons(Term* term)
{
return (is_output_placeholder(term)
|| (term->function == FUNCS.function_decl)
|| (term->function == FUNCS.loop_iterator)
|| (is_loop(term->owningBlock) && is_output_placeholder(term))
|| (term_get_bool_prop(term, s_LocalStateResult, false)));
}
static unsigned int leftmatch_fb(struct aa_dfa *dfa, unsigned int start,
const char *str, struct match_workbuf *wb,
unsigned int *count)
{
u16 *def = DEFAULT_TABLE(dfa);
u32 *base = BASE_TABLE(dfa);
u16 *next = NEXT_TABLE(dfa);
u16 *check = CHECK_TABLE(dfa);
unsigned int state = start, pos;
AA_BUG(!dfa);
AA_BUG(!str);
AA_BUG(!wb);
AA_BUG(!count);
*count = 0;
if (state == 0)
return 0;
/* current state is <state>, matching character *str */
if (dfa->tables[YYTD_ID_EC]) {
/* Equivalence class table defined */
u8 *equiv = EQUIV_TABLE(dfa);
/* default is direct to next state */
while (*str) {
unsigned int adjust;
wb->history[wb->pos] = state;
pos = base_idx(base[state]) + equiv[(u8) *str++];
if (check[pos] == state)
state = next[pos];
else
state = def[state];
if (is_loop(wb, state, &adjust)) {
state = aa_dfa_match(dfa, state, str);
*count -= adjust;
goto out;
}
inc_wb_pos(wb);
(*count)++;
}
} else {
/* default is direct to next state */
while (*str) {
unsigned int adjust;
wb->history[wb->pos] = state;
pos = base_idx(base[state]) + (u8) *str++;
if (check[pos] == state)
state = next[pos];
else
state = def[state];
if (is_loop(wb, state, &adjust)) {
state = aa_dfa_match(dfa, state, str);
*count -= adjust;
goto out;
}
inc_wb_pos(wb);
(*count)++;
}
}
out:
if (!state)
*count = 0;
return state;
}
bool is_counted() { return is_loop() && _head != NULL && _head->is_CountedLoop(); }
bool is_inner() { return is_loop() && _child == NULL; }
DFA *dfaProduct(DFA* a1, DFA* a2, dfaProductType ff)
{
DFA *b;
int i;
unsigned *root_ptr;
char binfun[4];
int make_a_loop;
unsigned size_estimate = 4 + 4 *
(bdd_size(a1->bddm) > bdd_size(a2->bddm) ?
bdd_size(a1->bddm) : bdd_size(a2->bddm));
bdd_manager *bddm;
/* #define _AUTOMATON_HASHED_IN_PRODUCT_
*/
#ifdef _AUTOMATON_HASHED_IN_PRODUCT_
/*prepare hashed access */
bddm = bdd_new_manager(size_estimate, size_estimate/8 + 2);
bdd_make_cache(bddm, size_estimate, size_estimate/8 + 2);
bddm->cache_erase_on_doubling = TRUE ;
#else
/*prepare sequential access*/
bddm = bdd_new_manager(size_estimate, 0);
bdd_make_cache(bddm, size_estimate, size_estimate/8 + 2);
#endif
binfun[0] = ff&1; binfun[1] = (ff&2)>>1; /* The binary function */
binfun[2] = (ff&4)>>2; binfun[3] = (ff&8)>>3;
qst = qh = qt = new_list(a1->s, a2->s, (list) 0);
htbl = new_hash_tab(&hash2, &eq2);
insert_in_hash_tab(htbl, a1->s, a2->s, (void *) 1);
last_state = 1; /* Careful here! Bdd's start at 0, hashtbl at 1 */
while(qh) { /* Our main loop, nice and tight */
make_a_loop = make_a_loop_status(is_loop(a1->bddm, qh->li1,
a1->q[qh->li1]),
a1->f[qh->li1],
is_loop(a2->bddm, qh->li2,
a2->q[qh->li2]),
a2->f[qh->li2],
binfun);
if (make_a_loop != 2)
make_loop(bddm, qh->li1, qh->li2);
else {
#ifdef _AUTOMATON_HASHED_IN_PRODUCT_
(void) bdd_apply2_hashed (a1->bddm, a1->q[qh->li1],
a2->bddm, a2->q[qh->li2],
bddm,
&prod_term_fn);
#else
(void) bdd_apply2_sequential (a1->bddm, a1->q[qh->li1],
a2->bddm, a2->q[qh->li2],
bddm,
&prod_term_fn);
#endif
}
qh = qh->next;
}
b = dfaMakeNoBddm(last_state); /* Return the result */
b->s = 0; /* Always first on list */
b->bddm = bddm;
for (i=0, root_ptr = bdd_roots(bddm);
i < last_state; root_ptr++, i++) {
list qnxt;
b->q[i] = *root_ptr;
b->f[i] = ((a1->f[qst->li1] != 0) && (a2->f[qst->li2] != 0)) ?
/* both states are non-bottom, use "binfun" */
BOOL_TO_STATUS(binfun[STATUS_TO_BOOL(a1->f[qst->li1])*2
+ STATUS_TO_BOOL(a2->f[qst->li2])]) :
/* at least one is bottom */
0;
qnxt = qst->next;
mem_free(qst); /* Free the list */
qst = qnxt;
}
free_hash_tab(htbl);
bdd_update_statistics(bddm, (unsigned) PRODUCT);
bdd_kill_cache(b->bddm);
return(b);
}
static void *
reach_thread (void *vdata)
{
struct tdata *data = vdata;
int sw = data->sw;
struct list_res *res = &data->res;
const uint32_t *out = g_out;
int nout = g_nout;
int ntfs = data_file->ntfs - 1;
//int count = 0, loops = 0;
while (true) {
struct list_res queue = {0};
pthread_mutex_lock (&wait_lock);
//fprintf (stderr, "%d %d\n", sw, queues[sw].n);
while (!queues[sw].head) {
waiters |= 1 << sw;
if (waiters + 1 == 1 << ntfs) {
for (int i = 0; i < ntfs; i++) {
if (i == sw) continue;
pthread_cond_broadcast (&conds[i]);
}
pthread_mutex_unlock (&wait_lock);
return NULL;
}
pthread_cond_wait (&conds[sw], &wait_lock);
if (waiters + 1 == 1 << ntfs) {
pthread_mutex_unlock (&wait_lock);
return NULL;
}
assert (waiters | (1 << sw));
}
queue = queues[sw];
memset (&queues[sw], 0, sizeof queues[sw]);
pthread_mutex_unlock (&wait_lock);
struct res *cur;
while ((cur = queue.head)) {
list_pop (&queue);
bool new_res = false;
struct list_res nextqs[ntfs];
memset (nextqs, 0, sizeof nextqs);
struct list_res ntf_res = ntf_apply (cur, sw);
struct res *ntf_cur = ntf_res.head;
while (ntf_cur) {
struct res *ntf_next = ntf_cur->next;
if (!out || int_find (ntf_cur->port, out, nout)) {
list_append (res, ntf_cur);
ref_add (ntf_cur, cur);
if (out) {
ntf_cur = ntf_next;
continue;
}
}
struct list_res ttf_res = tf_apply (tf_get (0), ntf_cur, true);
struct res *ttf_cur = ttf_res.head;
while (ttf_cur) {
struct res *ttf_next = ttf_cur->next;
if (is_loop (ttf_cur->port, cur)) {
res_free (ttf_cur);
ttf_cur = ttf_next;
//loops++;
continue;
}
ref_add (ttf_cur, cur);
if (out && int_find (ttf_cur->port, out, nout)) list_append (res, ttf_cur);
else {
int new_sw = ntf_get_sw (ttf_cur->port);
list_append (&nextqs[new_sw], ttf_cur);
//count++;
new_res = true;
}
ttf_cur = ttf_next;
}
if (out) res_free (ntf_cur);
ntf_cur = ntf_next;
}
res_free_mt (cur, true);
if (!new_res) continue;
pthread_mutex_lock (&wait_lock);
unsigned int wake = 0;
for (int i = 0; i < ntfs; i++) {
if (!nextqs[i].head) continue;
list_concat (&queues[i], &nextqs[i]);
pthread_cond_broadcast (&conds[i]);
wake |= 1 << i;
}
waiters &= ~wake;
pthread_mutex_unlock (&wait_lock);
}
}
}
