/** * @brief Basic BDD test. * @return 0 if successful; -1 otherwise. */ static int testBdd(int verbosity) { DdManager *dd; DdNode *f, *var, *tmp; int i, ret; dd = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0); if (!dd) { if (verbosity) { printf("initialization failed\n"); } return -1; } if (verbosity) { printf("Started CUDD version "); Cudd_PrintVersion(stdout); } f = Cudd_ReadOne(dd); Cudd_Ref(f); for (i = 3; i >= 0; i--) { var = Cudd_bddIthVar(dd, i); tmp = Cudd_bddAnd(dd, Cudd_Not(var), f); if (!tmp) { if (verbosity) { printf("computation failed\n"); } return -1; } Cudd_Ref(tmp); Cudd_RecursiveDeref(dd, f); f = tmp; } if (verbosity) { Cudd_bddPrintCover(dd, f, f); } Cudd_RecursiveDeref(dd, f); ret = Cudd_CheckZeroRef(dd); if (ret != 0 && verbosity) { printf("%d unexpected non-zero references\n", ret); } Cudd_Quit(dd); return 0; }
/** * @brief Basic test of timeout handler. * * @details Sets a short timeout and then tries to build a function * with a large BDD. Strives to avoid leaking nodes. * * @return 0 if successful; -1 otherwise. */ static int testTimeout(int verbosity) { DdManager *dd; /* Declare these "volatile" to prevent clobbering by longjmp. */ DdNode * volatile f; DdNode * volatile clause = NULL; DdNode * var1, * var2; int i, ret, count; int const N = 20; /* half the number of variables in f */ unsigned long timeout = 100UL; /* in milliseconds */ jmp_buf timeoutEnv; dd = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0); if (!dd) { if (verbosity) { printf("initialization failed\n"); } return -1; } /* Set up timeout handling. */ if (setjmp(timeoutEnv) > 0) { if (verbosity) { printf("caught timeout\n"); } /* The nodes of clause may be leaked if the timeout was * detected while conjoining the clause to f. We set * clause to NULL when it's not in use to be able to * detect this case. */ if (clause) Cudd_RecursiveDeref(dd, clause); goto finally; } (void) Cudd_RegisterTimeoutHandler(dd, timeoutHandler, (void *) &timeoutEnv); (void) Cudd_SetTimeLimit(dd, timeout); /* Try to build function. This is expected to run out of time. */ f = Cudd_ReadOne(dd); Cudd_Ref(f); for (i = 0; i < N; i++) { DdNode * tmp; var1 = Cudd_bddIthVar(dd, i); if (!var1) { if (verbosity) { printf("computation failed\n"); return -1; } } var2 = Cudd_bddIthVar(dd, i+N); if (!var2) { if (verbosity) { printf("computation failed\n"); return -1; } } clause = Cudd_bddOr(dd, var1, var2); if (!clause) { if (verbosity) { printf("computation failed\n"); } return -1; } Cudd_Ref(clause); tmp = Cudd_bddAnd(dd, f, clause); if (!tmp) { if (verbosity) { printf("computation failed\n"); } return -1; } Cudd_Ref(tmp); Cudd_RecursiveDeref(dd, clause); clause = NULL; Cudd_RecursiveDeref(dd, f); f = tmp; } if (verbosity > 1) { Cudd_bddPrintCover(dd, f, f); } finally: if (verbosity) { printf("so far"); Cudd_PrintSummary(dd, f, 2*N, 0); } count = 0; for (i = 0; i < N-1; i += 2) { var1 = Cudd_bddIthVar(dd, i); if (!var1) { printf("computation failed\n"); return -1; } var2 = Cudd_bddIthVar(dd, i+1); if (!var2) { printf("computation failed\n"); return -1; } clause = Cudd_bddOr(dd, var1, var2); if (!clause) { printf("computation failed\n"); return -1; } Cudd_Ref(clause); if (Cudd_bddLeq(dd, f, clause)) { count++; } Cudd_RecursiveDeref(dd, clause); } if (verbosity) { printf("f implies %d clauses\n", count); } Cudd_RecursiveDeref(dd, f); ret = Cudd_CheckZeroRef(dd); if (verbosity) { Cudd_PrintInfo(dd, stdout); if (ret != 0) { printf("%d non-zero references\n", ret); } } Cudd_Quit(dd); return 0; }
void BddBuilder::dotDumpC(DdNode ** ddNodes,int& number_of_diff_output,char** diff_output){ char filename[128]; DdNode * dumpdd[1]; char * dumpname[1]; int res; int * index_of_diff_output; int j=0; index_of_diff_output = new int[__outputWireCnt]; for(int i=0 ; i<__outputWireCnt ; ++i){ if(ddNodes[i] != NULL){ number_of_diff_output++; index_of_diff_output[j++] = i; printf("%s\n",__ppOutputNodesNames[i]); sprintf(filename, "./dotdump/dumpC_%s.dot", __ppOutputNodesNames[i]); FILE * fp = fopen(filename, "w"); dumpdd[0] = ddNodes[i]; dumpname[0] = __ppOutputNodesNames[i]; res = Cudd_DumpDot(__pddManager, 1, dumpdd, __ppInputNodesNames, dumpname, fp); fclose(fp); sprintf(filename, "./factored/dumpC_factored_%s", __ppOutputNodesNames[i]); fp = fopen(filename, "w"); Cudd_DumpFactoredForm(__pddManager, 1, dumpdd, __ppInputNodesNames, dumpname, fp); fclose(fp); printf("Factored form(Boolean equation) written : %s\n", filename); //Cudd_PrintDebug(__pddManager, dumpdd[0], Cudd_ReadSize(__pddManager), 4); sprintf(filename, "./sop/%s.sop", __ppOutputNodesNames[i]); FILE * fp_sop = fopen(filename, "w"); FILE * tmp; FILE* debug = fopen("debug.txt","w"); printf("%s's SOP:\n", __ppOutputNodesNames[i]); Cudd_bddPrintCover(__pddManager, dumpdd[0], dumpdd[0]); //Cudd_PrintMinterm(__pddManager,dumpdd[0]); tmp = Cudd_ReadStdout(__pddManager); Cudd_SetStdout(__pddManager, fp_sop); Cudd_bddPrintCover(__pddManager, dumpdd[0], dumpdd[0]); //Cudd_PrintMinterm(__pddManager,dumpdd[0]); //fprintf(fp_sop,"\n"); Cudd_SetStdout(__pddManager, debug); Cudd_PrintDebug(__pddManager,dumpdd[0],Cudd_ReadSize(__pddManager),4); Cudd_SetStdout(__pddManager, tmp); fseek(fp_sop,-2,SEEK_END); //fputc(0,fp_so; fclose(fp_sop); printf("SOP file written : %s\n\n", filename); /*printf("Quine-Mccluskey for %s:\n", __ppOutputNodesNames[i]); QuineMccluskey quine(filename); printf("Quine-Mccluskey for %s Done.\n", __ppOutputNodesNames[i]); */ //Cudd_PrintMinterm(__pddManager, dumpdd[0]); if(res == 1) printf("DOT dump for C's %s completed.\n", __ppOutputNodesNames[i]); else printf("DOT dump for C's %s failed.\n", __ppOutputNodesNames[i]); } else printf("DOT dump for C's %s not executed: A = B\n", __ppOutputNodesNames[i]); } for(int i=0;i<number_of_diff_output;i++){ strcpy(diff_output[i],__ppOutputNodesNames[index_of_diff_output[i]]); } delete index_of_diff_output; }