/**
* @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;
}
