/**Function*************************************************************
Synopsis [Prepares the SAT solver to run on the two nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_PrepareCones( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
{
// Msat_IntVec_t * vAdjs;
// int * pVars, nVars, i, k;
int nVarsAlloc;
assert( pOld != pNew );
assert( !Fraig_IsComplement(pOld) );
assert( !Fraig_IsComplement(pNew) );
// clean the variables
nVarsAlloc = Msat_IntVecReadSize(pMan->vVarsUsed);
Msat_IntVecFill( pMan->vVarsUsed, nVarsAlloc, 0 );
Msat_IntVecClear( pMan->vVarsInt );
pMan->nTravIds++;
Fraig_PrepareCones_rec( pMan, pNew );
Fraig_PrepareCones_rec( pMan, pOld );
/*
nVars = Msat_IntVecReadSize( pMan->vVarsInt );
pVars = Msat_IntVecReadArray( pMan->vVarsInt );
for ( i = 0; i < nVars; i++ )
{
// process its connections
vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
printf( "%d=%d { ", pVars[i], Msat_IntVecReadSize(vAdjs) );
for ( k = 0; k < Msat_IntVecReadSize(vAdjs); k++ )
printf( "%d ", Msat_IntVecReadEntry(vAdjs,k) );
printf( "}\n" );
}
i = 0;
*/
}
/**Function*************************************************************
Synopsis [Adds clauses to the solver.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_SupergateAddClauses( Fraig_Man_t * p, Fraig_Node_t * pNode, Fraig_NodeVec_t * vSuper )
{
int fComp1, RetValue, nVars, Var, Var1, i;
assert( Fraig_NodeIsAnd( pNode ) );
nVars = Msat_SolverReadVarNum(p->pSat);
Var = pNode->Num;
assert( Var < nVars );
for ( i = 0; i < vSuper->nSize; i++ )
{
// get the predecessor nodes
// get the complemented attributes of the nodes
fComp1 = Fraig_IsComplement(vSuper->pArray[i]);
// determine the variable numbers
Var1 = Fraig_Regular(vSuper->pArray[i])->Num;
// check that the variables are in the SAT manager
assert( Var1 < nVars );
// suppose the AND-gate is A * B = C
// add !A => !C or A + !C
// fprintf( pFile, "%d %d 0%c", Var1, -Var, 10 );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var1, fComp1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var, 1) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
}
// add A & B => C or !A + !B + C
// fprintf( pFile, "%d %d %d 0%c", -Var1, -Var2, Var, 10 );
Msat_IntVecClear( p->vProj );
for ( i = 0; i < vSuper->nSize; i++ )
{
// get the predecessor nodes
// get the complemented attributes of the nodes
fComp1 = Fraig_IsComplement(vSuper->pArray[i]);
// determine the variable numbers
Var1 = Fraig_Regular(vSuper->pArray[i])->Num;
// add this variable to the array
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var1, !fComp1) );
}
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(Var, 0) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
}
/**Function*************************************************************
Synopsis [Adds clauses to the solver.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_SupergateAddClausesExor( Fraig_Man_t * p, Fraig_Node_t * pNode )
{
Fraig_Node_t * pNode1, * pNode2;
int fComp, RetValue;
assert( !Fraig_IsComplement( pNode ) );
assert( Fraig_NodeIsExorType( pNode ) );
// get nodes
pNode1 = Fraig_Regular(Fraig_Regular(pNode->p1)->p1);
pNode2 = Fraig_Regular(Fraig_Regular(pNode->p1)->p2);
// get the complemented attribute of the EXOR/NEXOR gate
fComp = Fraig_NodeIsExor( pNode ); // 1 if EXOR, 0 if NEXOR
// create four clauses
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, !fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, !fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, !fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, !fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, !fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1->Num, !fComp) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2->Num, fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
}
/**Function*************************************************************
Synopsis [Set up the adjacent variable information.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_SetupAdjacent( Fraig_Man_t * pMan, Msat_IntVec_t * vConeVars )
{
Fraig_Node_t * pNode, * pFanin;
Msat_IntVec_t * vAdjs;
int * pVars, nVars, i, k;
// clean the adjacents for the variables
nVars = Msat_IntVecReadSize( vConeVars );
pVars = Msat_IntVecReadArray( vConeVars );
for ( i = 0; i < nVars; i++ )
{
// process its connections
vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
Msat_IntVecClear( vAdjs );
pNode = pMan->vNodes->pArray[pVars[i]];
if ( !Fraig_NodeIsAnd(pNode) )
continue;
// add fanins
vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
for ( k = 0; k < pNode->vFanins->nSize; k++ )
// for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
{
pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
Msat_IntVecPush( vAdjs, pFanin->Num );
// Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
}
}
// add the fanouts
for ( i = 0; i < nVars; i++ )
{
pNode = pMan->vNodes->pArray[pVars[i]];
if ( !Fraig_NodeIsAnd(pNode) )
continue;
// add the edges
for ( k = 0; k < pNode->vFanins->nSize; k++ )
// for ( k = pNode->vFanins->nSize - 1; k >= 0; k-- )
{
pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pFanin->Num );
Msat_IntVecPush( vAdjs, pNode->Num );
// Msat_IntVecPushUniqueOrder( vAdjs, pFanin->Num );
}
}
}
/**Function*************************************************************
Synopsis [Adds clauses to the solver.]
Description [This procedure is used to add external clauses to the solver.
The clauses are given by sets of nodes. Each node stands for one literal.
If the node is complemented, the literal is negated.]
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_ManAddClause( Fraig_Man_t * p, Fraig_Node_t ** ppNodes, int nNodes )
{
Fraig_Node_t * pNode;
int i, fComp, RetValue;
if ( p->pSat == NULL )
Fraig_ManCreateSolver( p );
// create four clauses
Msat_IntVecClear( p->vProj );
for ( i = 0; i < nNodes; i++ )
{
pNode = Fraig_Regular(ppNodes[i]);
fComp = Fraig_IsComplement(ppNodes[i]);
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode->Num, fComp) );
// printf( "%d(%d) ", pNode->Num, fComp );
}
// printf( "\n" );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
}
/**Function*************************************************************
Synopsis [Collect variables using their proximity from the nodes.]
Description [This procedure creates a variable order based on collecting
first the nodes that are the closest to the given two target nodes.]
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_OrderVariables( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
{
Fraig_Node_t * pNode, * pFanin;
int i, k, Number, fUseMuxes = 1;
int nVarsAlloc;
assert( pOld != pNew );
assert( !Fraig_IsComplement(pOld) );
assert( !Fraig_IsComplement(pNew) );
pMan->nTravIds++;
// clean the variables
nVarsAlloc = Msat_IntVecReadSize(pMan->vVarsUsed);
Msat_IntVecFill( pMan->vVarsUsed, nVarsAlloc, 0 );
Msat_IntVecClear( pMan->vVarsInt );
// add the first node
Msat_IntVecPush( pMan->vVarsInt, pOld->Num );
Msat_IntVecWriteEntry( pMan->vVarsUsed, pOld->Num, 1 );
pOld->TravId = pMan->nTravIds;
// add the second node
Msat_IntVecPush( pMan->vVarsInt, pNew->Num );
Msat_IntVecWriteEntry( pMan->vVarsUsed, pNew->Num, 1 );
pNew->TravId = pMan->nTravIds;
// create the variable order
for ( i = 0; i < Msat_IntVecReadSize(pMan->vVarsInt); i++ )
{
// get the new node on the frontier
Number = Msat_IntVecReadEntry(pMan->vVarsInt, i);
pNode = pMan->vNodes->pArray[Number];
if ( !Fraig_NodeIsAnd(pNode) )
continue;
// if the node does not have fanins, create them
if ( pNode->vFanins == NULL )
{
// create the fanins of the supergate
assert( pNode->fClauses == 0 );
// detecting a fanout-free cone (experiment only)
// Fraig_DetectFanoutFreeCone( pMan, pNode );
if ( fUseMuxes && Fraig_NodeIsMuxType(pNode) )
{
pNode->vFanins = Fraig_NodeVecAlloc( 4 );
Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p1) );
Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p1)->p2) );
Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p1) );
Fraig_NodeVecPushUnique( pNode->vFanins, Fraig_Regular(Fraig_Regular(pNode->p2)->p2) );
Fraig_SupergateAddClausesMux( pMan, pNode );
// Fraig_DetectFanoutFreeConeMux( pMan, pNode );
nMuxes++;
}
else
{
pNode->vFanins = Fraig_CollectSupergate( pNode, fUseMuxes );
Fraig_SupergateAddClauses( pMan, pNode, pNode->vFanins );
}
assert( pNode->vFanins->nSize > 1 );
pNode->fClauses = 1;
pMan->nVarsClauses++;
pNode->fMark2 = 1; // goes together with Fraig_SetupAdjacentMark()
}
// explore the implication fanins of pNode
for ( k = 0; k < pNode->vFanins->nSize; k++ )
{
pFanin = Fraig_Regular(pNode->vFanins->pArray[k]);
if ( pFanin->TravId == pMan->nTravIds ) // already collected
continue;
// collect and mark
Msat_IntVecPush( pMan->vVarsInt, pFanin->Num );
Msat_IntVecWriteEntry( pMan->vVarsUsed, pFanin->Num, 1 );
pFanin->TravId = pMan->nTravIds;
}
}
// set up the adjacent variable information
// Fraig_SetupAdjacent( pMan, pMan->vVarsInt );
Fraig_SetupAdjacentMark( pMan, pMan->vVarsInt );
}
/**Function*************************************************************
Synopsis [Prepares the SAT solver to run on the two nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_ManCheckClauseUsingSat( Fraig_Man_t * p, Fraig_Node_t * pNode1, Fraig_Node_t * pNode2, int nBTLimit )
{
Fraig_Node_t * pNode1R, * pNode2R;
int RetValue, RetValue1, i, clk;
int fVerbose = 0;
pNode1R = Fraig_Regular(pNode1);
pNode2R = Fraig_Regular(pNode2);
assert( pNode1R != pNode2R );
// make sure the solver is allocated and has enough variables
if ( p->pSat == NULL )
Fraig_ManCreateSolver( p );
// make sure the SAT solver has enough variables
for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
// get the logic cone
clk = clock();
Fraig_OrderVariables( p, pNode1R, pNode2R );
// Fraig_PrepareCones( p, pNode1R, pNode2R );
p->timeTrav += clock() - clk;
////////////////////////////////////////////
// prepare the solver to run incrementally on these variables
//clk = clock();
Msat_SolverPrepare( p->pSat, p->vVarsInt );
//p->time3 += clock() - clk;
// solve under assumptions
// A = 1; B = 0 OR A = 1; B = 1
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1R->Num, !Fraig_IsComplement(pNode1)) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2R->Num, !Fraig_IsComplement(pNode2)) );
// run the solver
clk = clock();
RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, 1000000 );
p->timeSat += clock() - clk;
if ( RetValue1 == MSAT_FALSE )
{
//p->time1 += clock() - clk;
if ( fVerbose )
{
printf( "unsat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// add the clause
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode1R->Num, Fraig_IsComplement(pNode1)) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNode2R->Num, Fraig_IsComplement(pNode2)) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
// p->nSatProofImp++;
return 1;
}
else if ( RetValue1 == MSAT_TRUE )
{
//p->time2 += clock() - clk;
if ( fVerbose )
{
printf( "sat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// record the counter example
// Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pNode1R, pNode2R );
p->nSatCounterImp++;
return 0;
}
else // if ( RetValue1 == MSAT_UNKNOWN )
{
p->time3 += clock() - clk;
p->nSatFailsImp++;
return 0;
}
}
/**Function*************************************************************
Synopsis [Checks whether pOld => pNew.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_NodeIsImplication( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit )
{
int RetValue, RetValue1, i, fComp, clk;
int fVerbose = 0;
// make sure the nodes are not complemented
assert( !Fraig_IsComplement(pNew) );
assert( !Fraig_IsComplement(pOld) );
assert( pNew != pOld );
p->nSatCallsImp++;
// make sure the solver is allocated and has enough variables
if ( p->pSat == NULL )
Fraig_ManCreateSolver( p );
// make sure the SAT solver has enough variables
for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
// get the logic cone
clk = clock();
Fraig_OrderVariables( p, pOld, pNew );
// Fraig_PrepareCones( p, pOld, pNew );
p->timeTrav += clock() - clk;
if ( fVerbose )
printf( "%d(%d) - ", Fraig_CountPis(p,p->vVarsInt), Msat_IntVecReadSize(p->vVarsInt) );
// get the complemented attribute
fComp = Fraig_NodeComparePhase( pOld, pNew );
//Msat_SolverPrintClauses( p->pSat );
////////////////////////////////////////////
// prepare the solver to run incrementally on these variables
//clk = clock();
Msat_SolverPrepare( p->pSat, p->vVarsInt );
//p->time3 += clock() - clk;
// solve under assumptions
// A = 1; B = 0 OR A = 1; B = 1
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
// run the solver
clk = clock();
RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, 1000000 );
p->timeSat += clock() - clk;
if ( RetValue1 == MSAT_FALSE )
{
//p->time1 += clock() - clk;
if ( fVerbose )
{
printf( "unsat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// add the clause
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
// p->nSatProofImp++;
return 1;
}
else if ( RetValue1 == MSAT_TRUE )
{
//p->time2 += clock() - clk;
if ( fVerbose )
{
printf( "sat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// record the counter example
Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
p->nSatCounterImp++;
return 0;
}
else // if ( RetValue1 == MSAT_UNKNOWN )
{
p->time3 += clock() - clk;
p->nSatFailsImp++;
return 0;
}
}
/**Function*************************************************************
Synopsis [Checks whether two nodes are functinally equivalent.]
Description [The flag (fComp) tells whether the nodes to be checked
are in the opposite polarity. The second flag (fSkipZeros) tells whether
the checking should be performed if the simulation vectors are zeros.
Returns 1 if the nodes are equivalent; 0 othewise.]
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_NodeIsEquivalent( Fraig_Man_t * p, Fraig_Node_t * pOld, Fraig_Node_t * pNew, int nBTLimit, int nTimeLimit )
{
int RetValue, RetValue1, i, fComp, clk;
int fVerbose = 0;
int fSwitch = 0;
// make sure the nodes are not complemented
assert( !Fraig_IsComplement(pNew) );
assert( !Fraig_IsComplement(pOld) );
assert( pNew != pOld );
// if at least one of the nodes is a failed node, perform adjustments:
// if the backtrack limit is small, simply skip this node
// if the backtrack limit is > 10, take the quare root of the limit
if ( nBTLimit > 0 && (pOld->fFailTfo || pNew->fFailTfo) )
{
p->nSatFails++;
// return 0;
// if ( nBTLimit > 10 )
// nBTLimit /= 10;
if ( nBTLimit <= 10 )
return 0;
nBTLimit = (int)sqrt(nBTLimit);
// fSwitch = 1;
}
p->nSatCalls++;
// make sure the solver is allocated and has enough variables
if ( p->pSat == NULL )
Fraig_ManCreateSolver( p );
// make sure the SAT solver has enough variables
for ( i = Msat_SolverReadVarNum(p->pSat); i < p->vNodes->nSize; i++ )
Msat_SolverAddVar( p->pSat, p->vNodes->pArray[i]->Level );
/*
{
Fraig_Node_t * ppNodes[2] = { pOld, pNew };
extern void Fraig_MappingShowNodes( Fraig_Man_t * pMan, Fraig_Node_t ** ppRoots, int nRoots, char * pFileName );
Fraig_MappingShowNodes( p, ppNodes, 2, "temp_aig" );
}
*/
nMuxes = 0;
// get the logic cone
clk = clock();
// Fraig_VarsStudy( p, pOld, pNew );
Fraig_OrderVariables( p, pOld, pNew );
// Fraig_PrepareCones( p, pOld, pNew );
p->timeTrav += clock() - clk;
// printf( "The number of MUXes detected = %d (%5.2f %% of logic). ", nMuxes, 300.0*nMuxes/(p->vNodes->nSize - p->vInputs->nSize) );
// PRT( "Time", clock() - clk );
if ( fVerbose )
printf( "%d(%d) - ", Fraig_CountPis(p,p->vVarsInt), Msat_IntVecReadSize(p->vVarsInt) );
// prepare variable activity
Fraig_SetActivity( p, pOld, pNew );
// get the complemented attribute
fComp = Fraig_NodeComparePhase( pOld, pNew );
//Msat_SolverPrintClauses( p->pSat );
////////////////////////////////////////////
// prepare the solver to run incrementally on these variables
//clk = clock();
Msat_SolverPrepare( p->pSat, p->vVarsInt );
//p->time3 += clock() - clk;
// solve under assumptions
// A = 1; B = 0 OR A = 1; B = 1
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
//Msat_SolverWriteDimacs( p->pSat, "temp_fraig.cnf" );
// run the solver
clk = clock();
RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, nTimeLimit );
p->timeSat += clock() - clk;
if ( RetValue1 == MSAT_FALSE )
{
//p->time1 += clock() - clk;
if ( fVerbose )
{
printf( "unsat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// add the clause
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
// continue solving the other implication
}
else if ( RetValue1 == MSAT_TRUE )
{
//p->time2 += clock() - clk;
if ( fVerbose )
{
printf( "sat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// record the counter example
Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
// if ( pOld->fFailTfo || pNew->fFailTfo )
// printf( "*" );
// printf( "s(%d)", pNew->Level );
if ( fSwitch )
printf( "s(%d)", pNew->Level );
p->nSatCounter++;
return 0;
}
else // if ( RetValue1 == MSAT_UNKNOWN )
{
p->time3 += clock() - clk;
// if ( pOld->fFailTfo || pNew->fFailTfo )
// printf( "*" );
// printf( "T(%d)", pNew->Level );
// mark the node as the failed node
if ( pOld != p->pConst1 )
pOld->fFailTfo = 1;
pNew->fFailTfo = 1;
// p->nSatFails++;
if ( fSwitch )
printf( "T(%d)", pNew->Level );
p->nSatFailsReal++;
return 0;
}
// if the old node was constant 0, we already know the answer
if ( pOld == p->pConst1 )
return 1;
////////////////////////////////////////////
// prepare the solver to run incrementally
//clk = clock();
Msat_SolverPrepare( p->pSat, p->vVarsInt );
//p->time3 += clock() - clk;
// solve under assumptions
// A = 0; B = 1 OR A = 0; B = 0
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, fComp) );
// run the solver
clk = clock();
RetValue1 = Msat_SolverSolve( p->pSat, p->vProj, nBTLimit, nTimeLimit );
p->timeSat += clock() - clk;
if ( RetValue1 == MSAT_FALSE )
{
//p->time1 += clock() - clk;
if ( fVerbose )
{
printf( "unsat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// add the clause
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pOld->Num, 0) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(pNew->Num, !fComp) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
// continue solving the other implication
}
else if ( RetValue1 == MSAT_TRUE )
{
//p->time2 += clock() - clk;
if ( fVerbose )
{
printf( "sat %d ", Msat_SolverReadBackTracks(p->pSat) );
PRT( "time", clock() - clk );
}
// record the counter example
Fraig_FeedBack( p, Msat_SolverReadModelArray(p->pSat), p->vVarsInt, pOld, pNew );
p->nSatCounter++;
// if ( pOld->fFailTfo || pNew->fFailTfo )
// printf( "*" );
// printf( "s(%d)", pNew->Level );
if ( fSwitch )
printf( "s(%d)", pNew->Level );
return 0;
}
else // if ( RetValue1 == MSAT_UNKNOWN )
{
p->time3 += clock() - clk;
// if ( pOld->fFailTfo || pNew->fFailTfo )
// printf( "*" );
// printf( "T(%d)", pNew->Level );
if ( fSwitch )
printf( "T(%d)", pNew->Level );
// mark the node as the failed node
pOld->fFailTfo = 1;
pNew->fFailTfo = 1;
// p->nSatFails++;
p->nSatFailsReal++;
return 0;
}
// return SAT proof
p->nSatProof++;
// if ( pOld->fFailTfo || pNew->fFailTfo )
// printf( "*" );
// printf( "u(%d)", pNew->Level );
if ( fSwitch )
printf( "u(%d)", pNew->Level );
return 1;
}
/**Function*************************************************************
Synopsis [Adds clauses to the solver.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_SupergateAddClausesMux( Fraig_Man_t * p, Fraig_Node_t * pNode )
{
Fraig_Node_t * pNodeI, * pNodeT, * pNodeE;
int RetValue, VarF, VarI, VarT, VarE, fCompT, fCompE;
assert( !Fraig_IsComplement( pNode ) );
assert( Fraig_NodeIsMuxType( pNode ) );
// get nodes (I = if, T = then, E = else)
pNodeI = Fraig_NodeRecognizeMux( pNode, &pNodeT, &pNodeE );
// get the variable numbers
VarF = pNode->Num;
VarI = pNodeI->Num;
VarT = Fraig_Regular(pNodeT)->Num;
VarE = Fraig_Regular(pNodeE)->Num;
// get the complementation flags
fCompT = Fraig_IsComplement(pNodeT);
fCompE = Fraig_IsComplement(pNodeE);
// f = ITE(i, t, e)
// i' + t' + f
// i' + t + f'
// i + e' + f
// i + e + f'
// create four clauses
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI, 1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT, 1^fCompT) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 0) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI, 1) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT, 0^fCompT) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 1) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI, 0) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE, 1^fCompE) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 0) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarI, 0) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE, 0^fCompE) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 1) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
// two additional clauses
// t' & e' -> f'
// t & e -> f
// t + e + f'
// t' + e' + f
if ( VarT == VarE )
{
// assert( fCompT == !fCompE );
return;
}
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT, 0^fCompT) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE, 0^fCompE) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 1) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
Msat_IntVecClear( p->vProj );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarT, 1^fCompT) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarE, 1^fCompE) );
Msat_IntVecPush( p->vProj, MSAT_VAR2LIT(VarF, 0) );
RetValue = Msat_SolverAddClause( p->pSat, p->vProj );
assert( RetValue );
}
