/**Function*************************************************************
Synopsis [Set up the adjacent variable information.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_SetupAdjacentMark( 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++ )
{
pNode = pMan->vNodes->pArray[pVars[i]];
if ( pNode->fMark2 == 0 )
continue;
// pNode->fMark2 = 0;
// process its connections
// vAdjs = (Msat_IntVec_t *)Msat_ClauseVecReadEntry( pMan->vAdjacents, pVars[i] );
// Msat_IntVecClear( vAdjs );
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 ( pNode->fMark2 == 0 )
continue;
pNode->fMark2 = 0;
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 [Count the number of PI variables.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_CountPis( Fraig_Man_t * p, Msat_IntVec_t * vVarNums )
{
int * pVars, nVars, i, Counter;
nVars = Msat_IntVecReadSize(vVarNums);
pVars = Msat_IntVecReadArray(vVarNums);
Counter = 0;
for ( i = 0; i < nVars; i++ )
Counter += Fraig_NodeIsVar( p->vNodes->pArray[pVars[i]] );
return Counter;
}
/**Function*************************************************************
Synopsis [Top-level solve.]
Description [If using assumptions (non-empty 'assumps' vector), you must
call 'simplifyDB()' first to see that no top-level conflict is present
(which would put the solver in an undefined state. If the last argument
is given (vProj), the solver enumerates through the satisfying solutions,
which are projected on the variables listed in this array. Note that the
variables in the array may be complemented, in which case the derived
assignment for the variable is complemented.]
SideEffects []
SeeAlso []
***********************************************************************/
int Msat_SolverSolve( Msat_Solver_t * p, Msat_IntVec_t * vAssumps, int nBackTrackLimit, int nTimeLimit )
{
Msat_SearchParams_t Params = { 0.95, 0.999 };
double nConflictsLimit, nLearnedLimit;
Msat_Type_t Status;
int timeStart = clock();
// p->pFreq = ABC_ALLOC( int, p->nVarsAlloc );
// memset( p->pFreq, 0, sizeof(int) * p->nVarsAlloc );
if ( vAssumps )
{
int * pAssumps, nAssumps, i;
assert( Msat_IntVecReadSize(p->vTrailLim) == 0 );
nAssumps = Msat_IntVecReadSize( vAssumps );
pAssumps = Msat_IntVecReadArray( vAssumps );
for ( i = 0; i < nAssumps; i++ )
{
if ( !Msat_SolverAssume(p, pAssumps[i]) || Msat_SolverPropagate(p) )
{
Msat_QueueClear( p->pQueue );
Msat_SolverCancelUntil( p, 0 );
return MSAT_FALSE;
}
}
}
p->nLevelRoot = Msat_SolverReadDecisionLevel(p);
p->nClausesInit = Msat_ClauseVecReadSize( p->vClauses );
nConflictsLimit = 100;
nLearnedLimit = Msat_ClauseVecReadSize(p->vClauses) / 3;
Status = MSAT_UNKNOWN;
p->nBackTracks = (int)p->Stats.nConflicts;
while ( Status == MSAT_UNKNOWN )
{
if ( p->fVerbose )
printf("Solving -- conflicts=%d learnts=%d progress=%.4f %%\n",
(int)nConflictsLimit, (int)nLearnedLimit, p->dProgress*100);
Status = Msat_SolverSearch( p, (int)nConflictsLimit, (int)nLearnedLimit, nBackTrackLimit, &Params );
nConflictsLimit *= 1.5;
nLearnedLimit *= 1.1;
// if the limit on the number of backtracks is given, quit the restart loop
if ( nBackTrackLimit > 0 && (int)p->Stats.nConflicts - p->nBackTracks > nBackTrackLimit )
break;
// if the runtime limit is exceeded, quit the restart loop
if ( nTimeLimit > 0 && clock() - timeStart >= nTimeLimit * CLOCKS_PER_SEC )
break;
}
Msat_SolverCancelUntil( p, 0 );
p->nBackTracks = (int)p->Stats.nConflicts - p->nBackTracks;
/*
ABC_PRT( "True solver runtime", clock() - timeStart );
// print the statistics
{
int i, Counter = 0;
for ( i = 0; i < p->nVars; i++ )
if ( p->pFreq[i] > 0 )
{
printf( "%d ", p->pFreq[i] );
Counter++;
}
if ( Counter )
printf( "\n" );
printf( "Total = %d. Used = %d. Decisions = %d. Imps = %d. Conflicts = %d. ", p->nVars, Counter, (int)p->Stats.nDecisions, (int)p->Stats.nPropagations, (int)p->Stats.nConflicts );
ABC_PRT( "Time", clock() - timeStart );
}
*/
return Status;
}
