extra.h

主要进行大规模的电路综合

extern DdNode *    Extra_zddPrimeProduct ARGS((DdManager *dd, DdNode *f, DdNode *g));
extern DdNode *     extraZddPrimeProduct ARGS((DdManager *dd, DdNode *f, DdNode *g));
/* an alternative implementation of the cover product */
extern DdNode *    Extra_zddProductAlt ARGS((DdManager *dd, DdNode *f, DdNode *g));
extern DdNode *     extraZddProductAlt ARGS((DdManager *dd, DdNode *f, DdNode *g));
/* returns the set of cubes pair-wise unate with the given cube */
extern DdNode *    Extra_zddCompatible ARGS((DdManager * dd, DdNode * zCover, DdNode * zCube));
extern DdNode *     extraZddCompatible ARGS((DdManager * dd, DdNode * zCover, DdNode * zCube));
/* a wrapper for the call to Extra_zddIsop() */
extern DdNode *    Extra_zddIsopCover ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
/* a wrapper for the call to Extra_zddIsopCover() and Extra_zddPrintCover() */
extern void        Extra_zddIsopPrintCover ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
/* a simple cover computation (not ISOP) */
extern DdNode *    Extra_zddSimplify ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
extern DdNode *     extraZddSimplify ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
/* an alternative ISOP cover computation (faster than Extra_zddIsop()) */
extern DdNode *    Extra_zddIsopCoverAlt ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
extern DdNode *     extraZddIsopCoverAlt ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
/* count the number of cubes in the ISOP without building the ISOP as a ZDD */
extern int         Extra_zddIsopCubeNum ARGS((DdManager * dd, DdNode * F1, DdNode * F12));
extern DdNode *     extraZddIsopCubeNum ARGS((DdManager * dd, DdNode * F1, DdNode * F12, int * pnCubes));

/* computes the disjoint cube cover produced by the bdd paths */
extern DdNode *    Extra_zddDisjointCover ARGS((DdManager * dd, DdNode * F));
/* performs resolution on the set of clauses (S) w.r.t. variables in zdd Vars */
extern DdNode *    Extra_zddResolve ARGS((DdManager * dd, DdNode * S, DdNode * Vars));
/* cubes from zC that are not contained by cubes from zD over area bA */
extern DdNode *    Extra_zddNotContainedCubesOverArea ARGS((DdManager * dd, DdNode * zC, DdNode * zD, DdNode * bA));
extern DdNode *     extraZddNotContainedCubesOverArea ARGS((DdManager * dd, DdNode * zC, DdNode * zD, DdNode * bA));

/* finds cofactors of the cover w.r.t. the top-most variable without creating new nodes */
extern void         extraDecomposeCover ARGS((DdManager* dd, DdNode *C, DdNode **zC0, DdNode **zC1, DdNode **zC2 ));
/* composes the cover from the three subcovers using the given variable (returns NULL = reordering)*/
extern DdNode *     extraComposeCover ARGS((DdManager* dd, DdNode * zC0, DdNode * zC1, DdNode * zC2, int TopVar ));

/* selects one cube from a ZDD representing the cube cover */
extern DdNode *    Extra_zddSelectOneCube ARGS((DdManager * dd, DdNode * zS));
extern DdNode *     extraZddSelectOneCube ARGS((DdManager * dd, DdNode * zS));
/* selects one subset from a ZDD representing the set of subsets */
extern DdNode *    Extra_zddSelectOneSubset ARGS((DdManager * dd, DdNode * zS));
extern DdNode *     extraZddSelectOneSubset ARGS((DdManager * dd, DdNode * zS));

/* checks unateness of the cover */
extern int         Extra_zddCheckUnateness ARGS((DdManager * dd, DdNode * zCover));

/*=== extraZddMaxMin.c ==============================================================*/

