int
Dddmp_cuddAddArrayLoad (
DdManager *ddMgr /* IN: DD Manager */,
Dddmp_RootMatchType rootMatchMode /* IN: storing mode selector */,
char **rootmatchnames /* IN: sorted names for loaded roots */,
Dddmp_VarMatchType varMatchMode /* IN: storing mode selector */,
char **varmatchnames /* IN: array of variable names, by ids */,
int *varmatchauxids /* IN: array of variable auxids, by ids */,
int *varcomposeids /* IN: array of new ids, by ids */,
int mode /* IN: requested input file format */,
char *file /* IN: file name */,
FILE *fp /* IN: file pointer */,
DdNode ***pproots /* OUT: array of returned BDD roots */
)
{
int retValue;
#if 0
#ifdef DDDMP_DEBUG
#ifndef __alpha__
int retValueBis;
retValueBis = Cudd_DebugCheck (ddMgr);
if (retValueBis == 1) {
fprintf (stderr, "Inconsistency Found During ADD Load.\n");
fflush (stderr);
} else {
if (retValueBis == CUDD_OUT_OF_MEM) {
fprintf (stderr, "Out of Memory During ADD Load.\n");
fflush (stderr);
}
}
#endif
#endif
#endif
retValue = DddmpCuddDdArrayLoad (DDDMP_ADD, ddMgr, rootMatchMode,
rootmatchnames, varMatchMode, varmatchnames, varmatchauxids,
varcomposeids, mode, file, fp, pproots);
#if 0
#ifdef DDDMP_DEBUG
#ifndef __alpha__
retValueBis = Cudd_DebugCheck (ddMgr);
if (retValueBis == 1) {
fprintf (stderr, "Inconsistency Found During ADD Load.\n");
fflush (stderr);
} else {
if (retValueBis == CUDD_OUT_OF_MEM) {
fprintf (stderr, "Out of Memory During ADD Load.\n");
fflush (stderr);
}
}
#endif
#endif
#endif
return (retValue);
}
/**Function********************************************************************
Synopsis [Main function for testcudd.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
int
main(int argc, char **argv)
{
FILE *fp; /* pointer to input file */
char *file = (char *) ""; /* input file name */
FILE *dfp = NULL; /* pointer to dump file */
char *dfile; /* file for DD dump */
DdNode *dfunc[2]; /* addresses of the functions to be dumped */
DdManager *dd; /* pointer to DD manager */
DdNode *_true; /* fast access to constant function */
DdNode *M;
DdNode **x; /* pointers to variables */
DdNode **y; /* pointers to variables */
DdNode **xn; /* complements of row variables */
DdNode **yn_; /* complements of column variables */
DdNode **xvars;
DdNode **yvars;
DdNode *C; /* result of converting from ADD to BDD */
DdNode *ess; /* cube of essential variables */
DdNode *shortP; /* BDD cube of shortest path */
DdNode *largest; /* BDD of largest cube */
DdNode *shortA; /* ADD cube of shortest path */
DdNode *constN; /* value returned by evaluation of ADD */
DdNode *ycube; /* cube of the negated y vars for c-proj */
DdNode *CP; /* C-Projection of C */
DdNode *CPr; /* C-Selection of C */
int length; /* length of the shortest path */
int nx; /* number of variables */
int ny;
int maxnx;
int maxny;
int m;
int n;
int N;
int cmu; /* use CMU multiplication */
int pr; /* verbose printout level */
int harwell;
int multiple; /* read multiple matrices */
int ok;
int c; /* variable to read in options */
int approach; /* reordering approach */
int autodyn; /* automatic reordering */
int groupcheck; /* option for group sifting */
int profile; /* print heap profile if != 0 */
int keepperm; /* keep track of permutation */
int clearcache; /* clear the cache after each matrix */
int blifOrDot; /* dump format: 0 -> dot, 1 -> blif, ... */
int retval; /* return value */
int i; /* loop index */
long startTime; /* initial time */
long lapTime;
int size;
unsigned int cacheSize, maxMemory;
unsigned int nvars,nslots;
startTime = util_cpu_time();
approach = CUDD_REORDER_NONE;
autodyn = 0;
pr = 0;
harwell = 0;
multiple = 0;
profile = 0;
keepperm = 0;
cmu = 0;
N = 4;
nvars = 4;
cacheSize = 127;
maxMemory = 0;
nslots = CUDD_UNIQUE_SLOTS;
clearcache = 0;
groupcheck = CUDD_GROUP_CHECK7;
dfile = NULL;
blifOrDot = 0; /* dot format */
/* Parse command line. */
while ((c = util_getopt(argc, argv, (char *) "CDHMPS:a:bcd:g:hkmn:p:v:x:X:"))
!= EOF) {
switch(c) {
case 'C':
cmu = 1;
break;
case 'D':
autodyn = 1;
break;
case 'H':
harwell = 1;
break;
case 'M':
#ifdef MNEMOSYNE
(void) mnem_setrecording(0);
#endif
break;
case 'P':
profile = 1;
break;
case 'S':
nslots = atoi(util_optarg);
break;
case 'X':
maxMemory = atoi(util_optarg);
break;
case 'a':
approach = atoi(util_optarg);
break;
case 'b':
blifOrDot = 1; /* blif format */
break;
case 'c':
clearcache = 1;
break;
case 'd':
dfile = util_optarg;
break;
case 'g':
groupcheck = atoi(util_optarg);
break;
case 'k':
keepperm = 1;
break;
case 'm':
multiple = 1;
break;
case 'n':
N = atoi(util_optarg);
break;
case 'p':
pr = atoi(util_optarg);
break;
case 'v':
nvars = atoi(util_optarg);
break;
case 'x':
cacheSize = atoi(util_optarg);
break;
case 'h':
default:
usage(argv[0]);
break;
}
}
if (argc - util_optind == 0) {
file = (char *) "-";
} else if (argc - util_optind == 1) {
file = argv[util_optind];
} else {
usage(argv[0]);
}
if ((approach<0) || (approach>17)) {
(void) fprintf(stderr,"Invalid approach: %d \n",approach);
usage(argv[0]);
}
if (pr >= 0) {
(void) printf("# %s\n", TESTCUDD_VERSION);
/* Echo command line and arguments. */
(void) printf("#");
for (i = 0; i < argc; i++) {
(void) printf(" %s", argv[i]);
}
(void) printf("\n");
(void) fflush(stdout);
}
/* Initialize manager and provide easy reference to terminals. */
dd = Cudd_Init(nvars,0,nslots,cacheSize,maxMemory);
_true = DD_TRUE(dd);
dd->groupcheck = (Cudd_AggregationType) groupcheck;
if (autodyn) Cudd_AutodynEnable(dd,CUDD_REORDER_SAME);
/* Open input file. */
fp = open_file(file, "r");
/* Open dump file if requested */
if (dfile != NULL) {
dfp = open_file(dfile, "w");
}
x = y = xn = yn_ = NULL;
do {
/* We want to start anew for every matrix. */
maxnx = maxny = 0;
nx = maxnx; ny = maxny;
if (pr>0) lapTime = util_cpu_time();
if (harwell) {
if (pr >= 0) (void) printf(":name: ");
ok = Cudd_addHarwell(fp, dd, &M, &x, &y, &xn, &yn_, &nx, &ny,
&m, &n, 0, 2, 1, 2, pr);
} else {
ok = Cudd_addRead(fp, dd, &M, &x, &y, &xn, &yn_, &nx, &ny,
&m, &n, 0, 2, 1, 2);
if (pr >= 0)
(void) printf(":name: %s: %d rows %d columns\n", file, m, n);
}
if (!ok) {
(void) fprintf(stderr, "Error reading matrix\n");
exit(1);
}
if (nx > maxnx) maxnx = nx;
if (ny > maxny) maxny = ny;
/* Build cube of negated y's. */
ycube = DD_TRUE(dd);
Cudd_Ref(ycube);
for (i = maxny - 1; i >= 0; i--) {
DdNode *tmpp;
tmpp = Cudd_bddAnd(dd,Cudd_Not(dd->vars[y[i]->index]),ycube);
if (tmpp == NULL) exit(2);
Cudd_Ref(tmpp);
Cudd_RecursiveDeref(dd,ycube);
ycube = tmpp;
}
/* Initialize vectors of BDD variables used by priority func. */
xvars = ALLOC(DdNode *, nx);
if (xvars == NULL) exit(2);
for (i = 0; i < nx; i++) {
xvars[i] = dd->vars[x[i]->index];
}
yvars = ALLOC(DdNode *, ny);
if (yvars == NULL) exit(2);
for (i = 0; i < ny; i++) {
yvars[i] = dd->vars[y[i]->index];
}
/* Clean up */
for (i=0; i < maxnx; i++) {
Cudd_RecursiveDeref(dd, x[i]);
Cudd_RecursiveDeref(dd, xn[i]);
}
FREE(x);
FREE(xn);
for (i=0; i < maxny; i++) {
Cudd_RecursiveDeref(dd, y[i]);
Cudd_RecursiveDeref(dd, yn_[i]);
}
FREE(y);
FREE(yn_);
if (pr>0) {(void) printf(":1: M"); Cudd_PrintDebug(dd,M,nx+ny,pr);}
if (pr>0) (void) printf(":2: time to read the matrix = %s\n",
util_print_time(util_cpu_time() - lapTime));
C = Cudd_addBddPattern(dd, M);
if (C == 0) exit(2);
Cudd_Ref(C);
if (pr>0) {(void) printf(":3: C"); Cudd_PrintDebug(dd,C,nx+ny,pr);}
/* Test iterators. */
retval = testIterators(dd,M,C,pr);
if (retval == 0) exit(2);
cuddCacheProfile(dd,stdout);
/* Test XOR */
retval = testXor(dd,C,pr,nx+ny);
if (retval == 0) exit(2);
/* Test Hamming distance functions. */
retval = testHamming(dd,C,pr);
if (retval == 0) exit(2);
/* Test selection functions. */
CP = Cudd_CProjection(dd,C,ycube);
if (CP == NULL) exit(2);
Cudd_Ref(CP);
if (pr>0) {(void) printf("ycube"); Cudd_PrintDebug(dd,ycube,nx+ny,pr);}
if (pr>0) {(void) printf("CP"); Cudd_PrintDebug(dd,CP,nx+ny,pr);}
if (nx == ny) {
CPr = Cudd_PrioritySelect(dd,C,xvars,yvars,(DdNode **)NULL,
(DdNode *)NULL,ny,Cudd_Xgty);
if (CPr == NULL) exit(2);
Cudd_Ref(CPr);
if (pr>0) {(void) printf(":4: CPr"); Cudd_PrintDebug(dd,CPr,nx+ny,pr);}
if (CP != CPr) {
(void) printf("CP != CPr!\n");
}
Cudd_RecursiveDeref(dd, CPr);
}
FREE(xvars); FREE(yvars);
Cudd_RecursiveDeref(dd, CP);
Cudd_RecursiveDeref(dd, ycube);
/* Test functions for essential variables. */
ess = Cudd_FindEssential(dd,C);
if (ess == NULL) exit(2);
Cudd_Ref(ess);
if (pr>0) {(void) printf(":4: ess"); Cudd_PrintDebug(dd,ess,nx+ny,pr);}
Cudd_RecursiveDeref(dd, ess);
/* Test functions for shortest paths. */
shortP = Cudd_ShortestPath(dd, M, NULL, NULL, &length);
if (shortP == NULL) exit(2);
Cudd_Ref(shortP);
if (pr>0) {
(void) printf(":5: shortP"); Cudd_PrintDebug(dd,shortP,nx+ny,pr);
}
/* Test functions for largest cubes. */
largest = Cudd_LargestCube(dd, Cudd_Not(C), &length);
if (largest == NULL) exit(2);
Cudd_Ref(largest);
if (pr>0) {
(void) printf(":5b: largest");
Cudd_PrintDebug(dd,largest,nx+ny,pr);
}
Cudd_RecursiveDeref(dd, largest);
/* Test Cudd_addEvalConst and Cudd_addIteConstant. */
shortA = Cudd_BddToAdd(dd,shortP);
if (shortA == NULL) exit(2);
Cudd_Ref(shortA);
Cudd_RecursiveDeref(dd, shortP);
constN = Cudd_addEvalConst(dd,shortA,M);
if (constN == DD_NON_CONSTANT) exit(2);
if (Cudd_addIteConstant(dd,shortA,M,constN) != constN) exit(2);
if (pr>0) {(void) printf("The value of M along the chosen shortest path is %g\n", cuddV(constN));}
Cudd_RecursiveDeref(dd, shortA);
shortP = Cudd_ShortestPath(dd, C, NULL, NULL, &length);
if (shortP == NULL) exit(2);
Cudd_Ref(shortP);
if (pr>0) {
(void) printf(":6: shortP"); Cudd_PrintDebug(dd,shortP,nx+ny,pr);
}
/* Test Cudd_bddIteConstant and Cudd_bddLeq. */
if (!Cudd_bddLeq(dd,shortP,C)) exit(2);
if (Cudd_bddIteConstant(dd,Cudd_Not(shortP),_true,C) != _true) exit(2);
Cudd_RecursiveDeref(dd, shortP);
if (profile) {
retval = cuddHeapProfile(dd);
}
size = dd->size;
if (pr>0) {
(void) printf("Average distance: %g\n", Cudd_AverageDistance(dd));
}
/* Reorder if so requested. */
if (approach != CUDD_REORDER_NONE) {
#ifndef DD_STATS
retval = Cudd_EnableReorderingReporting(dd);
if (retval == 0) {
(void) fprintf(stderr,"Error reported by Cudd_EnableReorderingReporting\n");
exit(3);
}
#endif
#ifdef DD_DEBUG
retval = Cudd_DebugCheck(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
exit(3);
}
retval = Cudd_CheckKeys(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_CheckKeys\n");
exit(3);
}
#endif
retval = Cudd_ReduceHeap(dd,(Cudd_ReorderingType)approach,5);
if (retval == 0) {
(void) fprintf(stderr,"Error reported by Cudd_ReduceHeap\n");
exit(3);
}
#ifndef DD_STATS
retval = Cudd_DisableReorderingReporting(dd);
if (retval == 0) {
(void) fprintf(stderr,"Error reported by Cudd_DisableReorderingReporting\n");
exit(3);
}
#endif
#ifdef DD_DEBUG
retval = Cudd_DebugCheck(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
exit(3);
}
retval = Cudd_CheckKeys(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_CheckKeys\n");
exit(3);
}
#endif
if (approach == CUDD_REORDER_SYMM_SIFT ||
approach == CUDD_REORDER_SYMM_SIFT_CONV) {
Cudd_SymmProfile(dd,0,dd->size-1);
}
if (pr>0) {
(void) printf("Average distance: %g\n", Cudd_AverageDistance(dd));
}
if (keepperm) {
/* Print variable permutation. */
(void) printf("Variable Permutation:");
for (i=0; i<size; i++) {
if (i%20 == 0) (void) printf("\n");
(void) printf("%d ", dd->invperm[i]);
}
(void) printf("\n");
(void) printf("Inverse Permutation:");
for (i=0; i<size; i++) {
if (i%20 == 0) (void) printf("\n");
(void) printf("%d ", dd->perm[i]);
}
(void) printf("\n");
}
if (pr>0) {(void) printf("M"); Cudd_PrintDebug(dd,M,nx+ny,pr);}
if (profile) {
retval = cuddHeapProfile(dd);
}
}
/* Dump DDs of C and M if so requested. */
if (dfile != NULL) {
dfunc[0] = C;
dfunc[1] = M;
if (blifOrDot == 1) {
/* Only dump C because blif cannot handle ADDs */
retval = Cudd_DumpBlif(dd,1,dfunc,NULL,(char **)onames,
NULL,dfp);
} else {
retval = Cudd_DumpDot(dd,2,dfunc,NULL,(char **)onames,dfp);
}
if (retval != 1) {
(void) fprintf(stderr,"abnormal termination\n");
exit(2);
}
}
Cudd_RecursiveDeref(dd, C);
Cudd_RecursiveDeref(dd, M);
if (clearcache) {
if (pr>0) {(void) printf("Clearing the cache... ");}
for (i = dd->cacheSlots - 1; i>=0; i--) {
dd->cache[i].data = NIL(DdNode);
}
if (pr>0) {(void) printf("done\n");}
}
if (pr>0) {
(void) printf("Number of variables = %6d\t",dd->size);
(void) printf("Number of slots = %6d\n",dd->slots);
(void) printf("Number of keys = %6d\t",dd->keys);
(void) printf("Number of min dead = %6d\n",dd->minDead);
}
} while (multiple && !feof(fp));
fclose(fp);
if (dfile != NULL) {
fclose(dfp);
}
/* Second phase: experiment with Walsh matrices. */
if (!testWalsh(dd,N,cmu,approach,pr)) {
exit(2);
}
/* Check variable destruction. */
assert(cuddDestroySubtables(dd,3));
assert(Cudd_DebugCheck(dd) == 0);
assert(Cudd_CheckKeys(dd) == 0);
retval = Cudd_CheckZeroRef(dd);
ok = retval != 0; /* ok == 0 means O.K. */
if (retval != 0) {
(void) fprintf(stderr,
"%d non-zero DD reference counts after dereferencing\n", retval);
}
if (pr >= 0) {
(void) Cudd_PrintInfo(dd,stdout);
}
Cudd_Quit(dd);
#ifdef MNEMOSYNE
mnem_writestats();
#endif
if (pr>0) (void) printf("total time = %s\n",
util_print_time(util_cpu_time() - startTime));
if (pr >= 0) util_print_cpu_stats(stdout);
exit(ok);
/* NOTREACHED */
} /* end of main */
/**Function********************************************************************
Synopsis [Tests Walsh matrix multiplication.]
Description [Tests Walsh matrix multiplication. Return 1 if successful;
0 otherwise.]
SideEffects [May create new variables in the manager.]
SeeAlso []
******************************************************************************/
static int
testWalsh(
DdManager *dd /* manager */,
int N /* number of variables */,
int cmu /* use CMU approach to matrix multiplication */,
int approach /* reordering approach */,
int pr /* verbosity level */)
{
DdNode *walsh1, *walsh2, *wtw;
DdNode **x, **v, **z;
int i, retval;
DdNode *_true = DD_TRUE(dd);
DdNode *_false = DD_FALSE(dd);
if (N > 3) {
x = ALLOC(DdNode *,N);
v = ALLOC(DdNode *,N);
z = ALLOC(DdNode *,N);
for (i = N-1; i >= 0; i--) {
Cudd_Ref(x[i]=cuddUniqueInter(dd,3*i,_true,_false));
Cudd_Ref(v[i]=cuddUniqueInter(dd,3*i+1,_true,_false));
Cudd_Ref(z[i]=cuddUniqueInter(dd,3*i+2,_true,_false));
}
Cudd_Ref(walsh1 = Cudd_addWalsh(dd,v,z,N));
if (pr>0) {(void) printf("walsh1"); Cudd_PrintDebug(dd,walsh1,2*N,pr);}
Cudd_Ref(walsh2 = Cudd_addWalsh(dd,x,v,N));
if (cmu) {
Cudd_Ref(wtw = Cudd_addTimesPlus(dd,walsh2,walsh1,v,N));
} else {
Cudd_Ref(wtw = Cudd_addMatrixMultiply(dd,walsh2,walsh1,v,N));
}
if (pr>0) {(void) printf("wtw"); Cudd_PrintDebug(dd,wtw,2*N,pr);}
if (approach != CUDD_REORDER_NONE) {
#ifdef DD_DEBUG
retval = Cudd_DebugCheck(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
return(0);
}
#endif
retval = Cudd_ReduceHeap(dd,(Cudd_ReorderingType)approach,5);
if (retval == 0) {
(void) fprintf(stderr,"Error reported by Cudd_ReduceHeap\n");
return(0);
}
#ifdef DD_DEBUG
retval = Cudd_DebugCheck(dd);
if (retval != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
return(0);
}
#endif
if (approach == CUDD_REORDER_SYMM_SIFT ||
approach == CUDD_REORDER_SYMM_SIFT_CONV) {
Cudd_SymmProfile(dd,0,dd->size-1);
}
}
/* Clean up. */
Cudd_RecursiveDeref(dd, wtw);
Cudd_RecursiveDeref(dd, walsh1);
Cudd_RecursiveDeref(dd, walsh2);
for (i=0; i < N; i++) {
Cudd_RecursiveDeref(dd, x[i]);
Cudd_RecursiveDeref(dd, v[i]);
Cudd_RecursiveDeref(dd, z[i]);
}
FREE(x);
FREE(v);
FREE(z);
}
/**Function********************************************************************
Synopsis [Linearly combines two adjacent variables.]
Description [Linearly combines two adjacent variables. It assumes
that no dead nodes are present on entry to this procedure. The
procedure then guarantees that no dead nodes will be present when it
terminates. cuddZddLinearInPlace assumes that x < y. Returns the
number of keys in the table if successful; 0 otherwise.]
SideEffects [None]
SeeAlso [cuddZddSwapInPlace cuddLinearInPlace]
******************************************************************************/
static int
cuddZddLinearInPlace(
DdManager * table,
int x,
int y)
{
DdNodePtr *xlist, *ylist;
int xindex, yindex;
int xslots, yslots;
int xshift, yshift;
int oldxkeys, oldykeys;
int newxkeys, newykeys;
int i;
int posn;
DdNode *f, *f1, *f0, *f11, *f10, *f01, *f00;
DdNode *newf1, *newf0, *g, *next, *previous;
DdNode *special;
#ifdef DD_DEBUG
assert(x < y);
assert(cuddZddNextHigh(table,x) == y);
assert(table->subtableZ[x].keys != 0);
assert(table->subtableZ[y].keys != 0);
assert(table->subtableZ[x].dead == 0);
assert(table->subtableZ[y].dead == 0);
#endif
zddTotalNumberLinearTr++;
/* Get parameters of x subtable. */
xindex = table->invpermZ[x];
xlist = table->subtableZ[x].nodelist;
oldxkeys = table->subtableZ[x].keys;
xslots = table->subtableZ[x].slots;
xshift = table->subtableZ[x].shift;
newxkeys = 0;
/* Get parameters of y subtable. */
yindex = table->invpermZ[y];
ylist = table->subtableZ[y].nodelist;
oldykeys = table->subtableZ[y].keys;
yslots = table->subtableZ[y].slots;
yshift = table->subtableZ[y].shift;
newykeys = oldykeys;
/* The nodes in the x layer are put in two chains. The chain
** pointed by g holds the normal nodes. When re-expressed they stay
** in the x list. The chain pointed by special holds the elements
** that will move to the y list.
*/
g = special = NULL;
for (i = 0; i < xslots; i++) {
f = xlist[i];
if (f == NULL) continue;
xlist[i] = NULL;
while (f != NULL) {
next = f->next;
f1 = cuddT(f);
/* if (f1->index == yindex) */ cuddSatDec(f1->ref);
f0 = cuddE(f);
/* if (f0->index == yindex) */ cuddSatDec(f0->ref);
if ((int) f1->index == yindex && cuddE(f1) == empty &&
(int) f0->index != yindex) {
f->next = special;
special = f;
} else {
f->next = g;
g = f;
}
f = next;
} /* while there are elements in the collision chain */
} /* for each slot of the x subtable */
/* Mark y nodes with pointers from above x. We mark them by
** changing their index to x.
*/
for (i = 0; i < yslots; i++) {
f = ylist[i];
while (f != NULL) {
if (f->ref != 0) {
f->index = xindex;
}
f = f->next;
} /* while there are elements in the collision chain */
} /* for each slot of the y subtable */
/* Move special nodes to the y list. */
f = special;
while (f != NULL) {
next = f->next;
f1 = cuddT(f);
f11 = cuddT(f1);
cuddT(f) = f11;
cuddSatInc(f11->ref);
f0 = cuddE(f);
cuddSatInc(f0->ref);
f->index = yindex;
/* Insert at the beginning of the list so that it will be
** found first if there is a duplicate. The duplicate will
** eventually be moved or garbage collected. No node
** re-expression will add a pointer to it.
*/
posn = ddHash(f11, f0, yshift);
f->next = ylist[posn];
ylist[posn] = f;
newykeys++;
f = next;
}
/* Take care of the remaining x nodes that must be re-expressed.
** They form a linked list pointed by g.
*/
f = g;
while (f != NULL) {
#ifdef DD_COUNT
table->swapSteps++;
#endif
next = f->next;
/* Find f1, f0, f11, f10, f01, f00. */
f1 = cuddT(f);
if ((int) f1->index == yindex || (int) f1->index == xindex) {
f11 = cuddT(f1); f10 = cuddE(f1);
} else {
f11 = empty; f10 = f1;
}
f0 = cuddE(f);
if ((int) f0->index == yindex || (int) f0->index == xindex) {
f01 = cuddT(f0); f00 = cuddE(f0);
} else {
f01 = empty; f00 = f0;
}
/* Create the new T child. */
if (f01 == empty) {
newf1 = f10;
cuddSatInc(newf1->ref);
} else {
/* Check ylist for triple (yindex, f01, f10). */
posn = ddHash(f01, f10, yshift);
/* For each element newf1 in collision list ylist[posn]. */
newf1 = ylist[posn];
/* Search the collision chain skipping the marked nodes. */
while (newf1 != NULL) {
if (cuddT(newf1) == f01 && cuddE(newf1) == f10 &&
(int) newf1->index == yindex) {
cuddSatInc(newf1->ref);
break; /* match */
}
newf1 = newf1->next;
} /* while newf1 */
if (newf1 == NULL) { /* no match */
newf1 = cuddDynamicAllocNode(table);
if (newf1 == NULL)
goto zddSwapOutOfMem;
newf1->index = yindex; newf1->ref = 1;
cuddT(newf1) = f01;
cuddE(newf1) = f10;
/* Insert newf1 in the collision list ylist[pos];
** increase the ref counts of f01 and f10
*/
newykeys++;
newf1->next = ylist[posn];
ylist[posn] = newf1;
cuddSatInc(f01->ref);
cuddSatInc(f10->ref);
}
}
cuddT(f) = newf1;
/* Do the same for f0. */
/* Create the new E child. */
if (f11 == empty) {
newf0 = f00;
cuddSatInc(newf0->ref);
} else {
/* Check ylist for triple (yindex, f11, f00). */
posn = ddHash(f11, f00, yshift);
/* For each element newf0 in collision list ylist[posn]. */
newf0 = ylist[posn];
while (newf0 != NULL) {
if (cuddT(newf0) == f11 && cuddE(newf0) == f00 &&
(int) newf0->index == yindex) {
cuddSatInc(newf0->ref);
break; /* match */
}
newf0 = newf0->next;
} /* while newf0 */
if (newf0 == NULL) { /* no match */
newf0 = cuddDynamicAllocNode(table);
if (newf0 == NULL)
goto zddSwapOutOfMem;
newf0->index = yindex; newf0->ref = 1;
cuddT(newf0) = f11; cuddE(newf0) = f00;
/* Insert newf0 in the collision list ylist[posn];
** increase the ref counts of f11 and f00.
*/
newykeys++;
newf0->next = ylist[posn];
ylist[posn] = newf0;
cuddSatInc(f11->ref);
cuddSatInc(f00->ref);
}
}
cuddE(f) = newf0;
/* Re-insert the modified f in xlist.
** The modified f does not already exists in xlist.
** (Because of the uniqueness of the cofactors.)
*/
posn = ddHash(newf1, newf0, xshift);
newxkeys++;
f->next = xlist[posn];
xlist[posn] = f;
f = next;
} /* while f != NULL */
/* GC the y layer and move the marked nodes to the x list. */
/* For each node f in ylist. */
for (i = 0; i < yslots; i++) {
previous = NULL;
f = ylist[i];
while (f != NULL) {
next = f->next;
if (f->ref == 0) {
cuddSatDec(cuddT(f)->ref);
cuddSatDec(cuddE(f)->ref);
cuddDeallocNode(table, f);
newykeys--;
if (previous == NULL)
ylist[i] = next;
else
previous->next = next;
} else if ((int) f->index == xindex) { /* move marked node */
if (previous == NULL)
ylist[i] = next;
else
previous->next = next;
f1 = cuddT(f);
cuddSatDec(f1->ref);
/* Check ylist for triple (yindex, f1, empty). */
posn = ddHash(f1, empty, yshift);
/* For each element newf1 in collision list ylist[posn]. */
newf1 = ylist[posn];
while (newf1 != NULL) {
if (cuddT(newf1) == f1 && cuddE(newf1) == empty &&
(int) newf1->index == yindex) {
cuddSatInc(newf1->ref);
break; /* match */
}
newf1 = newf1->next;
} /* while newf1 */
if (newf1 == NULL) { /* no match */
newf1 = cuddDynamicAllocNode(table);
if (newf1 == NULL)
goto zddSwapOutOfMem;
newf1->index = yindex; newf1->ref = 1;
cuddT(newf1) = f1; cuddE(newf1) = empty;
/* Insert newf1 in the collision list ylist[posn];
** increase the ref counts of f1 and empty.
*/
newykeys++;
newf1->next = ylist[posn];
ylist[posn] = newf1;
if (posn == i && previous == NULL)
previous = newf1;
cuddSatInc(f1->ref);
cuddSatInc(empty->ref);
}
cuddT(f) = newf1;
f0 = cuddE(f);
/* Insert f in x list. */
posn = ddHash(newf1, f0, xshift);
newxkeys++;
newykeys--;
f->next = xlist[posn];
xlist[posn] = f;
} else {
previous = f;
}
f = next;
} /* while f */
} /* for i */
/* Set the appropriate fields in table. */
table->subtableZ[x].keys = newxkeys;
table->subtableZ[y].keys = newykeys;
table->keysZ += newxkeys + newykeys - oldxkeys - oldykeys;
/* Update univ section; univ[x] remains the same. */
table->univ[y] = cuddT(table->univ[x]);
#if 0
(void) fprintf(table->out,"x = %d y = %d\n", x, y);
(void) Cudd_DebugCheck(table);
(void) Cudd_CheckKeys(table);
#endif
return (table->keysZ);
zddSwapOutOfMem:
(void) fprintf(table->err, "Error: cuddZddSwapInPlace out of memory\n");
return (0);
} /* end of cuddZddLinearInPlace */
int
Dddmp_cuddBddArrayStoreSmv (
DdManager *ddMgr /* IN: DD Manager */,
int nroots /* IN: number of output BDD roots to be stored */,
DdNode **f /* IN: array of BDD roots to be stored */,
char **inputNames /* IN: array of variable names (or NULL) */,
char **outputNames /* IN: array of root names (or NULL) */,
char *modelName /* IN: Model Name */,
char *fname /* IN: File name */,
FILE *fp /* IN: File pointer to the store file */
)
{
int retValue;
int fileToClose = 0;
#ifdef DDDMP_DEBUG
#ifndef __alpha__
int retValueBis;
retValueBis = Cudd_DebugCheck (ddMgr);
if (retValueBis == 1) {
fprintf (stderr, "Inconsistency Found During BDD Store.\n");
fflush (stderr);
} else {
if (retValueBis == CUDD_OUT_OF_MEM) {
fprintf (stderr, "Out of Memory During BDD Store.\n");
fflush (stderr);
}
}
#endif
#endif
/*
* Check if File needs to be opened in the proper mode.
*/
if (fp == NULL) {
fp = fopen (fname, "w");
Dddmp_CheckAndGotoLabel (fp==NULL, "Error opening file.",
failure);
fileToClose = 1;
}
retValue = DddmpCuddDdArrayStoreSmv (ddMgr, nroots, f,
inputNames, outputNames, modelName, fp);
if (fileToClose) {
fclose (fp);
}
#ifdef DDDMP_DEBUG
#ifndef __alpha__
retValueBis = Cudd_DebugCheck (ddMgr);
if (retValueBis == 1) {
fprintf (stderr, "Inconsistency Found During BDD Store.\n");
fflush (stderr);
} else {
if (retValueBis == CUDD_OUT_OF_MEM) {
fprintf (stderr, "Out of Memory During BDD Store.\n");
fflush (stderr);
}
}
#endif
#endif
return (retValue);
failure:
return (DDDMP_FAILURE);
}
/**Function********************************************************************
Synopsis [Applies reordering to the DDs.]
Description [Explicitly applies reordering to the DDs. Returns 1 if
successful; 0 otherwise.]
SideEffects [None]
SeeAlso []
*****************************************************************************/
static int
reorder(
BnetNetwork * net,
DdManager * dd /* DD Manager */,
NtrOptions * option)
{
#ifdef DD_DEBUG
st_table *mintermTable; /* minterm counts for each output */
#endif
int result; /* return value from functions */
(void) printf("Number of inputs = %d\n",net->ninputs);
/* Perform the final reordering */
if (option->reordering != CUDD_REORDER_NONE) {
#ifdef DD_DEBUG
result = Cudd_DebugCheck(dd);
if (result != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
return(0);
}
result = Cudd_CheckKeys(dd);
if (result != 0) {
(void) fprintf(stderr,"Error reported by Cudd_CheckKeys\n");
return(0);
}
mintermTable = checkMinterms(net,dd,NULL);
if (mintermTable == NULL) exit(2);
#endif
dd->siftMaxVar = 1000000;
dd->siftMaxSwap = 1000000000;
result = Cudd_ReduceHeap(dd,option->reordering,1);
if (result == 0) return(0);
#ifdef DD_DEBUG
result = Cudd_DebugCheck(dd);
if (result != 0) {
(void) fprintf(stderr,"Error reported by Cudd_DebugCheck\n");
return(0);
}
result = Cudd_CheckKeys(dd);
if (result != 0) {
(void) fprintf(stderr,"Error reported by Cudd_CheckKeys\n");
return(0);
}
mintermTable = checkMinterms(net,dd,mintermTable);
#endif
/* Print symmetry stats if pertinent */
if (dd->tree == NULL &&
(option->reordering == CUDD_REORDER_SYMM_SIFT ||
option->reordering == CUDD_REORDER_SYMM_SIFT_CONV))
Cudd_SymmProfile(dd,0,dd->size - 1);
}
if (option->gaOnOff) {
result = Cudd_ReduceHeap(dd,CUDD_REORDER_GENETIC,1);
if (result == 0) {
(void) printf("Something went wrong in cuddGa\n");
return(0);
}
}
return(1);
} /* end of reorder */