ACCExpr *cleanupBool(ACCExpr *expr)
{
if (!expr)
return expr;
inBool++; // can be invoked recursively!
walkReplaceBuiltin(expr);
inBool--;
int varIndex = 0;
VarMap varMap;
DdManager * mgr = Cudd_Init(MAX_NAME_COUNT,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
varIndex = 0;
varMap.clear();
DdNode *bdd = tree2BDD(mgr, expr, varMap);
char const *inames[MAX_NAME_COUNT];
for (auto item: varMap)
inames[item.second->index] = strdup(item.first.c_str());
char * fform = Cudd_FactoredFormString(mgr, bdd, inames);
Cudd_RecursiveDeref(mgr, bdd);
int err = Cudd_CheckZeroRef(mgr);
if (trace_bool)
printf("%s: expr '%s' val = %s\n", __FUNCTION__, tree2str(expr).c_str(), fform);
assert(err == 0 && "Reference counting");
ACCExpr *ret = str2tree(fform);
free(fform);
Cudd_Quit(mgr);
return ret;
}
static YAP_Bool init_test(void) {
YAP_Term arg1;
arg1 = YAP_ARG1;
nRules = YAP_IntOfTerm(arg1);
ex = 0;
mgr_ex = (DdManager **)malloc((ex + 1) * sizeof(DdManager *));
mgr_ex[ex] = Cudd_Init(0, 0, UNIQUE_SLOTS, CACHE_SLOTS, 5120);
Cudd_AutodynEnable(mgr_ex[ex], CUDD_REORDER_GROUP_SIFT);
Cudd_SetMaxCacheHard(mgr_ex[ex], 0);
Cudd_SetLooseUpTo(mgr_ex[ex], 0);
Cudd_SetMinHit(mgr_ex[ex], 15);
bVar2mVar_ex = (int **)malloc((ex + 1) * sizeof(int *));
bVar2mVar_ex[ex] = NULL;
vars_ex = (variable **)malloc((ex + 1) * sizeof(variable *));
vars_ex[ex] = NULL;
nVars_ex = (int *)malloc((ex + 1) * sizeof(int));
nVars_ex[ex] = 0;
probs_ex = (double **)malloc((ex + 1) * sizeof(double *));
probs_ex[ex] = NULL;
boolVars_ex = (int *)malloc((ex + 1) * sizeof(int));
boolVars_ex[ex] = 0;
rules = (int *)malloc(nRules * sizeof(int));
return 1;
}
/**Function*************************************************************
Synopsis [Converts the network from SOP to BDD representation.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Abc_NtkSopToBdd( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pNode;
DdManager * dd;
int nFaninsMax, i;
assert( Abc_NtkHasSop(pNtk) );
// start the functionality manager
nFaninsMax = Abc_NtkGetFaninMax( pNtk );
if ( nFaninsMax == 0 )
printf( "Warning: The network has only constant nodes.\n" );
dd = Cudd_Init( nFaninsMax, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
// convert each node from SOP to BDD
Abc_NtkForEachNode( pNtk, pNode, i )
{
assert( pNode->pData );
pNode->pData = Abc_ConvertSopToBdd( dd, pNode->pData );
if ( pNode->pData == NULL )
{
printf( "Abc_NtkSopToBdd: Error while converting SOP into BDD.\n" );
return 0;
}
Cudd_Ref( pNode->pData );
}
/***************************************************************************************************************************
Main Function( write all new functions in user.c only and call them in main.c)
Compile Command: make
Execution Command: ./proj2 "input file" "path file" "output file"
****************************************************************************************************************************/
int main(int argc, char **argv)
{
FILE *fisc, *path, *fout; //file pointers used for .isc file, .path file, and output file
int Max,Bound; //maxnode id,Max nodes in a bdd of cct
NODE *graph; //structure used to store the cct information in .isc file
//Read the .isc file and store the information in graph structure
fisc=fopen(argv[1],"r"); //file pointer to open .isc file
graph=(NODE *) malloc(Mnod * sizeof(NODE)); //dynamic memory allocation for graph structure
Max=0; Max=ReadIsc(fisc,graph); //read .isc file and return index of last node in graph formed
fclose(fisc); //close file pointer for .isc file
PrintCircuit(graph,Max); //print all members of graph structure
test (graph, Max, manager); //BDD user.c function declaration
manager=Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0); //intializing CUDD package manger
path=fopen(argv[2],"r"); //File pointer to open .path file
fout=fopen(argv[3],"w"); //File pointer to open .out file
printf("\nNo of Unreferenced Bdds %d\n", Cudd_CheckZeroRef(manager));
Cudd_Quit(manager); //closing the cudd package manager
ClearCircuit(graph,Mnod); //clear memeory for all members of graph
fclose(path); //close the path file
fclose(fout); //close the output file
return 0;
}//end of main
static YAP_Bool init_bdd(void) {
mgr_ex = (DdManager **)realloc(mgr_ex, (ex + 1) * sizeof(DdManager *));
mgr_ex[ex] = Cudd_Init(0, 0, UNIQUE_SLOTS, CACHE_SLOTS, 5120);
Cudd_AutodynEnable(mgr_ex[ex], CUDD_REORDER_GROUP_SIFT);
Cudd_SetMaxCacheHard(mgr_ex[ex], 0);
Cudd_SetLooseUpTo(mgr_ex[ex], 0);
Cudd_SetMinHit(mgr_ex[ex], 15);
bVar2mVar_ex = (int **)realloc(bVar2mVar_ex, (ex + 1) * sizeof(int *));
bVar2mVar_ex[ex] = NULL;
vars_ex = (variable **)realloc(vars_ex, (ex + 1) * sizeof(variable *));
vars_ex[ex] = NULL;
nVars_ex = (int *)realloc(nVars_ex, (ex + 1) * sizeof(int));
nVars_ex[ex] = 0;
probs_ex = (double **)realloc(probs_ex, (ex + 1) * sizeof(double *));
probs_ex[ex] = NULL;
boolVars_ex = (int *)realloc(boolVars_ex, (ex + 1) * sizeof(int));
boolVars_ex[ex] = 0;
return 1;
}
/**
* Creates a new BDDManager.
*
* @param maxMemoryInMB The amount of memory to be used. Must be <4096 as CUDD does not support more
* @param reorderingMaxBlowup The maximal allowed blowup during sifting steps in the reordering algorithm. Standard is 1.2 - use 1.1 to have less reordering done. A value of 1.0 results in greedy reordering.
* @author ehlers
*/
BFBddManager::BFBddManager(unsigned int maxMemoryInMB, float reorderingMaxBlowup) {
mgr = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, (long) maxMemoryInMB * 1024UL * 1024UL);
// Configuring the manager
Cudd_AutodynEnable(mgr, CUDD_REORDER_SIFT);
Cudd_SetMaxGrowth(mgr, reorderingMaxBlowup);
Cudd_SetMinHit(mgr, 1);
setAutomaticOptimisation(true);
}
/**
* @brief Basic test of Cudd_CountMinterm().
* @return 0 if successful; -1 otherwise.
*/
static int
testCount(int verbosity)
{
DdManager *dd;
DdNode *h;
int i, ret;
int const N = 2044; /* number of variables */
dd = Cudd_Init(N, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
if (!dd) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
/* Build a cube with N/2 variables. */
h = Cudd_ReadOne(dd);
Cudd_Ref(h);
for (i = 0; i < N; i += 2) {
DdNode *var, *tmp;
var = Cudd_bddIthVar(dd, N-i-1);
tmp = Cudd_bddAnd(dd, h, var);
if (!tmp) {
Cudd_Quit(dd);
return -1;
}
Cudd_Ref(tmp);
Cudd_RecursiveDeref(dd, h);
h = tmp;
}
if (verbosity) {
printf("h (dbl) ");
Cudd_PrintDebug(dd, h, N, 1);
printf("h (apa) ");
Cudd_PrintSummary(dd, h, N, 1);
}
Cudd_RecursiveDeref(dd, h);
if (verbosity) {
printf("one[%d] (dbl) ", N);
Cudd_PrintDebug(dd, Cudd_ReadOne(dd), N, 1);
printf("one[%d] (apa) ", N);
Cudd_PrintSummary(dd, Cudd_ReadOne(dd), N, 1);
ret = Cudd_CheckZeroRef(dd);
printf("one[%d] (dbl) ", N+1);
Cudd_PrintDebug(dd, Cudd_ReadOne(dd), N+1, 1);
printf("one[%d] (apa) ", N+1);
Cudd_PrintSummary(dd, Cudd_ReadOne(dd), N+1, 1);
ret = Cudd_CheckZeroRef(dd);
}
if (verbosity && ret != 0) {
printf("%d non-zero references\n", ret);
}
Cudd_Quit(dd);
return 0;
}
int main(int argc, char *argv[])
{
char *s1;
FILE *funfile;
FILE *statfile;
char *report;
if (argc != 2) {
printf("wrong # args\n");
return 1;
}
s1 = strdup(argv[1]);
funfile = fopen(s1,"r");
if (!funfile) {
printf("bddtraces-cmd: File error (%s)!\n",s1);
}
#ifdef USEBIDDY
Biddy_Init();
report = BddscoutRunBddTrace(funfile);
#endif
#ifdef USECUDD
manager = Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
report = BddscoutRunBddTrace(funfile);
#endif
printf("\nREPORT\n");
printf("%s\n",report);
fclose(funfile);
free(s1);
#ifdef USEBIDDY
statfile = fopen("statBIDDY.txt","w");
if (!statfile) {
printf("bddtraces-cmd: Stat file error!\n");
}
Biddy_PrintInfo(statfile);
fclose(statfile);
#endif
#ifdef USECUDD
statfile = fopen("statCUDD.txt","w");
if (!statfile) {
printf("bddtraces-cmd: Stat file error!\n");
}
Cudd_PrintInfo(manager,statfile);
fclose(statfile);
#endif
}
/**
* @brief Basic ADD test.
* @return 0 if successful; -1 otherwise.
*/
static int
testAdd(int verbosity)
{
DdManager *manager;
DdNode *f, *var, *tmp, *bg;
int i, ret;
CUDD_VALUE_TYPE pinf;
manager = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
if (!manager) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
pinf = Cudd_V(Cudd_ReadPlusInfinity(manager));
if (verbosity) {
printf("Plus infinity is %g\n", pinf);
}
f = Cudd_addConst(manager,5);
Cudd_Ref(f);
for (i = 3; i >= 0; i--) {
var = Cudd_addIthVar(manager,i);
Cudd_Ref(var);
tmp = Cudd_addApply(manager,Cudd_addTimes,var,f);
Cudd_Ref(tmp);
Cudd_RecursiveDeref(manager,f);
Cudd_RecursiveDeref(manager,var);
f = tmp;
}
if (verbosity) {
Cudd_PrintMinterm(manager, f);
printf("\n");
}
Cudd_RecursiveDeref(manager, f);
bg = Cudd_ReadBackground(manager);
if (verbosity) {
printf("background (%g) minterms : ", Cudd_V(bg));
Cudd_ApaPrintMinterm(Cudd_ReadStdout(manager), manager, bg, 0);
}
ret = Cudd_CheckZeroRef(manager);
if (ret != 0 && verbosity) {
printf("%d non-zero ADD reference counts after dereferencing\n", ret);
}
Cudd_Quit(manager);
return ret != 0;
}
/**Function********************************************************************
Synopsis [Starts the CUDD manager with the desired options.]
Description [Starts the CUDD manager with the desired options.
We start with 0 variables, because Ntr_buildDDs will create new
variables rather than using whatever already exists.]
SideEffects [None]
SeeAlso []
*****************************************************************************/
static DdManager *
startCudd(
NtrOptions * option,
int nvars)
{
DdManager *dd;
int result;
dd = Cudd_Init(0, 0, option->slots, option->cacheSize, option->maxMemory);
if (dd == NULL) return(NULL);
if (option->maxMemHard != 0) {
Cudd_SetMaxMemory(dd,option->maxMemHard);
}
Cudd_SetMaxLive(dd,option->maxLive);
Cudd_SetGroupcheck(dd,option->groupcheck);
if (option->autoDyn & 1) {
Cudd_AutodynEnable(dd,option->autoMethod);
}
dd->nextDyn = option->firstReorder;
dd->countDead = (option->countDead == FALSE) ? ~0 : 0;
dd->maxGrowth = 1.0 + ((float) option->maxGrowth / 100.0);
dd->recomb = option->recomb;
dd->arcviolation = option->arcviolation;
dd->symmviolation = option->symmviolation;
dd->populationSize = option->populationSize;
dd->numberXovers = option->numberXovers;
result = ntrReadTree(dd,option->treefile,nvars);
if (result == 0) {
Cudd_Quit(dd);
return(NULL);
}
#ifndef DD_STATS
result = Cudd_EnableReorderingReporting(dd);
if (result == 0) {
(void) fprintf(stderr,
"Error reported by Cudd_EnableReorderingReporting\n");
Cudd_Quit(dd);
return(NULL);
}
#endif
return(dd);
} /* end of startCudd */
void initc(int reorder)
{
int intBits;
nVars=0;
boolVars=0;
mgr=Cudd_Init(nVars,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
if (reorder != CUDD_REORDER_NONE)
Cudd_AutodynEnable(mgr,reorder);
vars= (variable *) malloc(nVars * sizeof(variable));
probs=(double *) malloc(0);
intBits=sizeof(unsigned int)*8;
dividend=-1;
/* dividend is a global variable used by my_hash
it is equal to an unsigned int with binary representation 11..1 */
}
/**Function*************************************************************
Synopsis [Reorders the DD using CUDD package.]
Description [Transfers the DD into a temporary manager in such a way
that the level correspondence is preserved. Reorders the manager
and transfers the DD back into the original manager using the topmost
levels of the manager, in such a way that the ordering of levels is
preserved. The resulting permutation is returned in the array
given by the user.]
SideEffects []
SeeAlso []
***********************************************************************/
DdNode * Extra_ReorderCudd( DdManager * dd, DdNode * aFunc, int pPermuteReo[] )
{
static DdManager * ddReorder = NULL;
static int * Permute = NULL;
static int * PermuteReo1 = NULL;
static int * PermuteReo2 = NULL;
DdNode * aFuncReorder, * aFuncNew;
int lev, var;
// start the reordering manager
if ( ddReorder == NULL )
{
Permute = ALLOC( int, dd->size );
PermuteReo1 = ALLOC( int, dd->size );
PermuteReo2 = ALLOC( int, dd->size );
ddReorder = Cudd_Init( dd->size, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
Cudd_AutodynDisable(ddReorder);
}
/**
* @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;
}
/**Function*************************************************************
Synopsis [Deriving the functionality of the gates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mio_LibraryParseFormulas( Mio_Library_t * pLib )
{
Mio_Gate_t * pGate;
// count the gates
pLib->nGates = 0;
Mio_LibraryForEachGate( pLib, pGate )
pLib->nGates++;
// start a temporary BDD manager
pLib->dd = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
// introduce ZDD variables
Cudd_zddVarsFromBddVars( pLib->dd, 2 );
// for each gate, derive its function
Mio_LibraryForEachGate( pLib, pGate )
if ( Mio_GateParseFormula( pGate ) )
return 1;
return 0;
}
/**Function*************************************************************
Synopsis [Recursively computes global BDDs for the AIG in the manager.]
Description [On exit, BDDs are stored in the pNode->pData fields.]
SideEffects []
SeeAlso []
***********************************************************************/
DdManager * Aig_ManComputeGlobalBdds( Aig_Man_t * p, int nBddSizeMax, int fDropInternal, int fReorder, int fVerbose )
{
ProgressBar * pProgress = NULL;
Aig_Obj_t * pObj;
DdManager * dd;
DdNode * bFunc;
int i, Counter;
// start the manager
dd = Cudd_Init( Aig_ManCiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
// set reordering
if ( fReorder )
Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
// prepare to construct global BDDs
Aig_ManCleanData( p );
// assign the constant node BDD
Aig_ObjSetGlobalBdd( Aig_ManConst1(p), dd->one ); Cudd_Ref( dd->one );
// set the elementary variables
Aig_ManForEachCi( p, pObj, i )
{
Aig_ObjSetGlobalBdd( pObj, dd->vars[i] ); Cudd_Ref( dd->vars[i] );
}
/**Function*************************************************************
Synopsis [Creates a new Ntk.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Ntk_t * Abc_NtkAlloc( Abc_NtkType_t Type, Abc_NtkFunc_t Func, int fUseMemMan )
{
Abc_Ntk_t * pNtk;
pNtk = ALLOC( Abc_Ntk_t, 1 );
memset( pNtk, 0, sizeof(Abc_Ntk_t) );
pNtk->ntkType = Type;
pNtk->ntkFunc = Func;
// start the object storage
pNtk->vObjs = Vec_PtrAlloc( 100 );
pNtk->vAsserts = Vec_PtrAlloc( 100 );
pNtk->vPios = Vec_PtrAlloc( 100 );
pNtk->vPis = Vec_PtrAlloc( 100 );
pNtk->vPos = Vec_PtrAlloc( 100 );
pNtk->vCis = Vec_PtrAlloc( 100 );
pNtk->vCos = Vec_PtrAlloc( 100 );
pNtk->vBoxes = Vec_PtrAlloc( 100 );
// start the memory managers
pNtk->pMmObj = fUseMemMan? Extra_MmFixedStart( sizeof(Abc_Obj_t) ) : NULL;
pNtk->pMmStep = fUseMemMan? Extra_MmStepStart( ABC_NUM_STEPS ) : NULL;
// get ready to assign the first Obj ID
pNtk->nTravIds = 1;
// start the functionality manager
if ( Abc_NtkIsStrash(pNtk) )
pNtk->pManFunc = Abc_AigAlloc( pNtk );
else if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
pNtk->pManFunc = Extra_MmFlexStart();
else if ( Abc_NtkHasBdd(pNtk) )
pNtk->pManFunc = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
else if ( Abc_NtkHasAig(pNtk) )
pNtk->pManFunc = Hop_ManStart();
else if ( Abc_NtkHasMapping(pNtk) )
pNtk->pManFunc = Abc_FrameReadLibGen();
else if ( !Abc_NtkHasBlackbox(pNtk) )
assert( 0 );
// name manager
pNtk->pManName = Nm_ManCreate( 200 );
// attribute manager
pNtk->vAttrs = Vec_PtrStart( VEC_ATTR_TOTAL_NUM );
return pNtk;
}
/**
* @brief Basic test of ZDDs.
* @return 0 if successful; -1 otherwise.
*/
static int
testZdd(int verbosity)
{
DdManager *manager;
DdNode *f, *var, *tmp;
int i, ret;
manager = Cudd_Init(0,4,CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS,0);
if (!manager) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
tmp = Cudd_ReadZddOne(manager,0);
Cudd_Ref(tmp);
for (i = 3; i >= 0; i--) {
var = Cudd_zddIthVar(manager,i);
Cudd_Ref(var);
f = Cudd_zddIntersect(manager,var,tmp);
Cudd_Ref(f);
Cudd_RecursiveDerefZdd(manager,tmp);
Cudd_RecursiveDerefZdd(manager,var);
tmp = f;
}
f = Cudd_zddDiff(manager,Cudd_ReadZddOne(manager,0),tmp);
Cudd_Ref(f);
Cudd_RecursiveDerefZdd(manager,tmp);
if (verbosity) {
Cudd_zddPrintMinterm(manager,f);
printf("\n");
}
Cudd_RecursiveDerefZdd(manager,f);
ret = Cudd_CheckZeroRef(manager);
if (ret != 0 && verbosity) {
printf("%d unexpected non-zero references\n", ret);
}
Cudd_Quit(manager);
return 0;
}
static DdManager *get_manager()
{
int i, l;
int lb, ub;
int tmp, next_var;
if (manager == NULL) {
l = env_size();
next_var = 0;
for (i = l; i; --i) {
env_name(i, &lb, &ub);
cudd_var_bits[i] = next_var;
tmp = ub-lb;
while (tmp) {
tmp >>= 1;
next_var += 2;
}
}
cudd_var_bits[0] = next_var;
manager = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_MvExperiment()
{
Mv_Man_t * p;
// get the functions
p = ALLOC( Mv_Man_t, 1 );
memset( p, 0, sizeof(Mv_Man_t) );
p->dd = Cudd_Init( 32, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
p->nFuncs = 15;
p->nInputs = 9;
Abc_MvRead( p );
// process the functions
Abc_MvPrintStats( p );
// Cudd_ReduceHeap( p->dd, CUDD_REORDER_SYMM_SIFT, 1 );
// Abc_MvPrintStats( p );
// try detecting support reducing bound set
Abc_MvDecompose( p );
// remove the manager
Abc_MvDeref( p );
Extra_StopManager( p->dd );
free( p );
}
BddBuilder::BddBuilder(){
__pddWireHead = __pddWireTail = NULL;
__pddOutputWireHead = __pddOutputWireTail = NULL;
__pddOutputNodes = NULL;
__pddGateHead = __pddGateTail = NULL;
__pddInputNodes = NULL;
__pddManager = Cudd_Init(0, 0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS , 0);
Cudd_ReduceHeap(__pddManager,CUDD_REORDER_RANDOM_PIVOT,0);
Cudd_AutodynEnable(__pddManager,CUDD_REORDER_RANDOM_PIVOT);
__Vcc = Cudd_ReadOne(__pddManager);
__GND = Cudd_ReadLogicZero(__pddManager);
char * name_vcc = new char[4];
char * name_gnd = new char[4];
sprintf(name_vcc, "Vcc");
sprintf(name_gnd, "GND");
__VccWire = new DdWire(__pddManager, name_vcc, 0, 0);
__GNDWire = new DdWire(__pddManager, name_gnd, 0, 0);
__VccWire->setDdNode(__Vcc);
__GNDWire->setDdNode(__GND);
Cudd_Ref(__Vcc);
Cudd_Ref(__GND);
if(__pddManager == NULL){
perror("DdManager initializing error.");
}
//__inputWireCnt = 2; // Vcc & GND
__inputWireCnt = -1;
__outputWireCnt = -1;
__pddInputWireHead = __VccWire;
__VccWire->setInputListNext(__GNDWire);
__pddInputWireTail = __GNDWire;
}
int main(void) {
DdManager *manager = Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
//DdNode *one = DD_ONE(manager);
//DdNode *zero = Cudd_Not(one);
//DdNode *tmp;
//DdNode *f;
int p1[] = {1,0,0,0};
// DdNode *v = getVar(manager,0,1);
DdNode *p = path(manager,p1,4);
printf("Is the new path an evaluation of the bdd? %d\n",Cudd_Eval(manager,p,p1) == DD_ONE(manager));
todot(manager,p,"tuple1000.dot");
printf("Paths to one in p: %f from a total of %f\n",
Cudd_CountPathsToNonZero(p),
Cudd_CountPath(p));
Cudd_RecursiveDeref(manager,p);
printf("This number should be zero: %d\n",Cudd_CheckZeroRef(manager));
return 0;
}
/**Function*************************************************************
Synopsis [Performs renoding as technology mapping.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Ntk_t * Abc_NtkRenode( Abc_Ntk_t * pNtk, int nFaninMax, int nCubeMax, int nFlowIters, int nAreaIters, int fArea, int fUseBdds, int fUseSops, int fUseCnfs, int fUseMv, int fVerbose )
{
extern Abc_Ntk_t * Abc_NtkIf( Abc_Ntk_t * pNtk, If_Par_t * pPars );
If_Par_t Pars, * pPars = &Pars;
Abc_Ntk_t * pNtkNew;
if ( Abc_NtkGetChoiceNum( pNtk ) )
printf( "Performing renoding with choices.\n" );
nDsdCounter = 0;
// set defaults
memset( pPars, 0, sizeof(If_Par_t) );
// user-controlable paramters
pPars->nLutSize = nFaninMax;
pPars->nCutsMax = nCubeMax;
pPars->nFlowIters = nFlowIters;
pPars->nAreaIters = nAreaIters;
pPars->DelayTarget = -1;
pPars->Epsilon = (float)0.005;
pPars->fPreprocess = 1;
pPars->fArea = fArea;
pPars->fFancy = 0;
pPars->fExpRed = 0; //
pPars->fLatchPaths = 0;
pPars->fVerbose = fVerbose;
// internal parameters
pPars->fTruth = 1;
pPars->fUsePerm = 1;
pPars->nLatchesCi = 0;
pPars->nLatchesCo = 0;
pPars->pLutLib = NULL; // Abc_FrameReadLibLut();
pPars->pTimesArr = NULL;
pPars->pTimesArr = NULL;
pPars->fUseBdds = fUseBdds;
pPars->fUseSops = fUseSops;
pPars->fUseCnfs = fUseCnfs;
pPars->fUseMv = fUseMv;
if ( fUseBdds )
pPars->pFuncCost = Abc_NtkRenodeEvalBdd;
else if ( fUseSops )
pPars->pFuncCost = Abc_NtkRenodeEvalSop;
else if ( fUseCnfs )
{
pPars->fArea = 1;
pPars->pFuncCost = Abc_NtkRenodeEvalCnf;
}
else if ( fUseMv )
pPars->pFuncCost = Abc_NtkRenodeEvalMv;
else
pPars->pFuncCost = Abc_NtkRenodeEvalAig;
// start the manager
if ( fUseBdds )
{
assert( s_pReo == NULL );
s_pDd = Cudd_Init( nFaninMax, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
s_pReo = Extra_ReorderInit( nFaninMax, 100 );
pPars->pReoMan = s_pReo;
}
else
{
assert( s_vMemory == NULL );
s_vMemory = Vec_IntAlloc( 1 << 16 );
s_vMemory2 = Vec_IntAlloc( 1 << 16 );
}
// perform mapping/renoding
pNtkNew = Abc_NtkIf( pNtk, pPars );
// start the manager
if ( fUseBdds )
{
Extra_StopManager( s_pDd );
Extra_ReorderQuit( s_pReo );
s_pReo = NULL;
s_pDd = NULL;
}
else
{
Vec_IntFree( s_vMemory );
Vec_IntFree( s_vMemory2 );
s_vMemory = NULL;
s_vMemory2 = NULL;
}
// printf( "Decomposed %d functions.\n", nDsdCounter );
return pNtkNew;
}
int main(int argc, char** argv) {
unsigned int i;
Biddy_Boolean complete;
Biddy_Edge tmp;
Biddy_Edge r1,r2;
unsigned int n1,n2;
char *userinput;
#ifdef USA_YES
unsigned int usaSize = 0;
unsigned int **usaEdge;
unsigned int *usaOrder;
char *usaCodes;
Biddy_Edge *usaState;
Biddy_Edge *usaGraph;
#endif
#ifdef EUROPE_YES
unsigned int europeSize = 0;
unsigned int **europeEdge;
unsigned int *europeOrder;
char *europeCodes;
Biddy_Edge *europeState;
Biddy_Edge *europeGraph;
#endif
setbuf(stdout, NULL);
#ifdef USA_YES
setDataUSA(&usaSize,&usaEdge,&usaOrder,&usaCodes);
#endif
#ifdef EUROPE_YES
setDataEurope(&europeSize,&europeEdge,&europeOrder,&europeCodes);
#endif
#ifdef USE_BIDDY
/* There is only one unique table in Biddy */
/* There are three caches in Biddy */
/* Unique table grows over the time */
/* The max number of variables is hardcoded in biddyInt. h */
/* biddyVariableTable.usaSize = BIDDYVARMAX = 2048 */
/* The following constants are hardcoded in biddyMain.c */
/* biddyIteCache.usaSize = MEDIUM_TABLE = 262143 */
/* biddyEACache.usaSize = SMALL_TABLE = 65535 */
/* biddyRCCache.usaSize = SMALL_TABLE = 65535 */
/* DEFAULT INIT CALL: Biddy_Init() */
Biddy_Init();
#endif
#ifdef USE_CUDD
/* In CUDD each variable has its own subtable in the unique table */
/* There is only one cache in CUDD */
/* Subtables grow over the time, you can set limit for fast unique table growth */
/* Cudd_SetLooseUpTo(manager,1048576) */
/* Cache can grow over the time, you can set the max usaSize */
/* Cudd_SetMaxCacheHard(manager,262144) */
/* These two constants are hardcoded in v3.0.0 */
/* CUDD_UNIQUE_SLOTS = 256 (default initial usaSize of each subtable) */
/* CUDD_CACHE_SLOTS = 262144 (default initial usaSize of cache table) */
/* DEFAULT INIT CALL: Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0) */
manager = Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
Cudd_SetMaxCacheHard(manager,262144);
#endif
#ifdef USA_YES
usaGraph = (Biddy_Edge *) malloc(usaSize*sizeof(Biddy_Edge *));
usaState = (Biddy_Edge *) malloc(usaSize*sizeof(Biddy_Edge *));
#endif
#ifdef EUROPE_YES
europeGraph = (Biddy_Edge *) malloc(europeSize*sizeof(Biddy_Edge *));
europeState = (Biddy_Edge *) malloc(europeSize*sizeof(Biddy_Edge *));
#endif
i = 0;
complete = FALSE;
while (!complete) {
complete = TRUE;
tmp = Biddy_AddVariable();
#ifdef USA_YES
if (i < usaSize) {
usaState[usaOrder[i]] = tmp;
}
complete = complete && (i >= (usaSize-1));
#endif
#ifdef EUROPE_YES
if (i < europeSize) {
europeState[europeOrder[i]] = tmp;
}
complete = complete && (i >= (europeSize-1));
#endif
i++;
}
#ifdef USA_YES
createGraph(usaSize,usaEdge,usaState,usaGraph);
#endif
#ifdef EUROPE_YES
createGraph(europeSize,europeEdge,europeState,europeGraph);
#endif
#ifdef USE_BIDDY
Biddy_Clean();
#endif
r1 = Biddy_GetConstantZero();
r2 = Biddy_GetConstantZero();
#ifdef USE_CUDD
Cudd_Ref(r1);
Cudd_Ref(r2);
#endif
#ifdef USA_YES
if (!CALCULATE_KERNELS) {
/* CALCULATING INDEPENDENCE SETS FOR USA */
#ifdef USE_CUDD
Cudd_RecursiveDeref(manager,r1);
#endif
r1 = calculateIndependence(usaSize,usaState,usaGraph);
} else {
/* CALCULATING KERNELS (MAXIMUM INDEPENDENCE SETS) FOR USA */
#ifdef USE_CUDD
Cudd_RecursiveDeref(manager,r1);
#endif
r1 = calculateKernels(usaSize,usaState,usaGraph);
}
#ifdef USE_BIDDY
Biddy_AddPersistentFormula((Biddy_String)"usa",r1);
Biddy_Clean();
#endif
#ifdef USE_CUDD
for (i=0; i<usaSize; i++) {
Cudd_RecursiveDeref(manager,usaGraph[i]);
}
#endif
#endif
#ifdef EUROPE_YES
if (!CALCULATE_KERNELS) {
/* CALCULATING INDEPENDENCE SETS FOR EUROPE */
#ifdef USE_CUDD
Cudd_RecursiveDeref(manager,r2);
#endif
r2 = calculateIndependence(europeSize,europeState,europeGraph);
} else {
/* CALCULATING KERNELS (MAXIMUM INDEPENDENCE SETS) FOR EUROPE */
#ifdef USE_CUDD
Cudd_RecursiveDeref(manager,r2);
#endif
r2 = calculateKernels(europeSize,europeState,europeGraph);
}
#ifdef USE_BIDDY
Biddy_AddPersistentFormula((Biddy_String)"europe",r2);
Biddy_Clean();
#endif
#ifdef USE_CUDD
for (i=0; i<europeSize; i++) {
Cudd_RecursiveDeref(manager,europeGraph[i]);
}
#endif
#endif
userinput = strdup("...");
while (userinput[0] != 'x') {
/* We have problems with passing stdout in the case you compile this file */
/* with MINGW and use biddy.dll generated with Visual Studio. */
/* In such cases, please, use Biddy_PrintInfo(NULL) */
if (userinput[0] == 'r') Biddy_PrintInfo(stdout);
/* SIFTING */
#ifdef USE_BIDDY
#ifdef CONVERGE
if (userinput[0] == 's') Biddy_PurgeAndReorder(NULL,TRUE);
#ifdef USA_YES
if (userinput[0] == 'u') Biddy_PurgeAndReorder(r1,TRUE);
#endif
#ifdef EUROPE_YES
if (userinput[0] == 'e') Biddy_PurgeAndReorder(r2,TRUE);
#endif
#else
if (userinput[0] == 's') Biddy_PurgeAndReorder(NULL,FALSE);
#ifdef USA_YES
if (userinput[0] == 'u') Biddy_PurgeAndReorder(r1,FALSE);
#endif
#ifdef EUROPE_YES
if (userinput[0] == 'e') Biddy_PurgeAndReorder(r2,FALSE);
#endif
#endif
#endif
#ifdef USE_CUDD
#ifdef CONVERGE
if (userinput[0] == 's') Cudd_ReduceHeap(manager,CUDD_REORDER_SIFT_CONVERGE,0);
#else
if (userinput[0] == 's') Cudd_ReduceHeap(manager,CUDD_REORDER_SIFT,0);
#endif
#endif
n1 = Biddy_VariableNumber(r1);
n2 = Biddy_VariableNumber(r2);
if ((userinput[0] == 's')
#ifdef USA_YES
|| (userinput[0] == 'u')
#endif
#ifdef EUROPE_YES
|| (userinput[0] == 'e')
#endif
) {
#ifdef CONVERGE
printf("(CONVERGING SIFTING");
#ifdef USE_BIDDY
if (userinput[0] == 'u') {
printf(" ON FUNCTION FOR USA");
}
if (userinput[0] == 'e') {
printf(" ON FUNCTION FOR EUROPE");
}
#endif
printf(") ");
#else
printf("(SIFTING");
#ifdef USE_BIDDY
if (userinput[0] == 'u') {
printf(" ON FUNCTION FOR USA");
}
if (userinput[0] == 'e') {
printf(" ON FUNCTION FOR EUROPE");
}
#endif
printf(") ");
#endif
}
printf("Resulting function r1/r2 depends on %u/%u variables.\n",n1,n2);
printf("Resulting function r1/r2 has %.0f/%.0f minterms.\n",Biddy_CountMinterm(r1,n1),Biddy_CountMinterm(r2,n2));
#ifdef USE_BIDDY
printf("BDD for resulting function r1/r2 has %u/%u nodes (%u/%u nodes if using complement edges).\n",
Biddy_NodeNumberPlain(r1),Biddy_NodeNumberPlain(r2),Biddy_NodeNumber(r1),Biddy_NodeNumber(r2));
#endif
#ifdef USE_CUDD
printf("BDD for resulting function r1/r2 has %u/%u nodes (using complement edges).\n",Biddy_NodeNumber(r1),Biddy_NodeNumber(r2));
#endif
#ifdef USE_BIDDY
printf("Variable swaps performed so far: %u\n",Biddy_NodeTableSwapNumber());
#endif
#ifdef USE_CUDD
printf("Variable swaps performed so far: %.0f\n",Cudd_ReadSwapSteps(manager));
#endif
#ifdef USA_YES
printf("Order for USA: ");
writeOrder(r1,usaCodes,usaOrder,usaSize);
#endif
#ifdef EUROPE_YES
printf("Order for Europe: ");
writeOrder(r2,europeCodes,europeOrder,europeSize);
#endif
#ifdef USE_BIDDY
printf("E[x]it or [r]eport or ");
#ifdef CONVERGE
printf("Converging sifting ");
#else
printf("Sifting ");
#endif
#if (defined USA_YES) || (defined EUROPE_YES)
printf("on [s]ystem or Sifting on function for");
#ifdef USA_YES
printf(" [u]SA");
#endif
#ifdef EUROPE_YES
printf(" [e]urope");
#endif
#endif
printf(": ");
if (!scanf("%s",userinput)) printf("ERROR\n");
#endif
#ifdef USE_CUDD
printf("E[x]it or [r]eport or ");
#ifdef CONVERGE
printf("Converging sifting ");
#else
printf("Sifting ");
#endif
printf("on [s]ystem: ");
if (!scanf("%s",userinput)) printf("ERROR\n");
#endif
}
free(userinput);
/* EXIT */
#ifdef USE_BIDDY
Biddy_Exit();
#endif
#ifdef USE_CUDD
Cudd_RecursiveDeref(manager,r1);
Cudd_RecursiveDeref(manager,r2);
printf("CUDD: nodes with non-zero reference counts: %d\n",Cudd_CheckZeroRef(manager));
Cudd_Quit(manager);
#endif
return 0;
}
/**
* @brief Basic test of long double and EPD minterm computation.
* @return 0 if successful; -1 otherwise.
*/
static int
testLdbl(int verbosity)
{
DdManager *dd;
DdNode *f, *g;
int i, ret;
int const N = 12; /* half the number of variables */
long double cnt;
dd = Cudd_Init(2*N, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
if (!dd) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
f = g = Cudd_ReadOne(dd);
Cudd_Ref(f);
Cudd_Ref(g);
for (i = 0; i < N; i++) {
DdNode *var1, *var2, *clause, *tmp;
var1 = Cudd_bddIthVar(dd, i);
var2 = Cudd_bddIthVar(dd, i+N);
clause = Cudd_bddOr(dd, var1, var2);
if (!clause) {
Cudd_Quit(dd);
return -1;
}
Cudd_Ref(clause);
tmp = Cudd_bddAnd(dd, f, clause);
if (!tmp) {
Cudd_Quit(dd);
return -1;
}
Cudd_Ref(tmp);
Cudd_RecursiveDeref(dd, clause);
Cudd_RecursiveDeref(dd, f);
f = tmp;
clause = Cudd_bddOr(dd, Cudd_Not(var1), Cudd_Not(var2));
if (!clause) {
Cudd_Quit(dd);
return -1;
}
Cudd_Ref(clause);
tmp = Cudd_bddAnd(dd, g, clause);
if (!tmp) {
Cudd_Quit(dd);
return -1;
}
Cudd_Ref(tmp);
Cudd_RecursiveDeref(dd, clause);
Cudd_RecursiveDeref(dd, g);
g = tmp;
}
if (verbosity) {
printf("f");
Cudd_PrintSummary(dd, f, 2*N, 0);
}
cnt = Cudd_LdblCountMinterm(dd, f, 2*N);
if (verbosity) {
printf("f has %Lg minterms\n", cnt);
}
if (verbosity) {
printf("EPD count for f = ");
ret = Cudd_EpdPrintMinterm(dd, f, 2*N);
printf("\n");
if (!ret) {
printf("problem with EPD\n");
}
}
Cudd_RecursiveDeref(dd, f);
if (verbosity) {
printf("g");
Cudd_PrintSummary(dd, g, 2*N, 0);
}
cnt = Cudd_LdblCountMinterm(dd, g, 2*N);
if (verbosity) {
printf("g has %Lg minterms\n", cnt);
}
if (verbosity) {
printf("EPD count for g = ");
ret = Cudd_EpdPrintMinterm(dd, g, 2*N);
printf("\n");
if (!ret) {
printf("problem with EPD\n");
}
}
Cudd_RecursiveDeref(dd, g);
ret = Cudd_CheckZeroRef(dd);
if (verbosity && ret != 0) {
printf("%d non-zero references\n", ret);
}
Cudd_Quit(dd);
return 0;
}
void * Abc_FrameReadManDd() { if ( s_GlobalFrame->dd == NULL ) s_GlobalFrame->dd = Cudd_Init( 0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 ); return s_GlobalFrame->dd; }
/**
* @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;
}
/**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 [Deriving the functionality of the gates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mio_GateParseFormula( Mio_Gate_t * pGate )
{
DdManager * dd = pGate->pLib->dd;
char * pPinNames[100];
char * pPinNamesCopy[100];
Mio_Pin_t * pPin, ** ppPin;
int nPins, iPin, i;
// set the maximum delay of the gate; count pins
pGate->dDelayMax = 0.0;
nPins = 0;
Mio_GateForEachPin( pGate, pPin )
{
// set the maximum delay of the gate
if ( pGate->dDelayMax < pPin->dDelayBlockMax )
pGate->dDelayMax = pPin->dDelayBlockMax;
// count the pin
nPins++;
}
// check for the gate with const function
if ( nPins == 0 )
{
if ( strcmp( pGate->pForm, MIO_STRING_CONST0 ) == 0 )
{
pGate->bFunc = b0;
pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 0\n" );
pGate->pLib->pGate0 = pGate;
}
else if ( strcmp( pGate->pForm, MIO_STRING_CONST1 ) == 0 )
{
pGate->bFunc = b1;
pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 1\n" );
pGate->pLib->pGate1 = pGate;
}
else
{
printf( "Cannot parse formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
return 1;
}
Cudd_Ref( pGate->bFunc );
return 0;
}
// collect the names as they appear in the formula
nPins = Mio_GateCollectNames( pGate->pForm, pPinNames );
if ( nPins == 0 )
{
printf( "Cannot read formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
return 1;
}
// set the number of inputs
pGate->nInputs = nPins;
// consider the case when all the pins have identical pin info
if ( strcmp( pGate->pPins->pName, "*" ) == 0 )
{
// get the topmost (generic) pin
pPin = pGate->pPins;
FREE( pPin->pName );
// create individual pins from the generic pin
ppPin = &pPin->pNext;
for ( i = 1; i < nPins; i++ )
{
// get the new pin
*ppPin = Mio_PinDup( pPin );
// set its name
(*ppPin)->pName = pPinNames[i];
// prepare the next place in the list
ppPin = &((*ppPin)->pNext);
}
*ppPin = NULL;
// set the name of the topmost pin
pPin->pName = pPinNames[0];
}
else
{
// reorder the variable names to appear the save way as the pins
iPin = 0;
Mio_GateForEachPin( pGate, pPin )
{
// find the pin with the name pPin->pName
for ( i = 0; i < nPins; i++ )
{
if ( pPinNames[i] && strcmp( pPinNames[i], pPin->pName ) == 0 )
{
// free pPinNames[i] because it is already available as pPin->pName
// setting pPinNames[i] to NULL is useful to make sure that
// this name is not assigned to two pins in the list
FREE( pPinNames[i] );
pPinNamesCopy[iPin++] = pPin->pName;
break;
}
if ( i == nPins )
{
printf( "Cannot find pin name \"%s\" in the formula \"%s\" of gate \"%s\".\n",
pPin->pName, pGate->pForm, pGate->pName );
return 1;
}
}
}
// check for the remaining names
for ( i = 0; i < nPins; i++ )
if ( pPinNames[i] )
{
printf( "Name \"%s\" appears in the formula \"%s\" of gate \"%s\" but there is no such pin.\n",
pPinNames[i], pGate->pForm, pGate->pName );
return 1;
}
// copy the names back
memcpy( pPinNames, pPinNamesCopy, nPins * sizeof(char *) );
}
// expand the manager if necessary
if ( dd->size < nPins )
{
Cudd_Quit( dd );
dd = Cudd_Init( nPins + 10, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
Cudd_zddVarsFromBddVars( dd, 2 );
}
// derive the formula as the BDD
pGate->bFunc = Parse_FormulaParser( stdout, pGate->pForm, nPins, 0, pPinNames, dd, dd->vars );
Cudd_Ref( pGate->bFunc );
// derive the cover (SOP)
pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, 0, pGate->pLib->vCube, -1 );
return 0;
}
static int compute_prob(void)
/* this is the function that implements the compute_prob predicate used in pp.pl
*/
{
YAP_Term out,arg1,arg2,arg3,arg4;
variables vars;
expr expression;
DdNode * function;
DdManager * mgr;
int nBVar,i,intBits,create_dot;
FILE * file;
DdNode * array[1];
double prob;
char * onames[1];
char inames[1000][20];
char * names[1000];
tablerow * nodes;
arg1=YAP_ARG1;
arg2=YAP_ARG2;
arg3=YAP_ARG3;
arg4=YAP_ARG4;
mgr=Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
create_dot=YAP_IntOfTerm(arg4);
vars=createVars(arg1,mgr,create_dot,inames);
//Cudd_PrintInfo(mgr,stderr);
/* automatic variable reordering, default method CUDD_REORDER_SIFT used */
//printf("status %d\n",Cudd_ReorderingStatus(mgr,&order));
//printf("order %d\n",order);
Cudd_AutodynEnable(mgr,CUDD_REORDER_SAME);
/* Cudd_AutodynEnable(mgr, CUDD_REORDER_RANDOM_PIVOT);
printf("status %d\n",Cudd_ReorderingStatus(mgr,&order));
printf("order %d\n",order);
printf("%d",CUDD_REORDER_RANDOM_PIVOT);
*/
expression=createExpression(arg2);
function=retFunction(mgr,expression,vars);
/* the BDD build by retFunction is converted to an ADD (algebraic decision diagram)
because it is easier to interpret and to print */
//add=Cudd_BddToAdd(mgr,function);
//Cudd_PrintInfo(mgr,stderr);
if (create_dot)
/* if specified by the user, a dot file for the BDD is written to cpl.dot */
{
nBVar=vars.nBVar;
for(i=0; i<nBVar; i++)
names[i]=inames[i];
array[0]=function;
onames[0]="Out";
file = open_file("cpl.dot", "w");
Cudd_DumpDot(mgr,1,array,names,onames,file);
fclose(file);
}
nodes=init_table(vars.nBVar);
intBits=sizeof(unsigned int)*8;
prob=Prob(function,vars,nodes);
out=YAP_MkFloatTerm(prob);
destroy_table(nodes,vars.nBVar);
Cudd_Quit(mgr);
for(i=0; i<vars.nVar; i++)
{
free(vars.varar[i].probabilities);
free(vars.varar[i].booleanVars);
}
free(vars.varar);
free(vars.bVar2mVar);
for(i=0; i<expression.nTerms; i++)
{
free(expression.terms[i].factors);
}
free(expression.terms);
return(YAP_Unify(out,arg3));
}
int main( int argc, char **argv )
{
FILE *fp;
FILE *stdin_backup = NULL;
bool help_flag = False;
bool ptdump_flag = False;
bool logging_flag = False;
unsigned char verbose = 0;
int input_index = -1;
int output_file_index = -1; /* For command-line flag "-o". */
char dumpfilename[64];
int i, j, var_index;
ptree_t *tmppt; /* General purpose temporary ptree pointer */
int horizon = -1;
DdNode *W, *etrans, *strans, **sgoals, **egoals;
DdManager *manager;
DdNode *T = NULL;
anode_t *strategy = NULL;
int num_env, num_sys;
int original_num_env, original_num_sys;
int max_sim_it; /* Number of simulation iterations */
anode_t *play;
vartype *init_state;
int *init_state_ints = NULL;
char *all_vars = NULL, *metric_vars = NULL;
int *offw, num_vars;
int init_state_acc; /* Accumulate components of initial state
before expanding into a (bool) bitvector. */
/* Look for flags in command-line arguments. */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
if (argv[i][1] == 'h') {
help_flag = True;
} else if (argv[i][1] == 'V') {
printf( "grjit (experiment-related program, distributed with"
" gr1c v" GR1C_VERSION ")\n\n" GR1C_COPYRIGHT "\n" );
return 0;
} else if (argv[i][1] == 'v') {
verbose = 1;
j = 2;
/* Only support up to "level 2" of verbosity */
while (argv[i][j] == 'v' && j <= 2) {
verbose++;
j++;
}
} else if (argv[i][1] == 'l') {
logging_flag = True;
} else if (argv[i][1] == 'p') {
ptdump_flag = True;
} else if (argv[i][1] == 'm') {
if (i == argc-1) {
fprintf( stderr, "Invalid flag given. Try \"-h\".\n" );
return 1;
}
all_vars = strtok( argv[i+1], "," );
max_sim_it = strtol( all_vars, NULL, 10 );
all_vars = strtok( NULL, "," );
if (all_vars == NULL) {
fprintf( stderr, "Invalid use of -m flag.\n" );
return 1;
}
metric_vars = strdup( all_vars );
if (max_sim_it >= 0) {
all_vars = strtok( NULL, "," );
if (all_vars == NULL) {
fprintf( stderr, "Invalid use of -m flag.\n" );
return 1;
}
init_state_acc = read_state_str( all_vars,
&init_state_ints, -1 );
all_vars = strtok( NULL, "," );
if (all_vars == NULL) {
horizon = -1; /* The horizon was not given. */
} else {
horizon = strtol( all_vars, NULL, 10 );
if (horizon < 1) {
fprintf( stderr,
"Invalid use of -m flag. Horizon must"
" be positive.\n" );
return 1;
}
}
}
all_vars = NULL;
i++;
} else if (argv[i][1] == 'o') {
if (i == argc-1) {
fprintf( stderr, "Invalid flag given. Try \"-h\".\n" );
return 1;
}
output_file_index = i+1;
i++;
} else {
fprintf( stderr, "Invalid flag given. Try \"-h\".\n" );
return 1;
}
} else if (input_index < 0) {
/* Use first non-flag argument as filename whence to read
specification. */
input_index = i;
}
}
if (help_flag) {
/* Split among printf() calls to conform with ISO C90 string length */
printf( "Usage: %s [-hVvlp] [-m ARG1,ARG2,...] [-o FILE] [FILE]\n\n"
" -h this help message\n"
" -V print version and exit\n"
" -v be verbose; use -vv to be more verbose\n"
" -l enable logging\n"
" -p dump parse trees to DOT files, and echo formulas to screen\n"
" -o FILE output results to FILE, rather than stdout (default)\n", argv[0] );
printf( " -m ARG1,... run simulation using comma-separated list of arguments:\n"
" ARG1 is the max simulation duration; -1 to only compute horizon;\n"
" ARG2 is a space-separated list of metric variables;\n"
" ARG3 is a space-separated list of initial values;\n"
" ARG3 is ignored and may be omitted if ARG1 equals -1.\n"
" ARG4 is the horizon, if provided; otherwise compute it.\n" );
return 1;
}
if (logging_flag) {
openlogfile( NULL ); /* Use default filename prefix */
/* Only change verbosity level if user did not specify it */
if (verbose == 0)
verbose = 1;
} else {
setlogstream( stdout );
setlogopt( LOGOPT_NOTIME );
}
if (verbose > 0)
logprint( "Running with verbosity level %d.", verbose );
/* If filename for specification given at command-line, then use
it. Else, read from stdin. */
if (input_index > 0) {
fp = fopen( argv[input_index], "r" );
if (fp == NULL) {
perror( "grjit, fopen" );
return -1;
}
stdin_backup = stdin;
stdin = fp;
}
/* Parse the specification. */
if (verbose)
logprint( "Parsing input..." );
SPC_INIT( spc );
if (yyparse())
return -1;
if (verbose)
logprint( "Done." );
if (stdin_backup != NULL) {
stdin = stdin_backup;
}
/* Close input file, if opened. */
if (input_index > 0)
fclose( fp );
/* Treat deterministic problem in which ETRANS or EINIT is omitted. */
if (spc.evar_list == NULL) {
if (spc.et_array_len == 0) {
spc.et_array_len = 1;
spc.env_trans_array = malloc( sizeof(ptree_t *) );
if (spc.env_trans_array == NULL) {
perror( "gr1c, malloc" );
return -1;
}
*spc.env_trans_array = init_ptree( PT_CONSTANT, NULL, 1 );
}
if (spc.env_init == NULL)
spc.env_init = init_ptree( PT_CONSTANT, NULL, 1 );
}
/* Number of variables, before expansion of those that are nonboolean */
original_num_env = tree_size( spc.evar_list );
original_num_sys = tree_size( spc.svar_list );
/* Build list of variable names if needed for simulation, storing
the result as a string in all_vars */
if (max_sim_it >= 0) {
/* At this point, init_state_acc should contain the number of
integers read by read_state_str() during
command-line argument parsing. */
if (init_state_acc != original_num_env+original_num_sys) {
fprintf( stderr,
"Number of initial values given does not match number"
" of problem variables.\n" );
return 1;
}
num_vars = 0;
tmppt = spc.evar_list;
while (tmppt) {
num_vars += strlen( tmppt->name )+1;
tmppt = tmppt->left;
}
tmppt = spc.svar_list;
while (tmppt) {
num_vars += strlen( tmppt->name )+1;
tmppt = tmppt->left;
}
all_vars = malloc( num_vars*sizeof(char) );
if (all_vars == NULL) {
perror( "main, malloc" );
return -1;
}
i = 0;
tmppt = spc.evar_list;
while (tmppt) {
strncpy( all_vars+i, tmppt->name, num_vars-i );
i += strlen( tmppt->name )+1;
*(all_vars+i-1) = ' ';
tmppt = tmppt->left;
}
tmppt = spc.svar_list;
while (tmppt) {
strncpy( all_vars+i, tmppt->name, num_vars-i );
i += strlen( tmppt->name )+1;
*(all_vars+i-1) = ' ';
tmppt = tmppt->left;
}
*(all_vars+i-1) = '\0';
if (verbose)
logprint( "String of all variables found to be \"%s\"", all_vars );
}
if (ptdump_flag) {
tree_dot_dump( spc.env_init, "env_init_ptree.dot" );
tree_dot_dump( spc.sys_init, "sys_init_ptree.dot" );
for (i = 0; i < spc.et_array_len; i++) {
snprintf( dumpfilename, sizeof(dumpfilename),
"env_trans%05d_ptree.dot", i );
tree_dot_dump( *(spc.env_trans_array+i), dumpfilename );
}
for (i = 0; i < spc.st_array_len; i++) {
snprintf( dumpfilename, sizeof(dumpfilename),
"sys_trans%05d_ptree.dot", i );
tree_dot_dump( *(spc.sys_trans_array+i), dumpfilename );
}
if (spc.num_egoals > 0) {
for (i = 0; i < spc.num_egoals; i++) {
snprintf( dumpfilename, sizeof(dumpfilename),
"env_goal%05d_ptree.dot", i );
tree_dot_dump( *(spc.env_goals+i), dumpfilename );
}
}
if (spc.num_sgoals > 0) {
for (i = 0; i < spc.num_sgoals; i++) {
snprintf( dumpfilename, sizeof(dumpfilename),
"sys_goal%05d_ptree.dot", i );
tree_dot_dump( *(spc.sys_goals+i), dumpfilename );
}
}
var_index = 0;
printf( "Environment variables (indices; domains): " );
if (spc.evar_list == NULL) {
printf( "(none)" );
} else {
tmppt = spc.evar_list;
while (tmppt) {
if (tmppt->value == 0) { /* Boolean */
if (tmppt->left == NULL) {
printf( "%s (%d; bool)", tmppt->name, var_index );
} else {
printf( "%s (%d; bool), ", tmppt->name, var_index);
}
} else {
if (tmppt->left == NULL) {
printf( "%s (%d; {0..%d})",
tmppt->name, var_index, tmppt->value );
} else {
printf( "%s (%d; {0..%d}), ",
tmppt->name, var_index, tmppt->value );
}
}
tmppt = tmppt->left;
var_index++;
}
}
printf( "\n\n" );
printf( "System variables (indices; domains): " );
if (spc.svar_list == NULL) {
printf( "(none)" );
} else {
tmppt = spc.svar_list;
while (tmppt) {
if (tmppt->value == 0) { /* Boolean */
if (tmppt->left == NULL) {
printf( "%s (%d; bool)", tmppt->name, var_index );
} else {
printf( "%s (%d; bool), ", tmppt->name, var_index );
}
} else {
if (tmppt->left == NULL) {
printf( "%s (%d; {0..%d})",
tmppt->name, var_index, tmppt->value );
} else {
printf( "%s (%d; {0..%d}), ",
tmppt->name, var_index, tmppt->value );
}
}
tmppt = tmppt->left;
var_index++;
}
}
printf( "\n\n" );
print_GR1_spec( spc.evar_list, spc.svar_list, spc.env_init, spc.sys_init,
spc.env_trans_array, spc.et_array_len,
spc.sys_trans_array, spc.st_array_len,
spc.env_goals, spc.num_egoals, spc.sys_goals, spc.num_sgoals, stdout );
}
if (expand_nonbool_GR1( spc.evar_list, spc.svar_list, &spc.env_init, &spc.sys_init,
&spc.env_trans_array, &spc.et_array_len,
&spc.sys_trans_array, &spc.st_array_len,
&spc.env_goals, spc.num_egoals, &spc.sys_goals, spc.num_sgoals,
verbose ) < 0)
return -1;
spc.nonbool_var_list = expand_nonbool_variables( &spc.evar_list, &spc.svar_list,
verbose );
if (spc.et_array_len > 1) {
spc.env_trans = merge_ptrees( spc.env_trans_array, spc.et_array_len, PT_AND );
} else if (spc.et_array_len == 1) {
spc.env_trans = *spc.env_trans_array;
} else {
fprintf( stderr,
"Syntax error: GR(1) specification is missing environment"
" transition rules.\n" );
return -1;
}
if (spc.st_array_len > 1) {
spc.sys_trans = merge_ptrees( spc.sys_trans_array, spc.st_array_len, PT_AND );
} else if (spc.st_array_len == 1) {
spc.sys_trans = *spc.sys_trans_array;
} else {
fprintf( stderr,
"Syntax error: GR(1) specification is missing system"
" transition rules.\n" );
return -1;
}
if (verbose > 1)
/* Dump the spec to show results of conversion (if any). */
print_GR1_spec( spc.evar_list, spc.svar_list, spc.env_init, spc.sys_init,
spc.env_trans_array, spc.et_array_len,
spc.sys_trans_array, spc.st_array_len,
spc.env_goals, spc.num_egoals, spc.sys_goals, spc.num_sgoals, NULL );
num_env = tree_size( spc.evar_list );
num_sys = tree_size( spc.svar_list );
manager = Cudd_Init( 2*(num_env+num_sys),
0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
Cudd_SetMaxCacheHard( manager, (unsigned int)-1 );
Cudd_AutodynEnable( manager, CUDD_REORDER_SAME );
T = check_realizable( manager, EXIST_SYS_INIT, verbose );
if (verbose) {
if (T != NULL) {
logprint( "Realizable." );
} else {
logprint( "Not realizable." );
}
}
if (T != NULL) { /* Print measure data and simulate. */
if (horizon < 0) {
if (verbose)
logprint( "Computing horizon with metric variables: %s",
metric_vars );
horizon = compute_horizon( manager, &W, &etrans, &strans, &sgoals,
metric_vars, verbose );
logprint( "horizon: %d", horizon );
if (getlogstream() != stdout)
printf( "horizon: %d\n", horizon );
} else {
W = compute_winning_set_saveBDDs( manager, &etrans, &strans,
&egoals, &sgoals, verbose );
if (verbose)
logprint( "Using given horizon: %d", horizon );
}
if (max_sim_it >= 0 && horizon > -1) {
/* Compute variable offsets and use it to get the initial
state as a bitvector */
offw = get_offsets( all_vars, &num_vars );
if (num_vars != original_num_env+original_num_sys) {
fprintf( stderr,
"Error while computing bitwise variable offsets.\n" );
return -1;
}
free( all_vars );
init_state_acc = 0;
if (verbose) {
logprint_startline();
logprint_raw( "initial state for simulation:" );
}
for (i = 0; i < original_num_env+original_num_sys; i++) {
if (verbose)
logprint_raw( " %d", *(init_state_ints+i) );
init_state_acc += *(init_state_ints+i) << *(offw + 2*i);
}
if (verbose)
logprint_endline();
free( offw );
init_state = int_to_bitvec( init_state_acc, num_env+num_sys );
if (init_state == NULL)
return -1;
play = sim_rhc( manager, W, etrans, strans, sgoals, metric_vars,
horizon, init_state, max_sim_it, verbose );
if (play == NULL) {
fprintf( stderr,
"Error while attempting receding horizon"
" simulation.\n" );
return -1;
}
free( init_state );
logprint( "play length: %d", aut_size( play ) );
tmppt = spc.nonbool_var_list;
while (tmppt) {
aut_compact_nonbool( play, spc.evar_list, spc.svar_list,
tmppt->name, tmppt->value );
tmppt = tmppt->left;
}
num_env = tree_size( spc.evar_list );
num_sys = tree_size( spc.svar_list );
/* Open output file if specified; else point to stdout. */
if (output_file_index >= 0) {
fp = fopen( argv[output_file_index], "w" );
if (fp == NULL) {
perror( "grjit, fopen" );
return -1;
}
} else {
fp = stdout;
}
/* Print simulation trace */
dump_simtrace( play, spc.evar_list, spc.svar_list, fp );
if (fp != stdout)
fclose( fp );
}
Cudd_RecursiveDeref( manager, W );
Cudd_RecursiveDeref( manager, etrans );
Cudd_RecursiveDeref( manager, strans );
}
/* Clean-up */
free( metric_vars );
delete_tree( spc.evar_list );
delete_tree( spc.svar_list );
delete_tree( spc.env_init );
delete_tree( spc.sys_init );
delete_tree( spc.env_trans );
delete_tree( spc.sys_trans );
for (i = 0; i < spc.num_egoals; i++)
delete_tree( *(spc.env_goals+i) );
if (spc.num_egoals > 0)
free( spc.env_goals );
for (i = 0; i < spc.num_sgoals; i++)
delete_tree( *(spc.sys_goals+i) );
if (spc.num_sgoals > 0)
free( spc.sys_goals );
if (T != NULL)
Cudd_RecursiveDeref( manager, T );
if (strategy)
delete_aut( strategy );
if (verbose > 1)
logprint( "Cudd_CheckZeroRef -> %d", Cudd_CheckZeroRef( manager ) );
Cudd_Quit(manager);
if (logging_flag)
closelogfile();
/* Return 0 if realizable, -1 if not realizable. */
if (T != NULL) {
return 0;
} else {
return -1;
}
return 0;
}