/* maximal/minimimal */
extern DdNode *    Extra_zddMaximal ARGS((DdManager *dd, DdNode *S));
extern DdNode *     extraZddMaximal ARGS((DdManager *dd, DdNode *S));
extern DdNode *    Extra_zddMinimal ARGS((DdManager *dd, DdNode *S));
extern DdNode *     extraZddMinimal ARGS((DdManager *dd, DdNode *S));
/* maximal/minimal of the union of two sets of subsets */
extern DdNode *    Extra_zddMaxUnion ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddMaxUnion ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *    Extra_zddMinUnion ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddMinUnion ARGS((DdManager *dd, DdNode *S, DdNode *T));
/* dot/cross products */
extern DdNode *    Extra_zddDotProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddDotProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *    Extra_zddExorProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddExorProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *    Extra_zddCrossProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddCrossProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *    Extra_zddMaxDotProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));
extern DdNode *     extraZddMaxDotProduct ARGS((DdManager *dd, DdNode *S, DdNode *T));

/*=== extraZddMisc.c ==============================================================*/

/* create the combination composed of a single ZDD variable */
extern DdNode *    Extra_zddVariable ARGS((DdManager * dd, int iVar));
/* build a ZDD for a combination of variables */
extern DdNode *    Extra_zddCombination ARGS((DdManager *dd, int* VarValues, int nVars));
extern DdNode *     extraZddCombination ARGS((DdManager *dd, int *VarValues, int nVars ));
/* the set of all possible combinations of the given set of variables */
extern DdNode *    Extra_zddUniverse ARGS((DdManager * dd, DdNode * VarSet));
extern DdNode *     extraZddUniverse ARGS((DdManager * dd, DdNode * VarSet));
/* build the set of all tuples of K variables out of N */
extern DdNode *    Extra_zddTuples ARGS((DdManager * dd, int K, DdNode *zVarsN));
extern DdNode *     extraZddTuples ARGS((DdManager * dd, DdNode *zVarsK, DdNode *zVarsN));
/* build the set of all tuples of K variables out of N from the BDD cube */
extern DdNode *    Extra_zddTuplesFromBdd ARGS((DdManager * dd, int K, DdNode *bVarsN));
extern DdNode *     extraZddTuplesFromBdd ARGS((DdManager * dd, DdNode *bVarsK, DdNode *bVarsN));
/* convert the set of singleton combinations into one combination */
extern DdNode *    Extra_zddSinglesToComb ARGS((DdManager * dd, DdNode * Singles));
extern DdNode *     extraZddSinglesToComb ARGS(( DdManager * dd, DdNode * Singles ));
/* returns the set of combinations containing the max/min number of elements */
extern DdNode *    Extra_zddMaximum ARGS((DdManager * dd, DdNode * S, int * nVars));
extern DdNode *     extraZddMaximum ARGS((DdManager * dd, DdNode * S, int * nVars));
extern DdNode *    Extra_zddMinimum ARGS((DdManager * dd, DdNode * S, int * nVars));
extern DdNode *     extraZddMinimum ARGS((DdManager * dd, DdNode * S, int * nVars));
/* returns the random set of k combinations of n elements with average density d */
extern DdNode *    Extra_zddRandomSet ARGS((DdManager * dd, int n, int k, double d));

/*=== extraZddSubSup.c ==============================================================*/

/* subset/supset operations */
extern DdNode *    Extra_zddSubSet    ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *     extraZddSubSet    ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *    Extra_zddSupSet    ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *     extraZddSupSet    ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *    Extra_zddNotSubSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *     extraZddNotSubSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *    Extra_zddNotSupSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *     extraZddNotSupSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *    Extra_zddMaxNotSupSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
extern DdNode *     extraZddMaxNotSupSet ARGS((DdManager *dd, DdNode *X, DdNode *Y));
/* check whether the empty combination belongs to the set of subsets */
extern int         Extra_zddEmptyBelongs  ARGS((DdManager *dd, DdNode* zS ));
/* check whether the set consists of one subset only */
extern int         Extra_zddIsOneSubset ARGS((DdManager *dd, DdNode* zS ));

/*===========================================================================*/
/*     Various Utilities                                                     */
/*===========================================================================*/

/*=== extraUtilPrint.c =================================================================*/

