void ToCNFAIG::toCNF(const BBNodeAIG& top, Cnf_Dat_t*& cnfData,
ToSATBase::ASTNodeToSATVar& nodeToVar,
bool needAbsRef, BBNodeManagerAIG& mgr) {
assert(cnfData == NULL);
Aig_ObjCreatePo(mgr.aigMgr, top.n);
if (!needAbsRef) {
Aig_ManCleanup( mgr.aigMgr); // remove nodes not connected to the PO.
}
Aig_ManCheck( mgr.aigMgr); // check that AIG looks ok.
assert(Aig_ManPoNum(mgr.aigMgr) == 1);
// UseZeroes gives assertion errors.
// Rewriting is sometimes very slow. Can it be configured to be faster?
// What about refactoring???
int nodeCount = mgr.aigMgr->nObjs[AIG_OBJ_AND];
if (uf.stats_flag)
cerr << "Nodes before AIG rewrite:" << nodeCount << endl;
if (!needAbsRef && uf.isSet("aig-rewrite","0")) {
Dar_LibStart();
Aig_Man_t * pTemp;
Dar_RwrPar_t Pars, *pPars = &Pars;
Dar_ManDefaultRwrParams(pPars);
// Assertion errors occur with this enabled.
// pPars->fUseZeros = 1;
// For mul63bit.smt2 with iterations =3 & nCutsMax = 8
// CNF generation was taking 139 seconds, solving 10 seconds.
// With nCutsMax =2, CNF generation takes 16 seconds, solving 10 seconds.
// The rewriting doesn't remove as many nodes of course..
int iterations = 3;
for (int i = 0; i < iterations; i++) {
mgr.aigMgr = Aig_ManDup(pTemp = mgr.aigMgr, 0);
Aig_ManStop(pTemp);
Dar_ManRewrite(mgr.aigMgr, pPars);
mgr.aigMgr = Aig_ManDup(pTemp = mgr.aigMgr, 0);
Aig_ManStop(pTemp);
if (uf.stats_flag)
cerr << "After rewrite [" << i << "] nodes:"
<< mgr.aigMgr->nObjs[AIG_OBJ_AND] << endl;
if (nodeCount == mgr.aigMgr->nObjs[AIG_OBJ_AND])
break;
}
}
if (!uf.isSet("simple-cnf","0")) {
cnfData = Cnf_Derive(mgr.aigMgr, 0);
if (uf.stats_flag)
cerr << "advanced CNF" << endl;
} else {
cnfData = Cnf_DeriveSimple(mgr.aigMgr, 0);
if (uf.stats_flag)
cerr << "simple CNF" << endl;
}
BBNodeManagerAIG::SymbolToBBNode::const_iterator it;
assert(nodeToVar.size() == 0);
//todo. cf. with addvariables above...
// Each symbol maps to a vector of CNF variables.
for (it = mgr.symbolToBBNode.begin(); it != mgr.symbolToBBNode.end(); it++) {
const ASTNode& n = it->first;
const vector<BBNodeAIG> &b = it->second;
assert(nodeToVar.find(n) == nodeToVar.end());
const int width = (n.GetType() == BOOLEAN_TYPE) ? 1 : n.GetValueWidth();
// INT_MAX for parts of symbols that didn't get encoded.
vector<unsigned> v(width, ~((unsigned) 0));
for (unsigned i = 0; i < b.size(); i++) {
if (!b[i].IsNull()) {
Aig_Obj_t * pObj;
pObj = (Aig_Obj_t*) Vec_PtrEntry(mgr.aigMgr->vPis,
b[i].symbol_index);
v[i] = cnfData->pVarNums[pObj->Id];
}
}
nodeToVar.insert(make_pair(n, v));
}
assert(cnfData != NULL);
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [The main() procedure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int main( int argc, char * argv[] )
{
int fEnableBmcOnly = 0; // enable to make it BMC-only
int fEnableCounter = 1; // should be 1 in the final version
int fEnableComment = 0; // should be 0 in the final version
Fra_Sec_t SecPar, * pSecPar = &SecPar;
FILE * pFile;
Aig_Man_t * pAig;
int RetValue = -1;
int Depth = -1;
// BMC parameters
int nFrames = 50;
int nSizeMax = 500000;
int nBTLimit = 10000;
int fRewrite = 0;
int fNewAlgo = 1;
int fVerbose = 0;
clock_t clkTotal = clock();
if ( argc != 2 )
{
printf( " Expecting one command-line argument (an input file in AIGER format).\n" );
printf( " usage: %s <file.aig>\n", argv[0] );
return 0;
}
pFile = fopen( argv[1], "r" );
if ( pFile == NULL )
{
printf( " Cannot open input AIGER file \"%s\".\n", argv[1] );
printf( " usage: %s <file.aig>\n", argv[0] );
return 0;
}
fclose( pFile );
pAig = Ioa_ReadAiger( argv[1], 1 );
if ( pAig == NULL )
{
printf( " Parsing the AIGER file \"%s\" has failed.\n", argv[1] );
printf( " usage: %s <file.aig>\n", argv[0] );
return 0;
}
Aig_ManSetRegNum( pAig, pAig->nRegs );
if ( !fEnableBmcOnly )
{
// perform BMC
if ( pAig->nRegs != 0 )
RetValue = Saig_ManBmcSimple( pAig, nFrames, nSizeMax, nBTLimit, fRewrite, fVerbose, NULL, 0 );
// perform full-blown SEC
if ( RetValue != 0 )
{
extern void Dar_LibStart();
extern void Dar_LibStop();
extern void Cnf_ManFree();
Fra_SecSetDefaultParams( pSecPar );
pSecPar->TimeLimit = 600;
pSecPar->nFramesMax = 4; // the max number of frames used for induction
pSecPar->fPhaseAbstract = 0; // disable phase-abstraction
pSecPar->fSilent = 1; // disable phase-abstraction
Dar_LibStart();
RetValue = Fra_FraigSec( pAig, pSecPar, NULL );
Dar_LibStop();
Cnf_ManFree();
}
}
// perform BMC again
if ( RetValue == -1 && pAig->nRegs != 0 )
{
int nFrames = 200;
int nSizeMax = 500000;
int nBTLimit = 10000000;
int fRewrite = 0;
RetValue = Saig_ManBmcSimple( pAig, nFrames, nSizeMax, nBTLimit, fRewrite, fVerbose, &Depth, 0 );
if ( RetValue != 0 )
RetValue = -1;
}
// decide how to report the output
pFile = stdout;
// report the result
if ( RetValue == 0 )
{
// fprintf(stdout, "s SATIFIABLE\n");
fprintf( pFile, "1" );
if ( fEnableCounter )
{
printf( "\n" );
if ( pAig->pSeqModel )
Fra_SmlWriteCounterExample( pFile, pAig, pAig->pSeqModel );
}
if ( fEnableComment )
{
printf( " # File %10s. ", argv[1] );
PRT( "Time", clock() - clkTotal );
}
if ( pFile != stdout )
fclose(pFile);
Aig_ManStop( pAig );
exit(10);
}
else if ( RetValue == 1 )
{
// fprintf(stdout, "s UNSATISFIABLE\n");
fprintf( pFile, "0" );
if ( fEnableComment )
{
printf( " # File %10s. ", argv[1] );
PRT( "Time", clock() - clkTotal );
}
printf( "\n" );
if ( pFile != stdout )
fclose(pFile);
Aig_ManStop( pAig );
exit(20);
}
else // if ( RetValue == -1 )
{
// fprintf(stdout, "s UNKNOWN\n");
fprintf( pFile, "2" );
if ( fEnableComment )
{
printf( " # File %10s. ", argv[1] );
PRT( "Time", clock() - clkTotal );
}
printf( "\n" );
if ( pFile != stdout )
fclose(pFile);
Aig_ManStop( pAig );
exit(0);
}
return 0;
}