enum { 
	EXTRA_GATE_TYPE_NONE, 
	EXTRA_GATE_TYPE_BUF, 
	EXTRA_GATE_TYPE_INV, 
	EXTRA_GATE_TYPE_AND, 
	EXTRA_GATE_TYPE_NAND, 
	EXTRA_GATE_TYPE_OR, 
	EXTRA_GATE_TYPE_NOR, 
	EXTRA_GATE_TYPE_EXOR, 
	EXTRA_GATE_TYPE_NEXOR,
	EXTRA_GATE_TYPE_CROSS 
};

extern FILE *      Extra_WriteBlifStart ARGS((char * FileName, char * pInputNames[], int nInputs, char * pOutputNames[], int nOutputs));
extern void        Extra_WriteBlifStop ARGS((FILE * pFile));

/* write the BDD/ZDD into as the boolean node in the BLIF file. */
extern void        Extra_WriteBlifNode ARGS((FILE * pFile, DdManager * dd, DdNode * Func, char * pInputNames[], char * pOutputName));
extern void        Extra_WriteBlifNodeUsingGates ARGS((FILE * pFile, DdManager * dd, DdNode * Func, char * pInputNames[], char * pOutputName, int fCascade));
extern void        Extra_WriteBlifGate ARGS((FILE * pFile, char * pInputNames[], int Polars[], int nInputs, char * pOutputName, int GateType));
extern void        Extra_WriteBlifGateCascade ARGS((FILE * pFile, char * pInputNames[], int Polars[], int nInputs, char * pOutputName, int GateType));

extern unsigned    Extra_ReadBinary ARGS((char * Buffer));
extern void        Extra_PrintBinary ARGS((FILE * pFile, unsigned Sign[], int nBits));
extern void        Extra_PrintSupport ARGS((DdManager * dd, DdNode * Func));
extern void        Extra_PrintSymbols ARGS((FILE * pFile, char Char, int nTimes, int fPrintNewLine));
extern void        Extra_DumpDot ARGS((DdManager * dd, DdNode * pFuncs[], int nFuncs, char * FileName, int fFlagZdd));
extern int         Extra_FileNameCheckExtension ARGS((char * FileName, char * Extension));
extern char *      Extra_FileNameAppend ARGS((char * pBase, char * pSuffix));
extern char *      Extra_FileNameGeneric ARGS((char * FileName));
extern void        Extra_StopManager ARGS((DdManager * dd));
extern int         Extra_Power3 ARGS((int Num));
extern int *       Extra_DeriveRadixCode ARGS((int Number, int Radix, int nDigits));

/*=== extraUtilMemory.c ========================================================*/

typedef struct mm_fixed_    mm_fixed;    // fixed-size-block memory manager (belongs to Extra)
typedef struct mm_flex_     mm_flex;     // flexible-size-block memory manager (belongs to Extra)

extern mm_fixed *  memManFixedStart( int nEntrySize, int nChunkSize, int nChunksAlloc );
extern void        memManFixedStop( mm_fixed * p, int fVerbose );
extern char *      memManFixedEntryFetch( mm_fixed * p );
extern void        memManFixedEntryRecycle( mm_fixed * p, char * pEntry );
extern void        memManFixedRestart( mm_fixed * p );
extern int         memManFixedReadMemUsage( mm_fixed * p );

extern mm_flex *   memManFlexStart( int nChunkSize, int nChunksAlloc );
extern void        memManFlexStop( mm_flex * p, int fVerbose );
extern char *      memManFlexEntryFetch( mm_flex * p, int nBytes );
extern int         memManFlexReadMemUsage( mm_flex * p );

/*=== extraUtilProgress.c ================================================================*/

typedef struct ProgressBarStruct ProgressBar;

extern ProgressBar * Extra_ProgressBarStart( FILE * pFile, int nItemsTotal );
extern void        Extra_ProgressBarUpdate( ProgressBar * p, int nItemsCur );
extern void        Extra_ProgressBarStop( ProgressBar * p );

/**AutomaticEnd***************************************************************/

#endif /* __EXTRA_H__ */