| /**CFile**************************************************************** |
| |
| FileName [abcMfs.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [Hierarchical word-level netlist.] |
| |
| Synopsis [Optimization with don't-cares.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - July 21, 2015.] |
| |
| Revision [$Id: abcMfs.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "acb.h" |
| #include "bool/kit/kit.h" |
| #include "sat/bsat/satSolver.h" |
| #include "sat/cnf/cnf.h" |
| #include "misc/util/utilTruth.h" |
| #include "acbPar.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| static inline int Acb_ObjIsDelayCriticalFanin( Acb_Ntk_t * p, int i, int f ) { return !Acb_ObjIsCi(p, f) && Acb_ObjLevelR(p, i) + Acb_ObjLevelD(p, f) == p->LevelMax; } |
| static inline int Acb_ObjIsAreaCritical( Acb_Ntk_t * p, int f ) { return !Acb_ObjIsCi(p, f) && Acb_ObjFanoutNum(p, f) == 1; } |
| static inline int Acb_ObjIsCritical( Acb_Ntk_t * p, int i, int f, int fDel ) { return fDel ? Acb_ObjIsDelayCriticalFanin(p, i, f) : Acb_ObjIsAreaCritical(p, f); } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Derive CNF for nodes in the window.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Acb_DeriveCnfFromTruth( word Truth, int nVars, Vec_Int_t * vCover, Vec_Str_t * vCnf ) |
| { |
| Vec_StrClear( vCnf ); |
| if ( Truth == 0 || ~Truth == 0 ) |
| { |
| // assert( nVars == 0 ); |
| Vec_StrPush( vCnf, (char)(Truth == 0) ); |
| Vec_StrPush( vCnf, (char)-1 ); |
| return 1; |
| } |
| else |
| { |
| int i, k, c, RetValue, Literal, Cube, nCubes = 0; |
| assert( nVars > 0 ); |
| for ( c = 0; c < 2; c ++ ) |
| { |
| Truth = c ? ~Truth : Truth; |
| RetValue = Kit_TruthIsop( (unsigned *)&Truth, nVars, vCover, 0 ); |
| assert( RetValue == 0 ); |
| nCubes += Vec_IntSize( vCover ); |
| Vec_IntForEachEntry( vCover, Cube, i ) |
| { |
| for ( k = 0; k < nVars; k++ ) |
| { |
| Literal = 3 & (Cube >> (k << 1)); |
| if ( Literal == 1 ) // '0' -> pos lit |
| Vec_StrPush( vCnf, (char)Abc_Var2Lit(k, 0) ); |
| else if ( Literal == 2 ) // '1' -> neg lit |
| Vec_StrPush( vCnf, (char)Abc_Var2Lit(k, 1) ); |
| else if ( Literal != 0 ) |
| assert( 0 ); |
| } |
| Vec_StrPush( vCnf, (char)Abc_Var2Lit(nVars, c) ); |
| Vec_StrPush( vCnf, (char)-1 ); |
| } |
| } |
| return nCubes; |
| } |
| } |
| |
| void Acb_DeriveCnfForWindowOne( Acb_Ntk_t * p, int iObj ) |
| { |
| Vec_Wec_t * vCnfs = &p->vCnfs; |
| Vec_Str_t * vCnfBase = Acb_ObjCnfs( p, iObj ); |
| assert( Vec_StrSize(vCnfBase) == 0 ); // unassigned |
| assert( Vec_WecSize(vCnfs) == Acb_NtkObjNumMax(p) ); |
| Acb_DeriveCnfFromTruth( Acb_ObjTruth(p, iObj), Acb_ObjFaninNum(p, iObj), &p->vCover, &p->vCnf ); |
| Vec_StrGrow( vCnfBase, Vec_StrSize(&p->vCnf) ); |
| memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(&p->vCnf), Vec_StrSize(&p->vCnf) ); |
| vCnfBase->nSize = Vec_StrSize(&p->vCnf); |
| } |
| Vec_Wec_t * Acb_DeriveCnfForWindow( Acb_Ntk_t * p, Vec_Int_t * vWin, int PivotVar ) |
| { |
| Vec_Wec_t * vCnfs = &p->vCnfs; |
| Vec_Str_t * vCnfBase; int i, iObj; |
| assert( Vec_WecSize(vCnfs) == Acb_NtkObjNumMax(p) ); |
| Vec_IntForEachEntry( vWin, iObj, i ) |
| { |
| if ( Abc_LitIsCompl(iObj) && i < PivotVar ) |
| continue; |
| iObj = Abc_Lit2Var(iObj); |
| vCnfBase = Acb_ObjCnfs( p, iObj ); |
| if ( Vec_StrSize(vCnfBase) > 0 ) |
| continue; |
| Acb_DeriveCnfForWindowOne( p, iObj ); |
| } |
| return vCnfs; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Constructs CNF for the window.] |
| |
| Description [The window for the pivot node is represented as a DFS ordered array |
| of objects (vWinObjs) whose indexes are used as SAT variable IDs (stored in p->vCopies). |
| PivotVar is the index of the pivot node in array vWinObjs. |
| The nodes before (after) PivotVar are TFI (TFO) nodes. |
| The leaf (root) nodes are labeled with Abc_LitIsCompl(). |
| If fQbf is 1, returns the instance meant for QBF solving. It uses the last |
| variable (LastVar) as the placeholder for the second copy of the pivot node.] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_TranslateCnf( Vec_Int_t * vClas, Vec_Int_t * vLits, Vec_Str_t * vCnf, Vec_Int_t * vSatVars, int iPivotVar ) |
| { |
| signed char Entry; |
| int i, Lit; |
| Vec_StrForEachEntry( vCnf, Entry, i ) |
| { |
| if ( (int)Entry == -1 ) |
| { |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| continue; |
| } |
| Lit = Abc_Lit2LitV( Vec_IntArray(vSatVars), (int)Entry ); |
| Lit = Abc_LitNotCond( Lit, Abc_Lit2Var(Lit) == iPivotVar ); |
| Vec_IntPush( vLits, Lit ); |
| } |
| } |
| int Acb_NtkCountRoots( Vec_Int_t * vWinObjs, int PivotVar ) |
| { |
| int i, iObjLit, nRoots = 0; |
| Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, PivotVar + 1 ) |
| nRoots += Abc_LitIsCompl(iObjLit); |
| return nRoots; |
| } |
| void Acb_DeriveCnfForNode( Acb_Ntk_t * p, int iObj, sat_solver * pSat, int OutVar ) |
| { |
| Vec_Wec_t * vCnfs = &p->vCnfs; |
| Vec_Int_t * vFaninVars = &p->vCover; |
| Vec_Int_t * vClas = Vec_IntAlloc( 100 ); |
| Vec_Int_t * vLits = Vec_IntAlloc( 100 ); |
| int k, iFanin, * pFanins, Prev, This; |
| // collect SAT variables |
| Vec_IntClear( vFaninVars ); |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) |
| { |
| assert( Acb_ObjFunc(p, iFanin) >= 0 ); |
| Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) ); |
| } |
| Vec_IntPush( vFaninVars, OutVar ); |
| // derive CNF for the node |
| Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, -1 ); |
| // add clauses |
| Prev = 0; |
| Vec_IntForEachEntry( vClas, This, k ) |
| { |
| if ( !sat_solver_addclause( pSat, Vec_IntArray(vLits) + Prev, Vec_IntArray(vLits) + This ) ) |
| printf( "Error: SAT solver became UNSAT at a wrong place (while adding new CNF).\n" ); |
| Prev = This; |
| } |
| Vec_IntFree( vClas ); |
| Vec_IntFree( vLits ); |
| } |
| Cnf_Dat_t * Acb_NtkWindow2Cnf( Acb_Ntk_t * p, Vec_Int_t * vWinObjs, int Pivot ) |
| { |
| Cnf_Dat_t * pCnf; |
| Vec_Int_t * vFaninVars = Vec_IntAlloc( 8 ); |
| int PivotVar = Vec_IntFind(vWinObjs, Abc_Var2Lit(Pivot, 0)); |
| int nRoots = Acb_NtkCountRoots(vWinObjs, PivotVar); |
| int TfoStart = PivotVar + 1; |
| int nTfoSize = Vec_IntSize(vWinObjs) - TfoStart; |
| int nVarsAll = Vec_IntSize(vWinObjs) + nTfoSize + nRoots; |
| int i, k, iObj, iObjLit, iFanin, * pFanins, Entry; |
| Vec_Wec_t * vCnfs = Acb_DeriveCnfForWindow( p, vWinObjs, PivotVar ); |
| Vec_Int_t * vClas = Vec_IntAlloc( 100 ); |
| Vec_Int_t * vLits = Vec_IntAlloc( 1000 ); |
| // mark new SAT variables |
| Vec_IntForEachEntry( vWinObjs, iObj, i ) |
| Acb_ObjSetFunc( p, Abc_Lit2Var(iObj), i ); |
| // add clauses for all nodes |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| Vec_IntForEachEntry( vWinObjs, iObjLit, i ) |
| { |
| if ( Abc_LitIsCompl(iObjLit) && i < PivotVar ) |
| continue; |
| iObj = Abc_Lit2Var(iObjLit); |
| assert( !Acb_ObjIsCio(p, iObj) ); |
| // collect SAT variables |
| Vec_IntClear( vFaninVars ); |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) |
| Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) ); |
| Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iObj) ); |
| // derive CNF for the node |
| Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, -1 ); |
| } |
| // add second clauses for the TFO |
| Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, TfoStart ) |
| { |
| iObj = Abc_Lit2Var(iObjLit); |
| assert( !Acb_ObjIsCio(p, iObj) ); |
| // collect SAT variables |
| Vec_IntClear( vFaninVars ); |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) |
| Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) + (Acb_ObjFunc(p, iFanin) > PivotVar) * nTfoSize ); |
| Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iObj) + nTfoSize ); |
| // derive CNF for the node |
| Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, PivotVar ); |
| } |
| if ( nRoots > 0 ) |
| { |
| // create XOR clauses for the roots |
| int nVars = Vec_IntSize(vWinObjs) + nTfoSize; |
| Vec_IntClear( vFaninVars ); |
| Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, TfoStart ) |
| { |
| if ( !Abc_LitIsCompl(iObjLit) ) |
| continue; |
| iObj = Abc_Lit2Var(iObjLit); |
| // add clauses |
| Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 1), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 0), Abc_Var2Lit(nVars, 0) ); |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 0), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 1), Abc_Var2Lit(nVars, 0) ); |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 0), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 0), Abc_Var2Lit(nVars, 1) ); |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 1), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 1), Abc_Var2Lit(nVars, 1) ); |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| Vec_IntPush( vFaninVars, Abc_Var2Lit(nVars++, 0) ); |
| } |
| Vec_IntAppend( vLits, vFaninVars ); |
| Vec_IntPush( vClas, Vec_IntSize(vLits) ); |
| assert( nRoots == Vec_IntSize(vFaninVars) ); |
| assert( nVars == nVarsAll ); |
| } |
| Vec_IntFree( vFaninVars ); |
| // create CNF structure |
| pCnf = ABC_CALLOC( Cnf_Dat_t, 1 ); |
| pCnf->nVars = nVarsAll; |
| pCnf->nClauses = Vec_IntSize(vClas)-1; |
| pCnf->nLiterals = Vec_IntSize(vLits); |
| pCnf->pClauses = ABC_ALLOC( int *, Vec_IntSize(vClas) ); |
| pCnf->pClauses[0] = Vec_IntReleaseArray(vLits); |
| Vec_IntForEachEntry( vClas, Entry, i ) |
| pCnf->pClauses[i] = pCnf->pClauses[0] + Entry; |
| // cleanup |
| Vec_IntFree( vClas ); |
| Vec_IntFree( vLits ); |
| //Cnf_DataPrint( pCnf, 1 ); |
| return pCnf; |
| } |
| void Acb_NtkWindowUndo( Acb_Ntk_t * p, Vec_Int_t * vWin ) |
| { |
| int i, iObj; |
| Vec_IntForEachEntry( vWin, iObj, i ) |
| { |
| assert( Vec_IntEntry(&p->vObjFunc, Abc_Lit2Var(iObj)) != -1 ); |
| Vec_IntWriteEntry( &p->vObjFunc, Abc_Lit2Var(iObj), -1 ); |
| } |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Creates SAT solver containing several copies of the window.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Acb_NtkWindow2Solver( sat_solver * pSat, Cnf_Dat_t * pCnf, Vec_Int_t * vFlip, int PivotVar, int nDivs, int nTimes ) |
| { |
| int n, i, RetValue, Test = pCnf->pClauses[0][0]; |
| int nGroups = nTimes <= 2 ? nTimes-1 : 2; |
| int nRounds = nTimes <= 2 ? nTimes-1 : nTimes; |
| assert( sat_solver_nvars(pSat) == 0 ); |
| sat_solver_setnvars( pSat, nTimes * pCnf->nVars + nGroups * nDivs + 2 ); |
| assert( nTimes == 1 || nTimes == 2 || nTimes == 6 ); |
| for ( n = 0; n < nTimes; n++ ) |
| { |
| if ( n & 1 ) |
| Cnf_DataLiftAndFlipLits( pCnf, -pCnf->nVars, vFlip ); |
| for ( i = 0; i < pCnf->nClauses; i++ ) |
| if ( !sat_solver_addclause( pSat, pCnf->pClauses[i], pCnf->pClauses[i+1] ) ) |
| printf( "Error: SAT solver became UNSAT at a wrong place.\n" ); |
| if ( n & 1 ) |
| Cnf_DataLiftAndFlipLits( pCnf, pCnf->nVars, vFlip ); |
| if ( n < nTimes - 1 ) |
| Cnf_DataLift( pCnf, pCnf->nVars ); |
| else if ( n ) // if ( n == nTimes - 1 ) |
| Cnf_DataLift( pCnf, -(nTimes - 1) * pCnf->nVars ); |
| } |
| assert( Test == pCnf->pClauses[0][0] ); |
| // add conditional buffers |
| for ( n = 0; n < nRounds; n++ ) |
| { |
| int BaseA = n * pCnf->nVars; |
| int BaseB = ((n + 1) % nTimes) * pCnf->nVars; |
| int BaseC = nTimes * pCnf->nVars + (n & 1) * nDivs; |
| for ( i = 0; i < nDivs; i++ ) |
| sat_solver_add_buffer_enable( pSat, BaseA + i, BaseB + i, BaseC + i, 0 ); |
| } |
| // finalize |
| RetValue = sat_solver_simplify( pSat ); |
| if ( !RetValue ) printf( "Error: SAT solver became UNSAT at a wrong place.\n" ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Computes function of the node] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| word Acb_ComputeFunction( sat_solver * pSat, int PivotVar, int FreeVar, Vec_Int_t * vDivVars, int fCompl ) |
| { |
| int fExpand = 0; |
| word uCube, uTruth = 0; |
| Vec_Int_t * vTempLits = Vec_IntAlloc( 100 ); |
| int status, i, iVar, iLit, nFinal, * pFinal, pLits[2]; |
| assert( FreeVar < sat_solver_nvars(pSat) ); |
| // if ( fCompl ) |
| // pLits[0] = Abc_Var2Lit( sat_solver_nvars(pSat)-2, 0 ); // F = 1 |
| // else |
| pLits[0] = Abc_Var2Lit( PivotVar, fCompl ); // F = 1 |
| pLits[1] = Abc_Var2Lit( FreeVar, 0 ); // iNewLit |
| while ( 1 ) |
| { |
| // find onset minterm |
| status = sat_solver_solve( pSat, pLits, pLits + 2, 0, 0, 0, 0 ); |
| if ( status == l_False ) |
| { |
| Vec_IntFree( vTempLits ); |
| return uTruth; |
| } |
| assert( status == l_True ); |
| if ( fExpand ) |
| { |
| // collect divisor literals |
| Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[0]) ); // F = 0 |
| Vec_IntForEachEntry( vDivVars, iVar, i ) |
| Vec_IntPush( vTempLits, sat_solver_var_literal(pSat, iVar) ); |
| // check against offset |
| status = sat_solver_solve( pSat, Vec_IntArray(vTempLits), Vec_IntLimit(vTempLits), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| printf( "Failed internal check during function comptutation.\n" ); |
| assert( status == l_False ); |
| // compute cube and add clause |
| nFinal = sat_solver_final( pSat, &pFinal ); |
| Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[1]) ); // NOT(iNewLit) |
| for ( i = 0; i < nFinal; i++ ) |
| if ( pFinal[i] != pLits[0] ) |
| Vec_IntPush( vTempLits, pFinal[i] ); |
| } |
| else |
| { |
| // collect divisor literals |
| Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[1]) );// NOT(iNewLit) |
| Vec_IntForEachEntry( vDivVars, iVar, i ) |
| Vec_IntPush( vTempLits, Abc_LitNot(sat_solver_var_literal(pSat, iVar)) ); |
| } |
| uCube = ~(word)0; |
| Vec_IntForEachEntryStart( vTempLits, iLit, i, 1 ) |
| { |
| iVar = Vec_IntFind( vDivVars, Abc_Lit2Var(iLit) ); assert( iVar >= 0 ); |
| uCube &= Abc_LitIsCompl(iLit) ? s_Truths6[iVar] : ~s_Truths6[iVar]; |
| } |
| uTruth |= uCube; |
| status = sat_solver_addclause( pSat, Vec_IntArray(vTempLits), Vec_IntLimit(vTempLits) ); |
| if ( status == 0 ) |
| { |
| Vec_IntFree( vTempLits ); |
| return uTruth; |
| } |
| } |
| Vec_IntFree( vTempLits ); |
| assert( 0 ); |
| return ~(word)0; |
| } |
| |
| |
| |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_NtkPrintVec( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName ) |
| { |
| int i; |
| printf( "%s: ", pName ); |
| for ( i = 0; i < vVec->nSize; i++ ) |
| printf( "%d ", vVec->pArray[i] ); |
| printf( "\n" ); |
| } |
| void Acb_NtkPrintVec2( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName ) |
| { |
| int i; |
| printf( "%s: \n", pName ); |
| for ( i = 0; i < vVec->nSize; i++ ) |
| Acb_NtkPrintNode( p, vVec->pArray[i] ); |
| printf( "\n" ); |
| } |
| void Acb_NtkPrintVecWin( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName ) |
| { |
| int i; |
| printf( "%s: \n", pName ); |
| for ( i = 0; i < vVec->nSize; i++ ) |
| Acb_NtkPrintNode( p, Abc_Lit2Var(vVec->pArray[i]) ); |
| printf( "\n" ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collects divisors in a non-topo order.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_NtkDivisors_rec( Acb_Ntk_t * p, int iObj, int nTfiLevMin, Vec_Int_t * vDivs ) |
| { |
| int k, iFanin, * pFanins; |
| // if ( !Acb_ObjIsCi(p, iObj) && Acb_ObjLevelD(p, iObj) < nTfiLevMin ) |
| if ( !Acb_ObjIsCi(p, iObj) && nTfiLevMin < 0 ) |
| return; |
| if ( Acb_ObjSetTravIdCur(p, iObj) ) |
| return; |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) |
| Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin-1, vDivs ); |
| Vec_IntPush( vDivs, iObj ); |
| } |
| Vec_Int_t * Acb_NtkDivisors( Acb_Ntk_t * p, int Pivot, int nTfiLevMin, int fDelay ) |
| { |
| int k, iFanin, * pFanins; |
| Vec_Int_t * vDivs = Vec_IntAlloc( 100 ); |
| Acb_NtkIncTravId( p ); |
| // if ( fDelay ) // delay-oriented |
| if ( 0 ) // delay-oriented |
| { |
| // start from critical fanins |
| assert( Acb_ObjLevelD( p, Pivot ) > 1 ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) ) |
| Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin, vDivs ); |
| // add non-critical fanins |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( !Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) ) |
| if ( !Acb_ObjSetTravIdCur(p, iFanin) ) |
| Vec_IntPush( vDivs, iFanin ); |
| } |
| else |
| { |
| Acb_NtkDivisors_rec( p, Pivot, nTfiLevMin, vDivs ); |
| assert( Vec_IntEntryLast(vDivs) == Pivot ); |
| Vec_IntPop( vDivs ); |
| // add remaining fanins of the node |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( !Acb_ObjSetTravIdCur(p, iFanin) ) |
| Vec_IntPush( vDivs, iFanin ); |
| /* |
| // start from critical fanins |
| assert( Acb_ObjLevelD( p, Pivot ) > 1 ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( Acb_ObjIsAreaCritical( p, iFanin ) ) |
| Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin, vDivs ); |
| // add non-critical fanins |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( !Acb_ObjIsAreaCritical( p, iFanin ) ) |
| if ( !Acb_ObjSetTravIdCur(p, iFanin) ) |
| Vec_IntPush( vDivs, iFanin ); |
| */ |
| } |
| return vDivs; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Marks TFO of divisors.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_ObjMarkTfo_rec( Acb_Ntk_t * p, int iObj, int nTfoLevMax, int nFanMax, Vec_Int_t * vMarked ) |
| { |
| int iFanout, i; |
| if ( Acb_ObjSetTravIdCur(p, iObj) ) |
| return; |
| Vec_IntPush( vMarked, iObj ); |
| if ( Acb_ObjLevelD(p, iObj) > nTfoLevMax || Acb_ObjFanoutNum(p, iObj) > nFanMax ) |
| return; |
| Acb_ObjForEachFanout( p, iObj, iFanout, i ) |
| Acb_ObjMarkTfo_rec( p, iFanout, nTfoLevMax, nFanMax, vMarked ); |
| } |
| Vec_Int_t * Acb_ObjMarkTfo( Acb_Ntk_t * p, Vec_Int_t * vDivs, int Pivot, int nTfoLevMax, int nFanMax ) |
| { |
| Vec_Int_t * vMarked = Vec_IntAlloc( 1000 ); |
| int i, iObj; |
| Acb_NtkIncTravId( p ); |
| Acb_ObjSetTravIdCur( p, Pivot ); |
| Vec_IntPush( vMarked, Pivot ); |
| Vec_IntForEachEntry( vDivs, iObj, i ) |
| Acb_ObjMarkTfo_rec( p, iObj, nTfoLevMax, nFanMax, vMarked ); |
| return vMarked; |
| } |
| void Acb_ObjMarkTfo2( Acb_Ntk_t * p, Vec_Int_t * vMarked ) |
| { |
| int i, Node; |
| Acb_NtkIncTravId( p ); |
| Vec_IntForEachEntry( vMarked, Node, i ) |
| Acb_ObjSetTravIdCur( p, Node ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Labels TFO nodes with {none, root, inner} based on their type.] |
| |
| Description [Assuming TFO of TFI is marked with the current trav ID.] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Acb_ObjLabelTfo_rec( Acb_Ntk_t * p, int iObj, int nTfoLevMax, int nFanMax, int fFirst ) |
| { |
| int iFanout, i, Diff, fHasNone = 0; |
| if ( (Diff = Acb_ObjTravIdDiff(p, iObj)) <= 2 ) |
| return Diff; |
| Acb_ObjSetTravIdDiff( p, iObj, 2 ); |
| if ( Acb_ObjIsCo(p, iObj) || Acb_ObjLevelD(p, iObj) > nTfoLevMax ) |
| return 2; |
| if ( Acb_ObjLevelD(p, iObj) == nTfoLevMax || Acb_ObjFanoutNum(p, iObj) > nFanMax ) |
| { |
| if ( Diff == 3 ) // belongs to TFO of TFI |
| Acb_ObjSetTravIdDiff( p, iObj, 1 ); // root |
| return Acb_ObjTravIdDiff(p, iObj); |
| } |
| Acb_ObjForEachFanout( p, iObj, iFanout, i ) |
| if ( !fFirst || Acb_ObjIsDelayCriticalFanin(p, iFanout, iObj) ) |
| fHasNone |= 2 == Acb_ObjLabelTfo_rec( p, iFanout, nTfoLevMax, nFanMax, 0 ); |
| if ( fHasNone && Diff == 3 ) // belongs to TFO of TFI |
| Acb_ObjSetTravIdDiff( p, iObj, 1 ); // root |
| else if ( !fHasNone ) |
| Acb_ObjSetTravIdDiff( p, iObj, 0 ); // inner |
| return Acb_ObjTravIdDiff(p, iObj); |
| } |
| int Acb_ObjLabelTfo( Acb_Ntk_t * p, int Root, int nTfoLevMax, int nFanMax, int fDelay ) |
| { |
| Acb_NtkIncTravId( p ); // none (2) marked (3) unmarked (4) |
| Acb_NtkIncTravId( p ); // root (1) |
| Acb_NtkIncTravId( p ); // inner (0) |
| assert( Acb_ObjTravIdDiff(p, Root) > 2 ); |
| return Acb_ObjLabelTfo_rec( p, Root, nTfoLevMax, nFanMax, fDelay ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collects labeled TFO.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_ObjDeriveTfo_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfo, Vec_Int_t * vRoots, int fFirst ) |
| { |
| int iFanout, i, Diff = Acb_ObjTravIdDiff(p, iObj); |
| if ( Acb_ObjSetTravIdCur(p, iObj) ) |
| return; |
| if ( Diff == 2 ) // root |
| { |
| Vec_IntPush( vRoots, iObj ); |
| Vec_IntPush( vTfo, iObj ); |
| return; |
| } |
| assert( Diff == 1 ); |
| Acb_ObjForEachFanout( p, iObj, iFanout, i ) |
| if ( !fFirst || Acb_ObjIsDelayCriticalFanin(p, iFanout, iObj) ) |
| Acb_ObjDeriveTfo_rec( p, iFanout, vTfo, vRoots, 0 ); |
| Vec_IntPush( vTfo, iObj ); |
| } |
| void Acb_ObjDeriveTfo( Acb_Ntk_t * p, int Pivot, int nTfoLevMax, int nFanMax, Vec_Int_t ** pvTfo, Vec_Int_t ** pvRoots, int fDelay ) |
| { |
| int Res = Acb_ObjLabelTfo( p, Pivot, nTfoLevMax, nFanMax, fDelay ); |
| Vec_Int_t * vTfo = *pvTfo = Vec_IntAlloc( 10 ); |
| Vec_Int_t * vRoots = *pvRoots = Vec_IntAlloc( 10 ); |
| if ( Res ) // none or root |
| return; |
| Acb_NtkIncTravId( p ); // root (2) inner (1) visited (0) |
| Acb_ObjDeriveTfo_rec( p, Pivot, vTfo, vRoots, fDelay ); |
| assert( Vec_IntEntryLast(vTfo) == Pivot ); |
| Vec_IntPop( vTfo ); |
| assert( Vec_IntEntryLast(vRoots) != Pivot ); |
| Vec_IntReverseOrder( vTfo ); |
| Vec_IntReverseOrder( vRoots ); |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collect side-inputs of the TFO, except the node.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Vec_Int_t * Acb_NtkCollectTfoSideInputs( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vTfo ) |
| { |
| Vec_Int_t * vSide = Vec_IntAlloc( 100 ); |
| int i, k, Node, iFanin, * pFanins; |
| Acb_NtkIncTravId( p ); |
| Vec_IntPush( vTfo, Pivot ); |
| Vec_IntForEachEntry( vTfo, Node, i ) |
| Acb_ObjSetTravIdCur( p, Node ); |
| Vec_IntForEachEntry( vTfo, Node, i ) |
| Acb_ObjForEachFaninFast( p, Node, pFanins, iFanin, k ) |
| if ( !Acb_ObjSetTravIdCur(p, iFanin) && iFanin != Pivot ) |
| Vec_IntPush( vSide, iFanin ); |
| Vec_IntPop( vTfo ); |
| return vSide; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [From side inputs, collect marked nodes and their unmarked fanins.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_NtkCollectNewTfi1_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfiNew ) |
| { |
| int i, iFanin, * pFanins; |
| if ( !Acb_ObjIsTravIdPrev(p, iObj) ) |
| return; |
| if ( Acb_ObjSetTravIdCur(p, iObj) ) |
| return; |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, i ) |
| Acb_NtkCollectNewTfi1_rec( p, iFanin, vTfiNew ); |
| Vec_IntPush( vTfiNew, iObj ); |
| } |
| void Acb_NtkCollectNewTfi2_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfiNew ) |
| { |
| int i, iFanin, * pFanins; |
| int fTravIdPrev = Acb_ObjIsTravIdPrev(p, iObj); |
| if ( Acb_ObjSetTravIdCur(p, iObj) ) |
| return; |
| if ( fTravIdPrev && !Acb_ObjIsCi(p, iObj) ) |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, i ) |
| Acb_NtkCollectNewTfi2_rec( p, iFanin, vTfiNew ); |
| Vec_IntPush( vTfiNew, iObj ); |
| } |
| Vec_Int_t * Acb_NtkCollectNewTfi( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vDivs, Vec_Int_t * vSide, int * pnDivs ) |
| { |
| Vec_Int_t * vTfiNew = Vec_IntAlloc( 100 ); |
| int i, Node; |
| Acb_NtkIncTravId( p ); |
| //Acb_NtkPrintVec( p, vDivs, "vDivs" ); |
| Vec_IntForEachEntry( vDivs, Node, i ) |
| Acb_NtkCollectNewTfi1_rec( p, Node, vTfiNew ); |
| //Acb_NtkPrintVec( p, vTfiNew, "vTfiNew" ); |
| Acb_NtkCollectNewTfi1_rec( p, Pivot, vTfiNew ); |
| //Acb_NtkPrintVec( p, vTfiNew, "vTfiNew" ); |
| assert( Vec_IntEntryLast(vTfiNew) == Pivot ); |
| Vec_IntPop( vTfiNew ); |
| /* |
| Vec_IntForEachEntry( vDivs, Node, i ) |
| { |
| Acb_ObjSetTravIdCur( p, Node ); |
| Vec_IntPush( vTfiNew, Node ); |
| } |
| */ |
| *pnDivs = Vec_IntSize(vTfiNew); |
| Vec_IntForEachEntry( vSide, Node, i ) |
| Acb_NtkCollectNewTfi2_rec( p, Node, vTfiNew ); |
| Vec_IntPush( vTfiNew, Pivot ); |
| return vTfiNew; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Vec_Int_t * Acb_NtkCollectWindow( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vTfi, Vec_Int_t * vTfo, Vec_Int_t * vRoots ) |
| { |
| Vec_Int_t * vWin = Vec_IntAlloc( 100 ); |
| int i, k, iObj, iFanin, * pFanins; |
| assert( Vec_IntEntryLast(vTfi) == Pivot ); |
| // mark nodes |
| Acb_NtkIncTravId( p ); |
| Vec_IntForEachEntry( vTfi, iObj, i ) |
| Acb_ObjSetTravIdCur(p, iObj); |
| // add TFI |
| Vec_IntForEachEntry( vTfi, iObj, i ) |
| { |
| int fIsTfiInput = 0; |
| Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) |
| if ( !Acb_ObjIsTravIdCur(p, iFanin) ) // fanin is not in TFI |
| fIsTfiInput = 1; // mark as leaf |
| Vec_IntPush( vWin, Abc_Var2Lit(iObj, Acb_ObjIsCi(p, iObj) || fIsTfiInput) ); |
| } |
| // mark roots |
| Acb_NtkIncTravId( p ); |
| Vec_IntForEachEntry( vRoots, iObj, i ) |
| Acb_ObjSetTravIdCur(p, iObj); |
| // add TFO |
| Vec_IntForEachEntry( vTfo, iObj, i ) |
| { |
| assert( !Acb_ObjIsCo(p, iObj) ); |
| Vec_IntPush( vWin, Abc_Var2Lit(iObj, Acb_ObjIsTravIdCur(p, iObj)) ); |
| } |
| return vWin; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Vec_Int_t * Acb_NtkWindow( Acb_Ntk_t * p, int Pivot, int nTfiLevs, int nTfoLevs, int nFanMax, int fDelay, int * pnDivs ) |
| { |
| int fVerbose = 0; |
| //int nTfiLevMin = Acb_ObjLevelD(p, Pivot) - nTfiLevs; |
| int nTfoLevMax = Acb_ObjLevelD(p, Pivot) + nTfoLevs; |
| Vec_Int_t * vWin, * vDivs, * vMarked, * vTfo, * vRoots, * vSide, * vTfi; |
| // collect divisors by traversing limited TFI |
| vDivs = Acb_NtkDivisors( p, Pivot, nTfiLevs, fDelay ); |
| if ( fVerbose ) Acb_NtkPrintVec( p, vDivs, "vDivs" ); |
| // mark limited TFO of the divisors |
| vMarked = Acb_ObjMarkTfo( p, vDivs, Pivot, nTfoLevMax, nFanMax ); |
| // collect TFO and roots |
| Acb_ObjDeriveTfo( p, Pivot, nTfoLevMax, nFanMax, &vTfo, &vRoots, 0 );//fDelay ); |
| if ( fVerbose ) Acb_NtkPrintVec( p, vTfo, "vTfo" ); |
| if ( fVerbose ) Acb_NtkPrintVec( p, vRoots, "vRoots" ); |
| // collect side inputs of the TFO |
| vSide = Acb_NtkCollectTfoSideInputs( p, Pivot, vTfo ); |
| if ( fVerbose ) Acb_NtkPrintVec( p, vSide, "vSide" ); |
| // mark limited TFO of the divisors |
| //Acb_ObjMarkTfo( p, vDivs, Pivot, nTfoLevMax, nFanMax ); |
| Acb_ObjMarkTfo2( p, vMarked ); |
| Vec_IntFree( vMarked ); |
| // collect new TFI |
| vTfi = Acb_NtkCollectNewTfi( p, Pivot, vDivs, vSide, pnDivs ); |
| if ( fVerbose ) Acb_NtkPrintVec( p, vTfi, "vTfi" ); |
| Vec_IntFree( vSide ); |
| Vec_IntFree( vDivs ); |
| // collect all nodes |
| vWin = Acb_NtkCollectWindow( p, Pivot, vTfi, vTfo, vRoots ); |
| // cleanup |
| Vec_IntFree( vTfi ); |
| Vec_IntFree( vTfo ); |
| Vec_IntFree( vRoots ); |
| return vWin; |
| } |
| |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline void Vec_IntVars2Vars( Vec_Int_t * p, int Shift ) |
| { |
| int i; |
| for ( i = 0; i < p->nSize; i++ ) |
| p->pArray[i] += Shift; |
| } |
| static inline void Vec_IntVars2Lits( Vec_Int_t * p, int Shift, int fCompl ) |
| { |
| int i; |
| for ( i = 0; i < p->nSize; i++ ) |
| p->pArray[i] = Abc_Var2Lit( p->pArray[i] + Shift, fCompl ); |
| } |
| static inline void Vec_IntLits2Vars( Vec_Int_t * p, int Shift ) |
| { |
| int i; |
| for ( i = 0; i < p->nSize; i++ ) |
| p->pArray[i] = Abc_Lit2Var( p->pArray[i] ) + Shift; |
| } |
| static inline void Vec_IntRemap( Vec_Int_t * p, Vec_Int_t * vMap ) |
| { |
| int i; |
| for ( i = 0; i < p->nSize; i++ ) |
| p->pArray[i] = Vec_IntEntry(vMap, p->pArray[i]); |
| } |
| |
| static inline void Acb_WinPrint( Acb_Ntk_t * p, Vec_Int_t * vWin, int Pivot, int nDivs ) |
| { |
| int i, Node; |
| printf( "Window for node %d with %d divisors:\n", Pivot, nDivs ); |
| Vec_IntForEachEntry( vWin, Node, i ) |
| { |
| if ( i == nDivs ) |
| printf( " | " ); |
| if ( Abc_Lit2Var(Node) == Pivot ) |
| printf( "(%d) ", Pivot ); |
| else |
| printf( "%s%d ", Abc_LitIsCompl(Node) ? "*":"", Abc_Lit2Var(Node) ); |
| } |
| printf( "\n" ); |
| } |
| |
| static inline void Acb_NtkOrderByRefCount( Acb_Ntk_t * p, Vec_Int_t * vSupp ) |
| { |
| int i, j, best_i, nSize = Vec_IntSize(vSupp); |
| int * pArray = Vec_IntArray(vSupp); |
| for ( i = 0; i < nSize-1; i++ ) |
| { |
| best_i = i; |
| for ( j = i+1; j < nSize; j++ ) |
| if ( Acb_ObjFanoutNum(p, pArray[j]) > Acb_ObjFanoutNum(p, pArray[best_i]) ) |
| best_i = j; |
| ABC_SWAP( int, pArray[i], pArray[best_i] ); |
| } |
| } |
| |
| static inline void Acb_NtkRemapIntoSatVariables( Acb_Ntk_t * p, Vec_Int_t * vSupp ) |
| { |
| int k, iFanin; |
| Vec_IntForEachEntry( vSupp, iFanin, k ) |
| { |
| assert( Acb_ObjFunc(p, iFanin) >= 0 ); |
| Vec_IntWriteEntry( vSupp, k, Acb_ObjFunc(p, iFanin) ); |
| } |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Acb_NtkFindSupp1( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp ) |
| { |
| int nSuppNew, status, k, iFanin, * pFanins; |
| Vec_IntClear( vSupp ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| Vec_IntPush( vSupp, iFanin ); |
| Acb_NtkOrderByRefCount( p, vSupp ); |
| Acb_NtkRemapIntoSatVariables( p, vSupp ); |
| Vec_IntVars2Lits( vSupp, 2*nVars, 0 ); |
| status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| printf( "Failed internal check at node %d.\n", Pivot ); |
| assert( status == l_False ); |
| nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 ); |
| Vec_IntShrink( vSupp, nSuppNew ); |
| Vec_IntLits2Vars( vSupp, -2*nVars ); |
| return Vec_IntSize(vSupp) < Acb_ObjFaninNum(p, Pivot); |
| } |
| |
| static int StrCount = 0; |
| |
| int Acb_NtkFindSupp2( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp, int nLutSize, int fDelay ) |
| { |
| int nSuppNew, status, k, iFanin, * pFanins, k2, iFanin2, * pFanins2; |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| assert( Acb_ObjFunc(p, iFanin) >= 0 && Acb_ObjFunc(p, iFanin) < nDivs ); |
| if ( fDelay ) |
| { |
| // add non-timing-critical fanins |
| int nNonCrits, k2, iFanin2 = 0, * pFanins2; |
| assert( Acb_ObjLevelD( p, Pivot ) > 1 ); |
| Vec_IntClear( vSupp ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( !Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) ) |
| Vec_IntPush( vSupp, iFanin ); |
| nNonCrits = Vec_IntSize(vSupp); |
| // add fanins of timing critical fanins |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| if ( Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) ) |
| Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 ) |
| Vec_IntPushUnique( vSupp, iFanin2 ); |
| assert( nNonCrits < Vec_IntSize(vSupp) ); |
| // sort additional fanins by level |
| Vec_IntSelectSortCost( Vec_IntArray(vSupp) + nNonCrits, Vec_IntSize(vSupp) - nNonCrits, &p->vLevelD ); |
| // translate to SAT vars |
| Vec_IntForEachEntry( vSupp, iFanin, k ) |
| { |
| assert( Acb_ObjFunc(p, iFanin) >= 0 ); |
| Vec_IntWriteEntry( vSupp, k, Acb_ObjFunc(p, iFanin) ); |
| } |
| // solve for these fanins |
| Vec_IntVars2Lits( vSupp, 2*nVars, 0 ); |
| status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| printf( "Failed internal check at node %d.\n", Pivot ); |
| assert( status == l_False ); |
| nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 ); |
| Vec_IntShrink( vSupp, nSuppNew ); |
| Vec_IntLits2Vars( vSupp, -2*nVars ); |
| return Vec_IntSize(vSupp) <= nLutSize; |
| } |
| // iterate through different fanout free cones |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| { |
| if ( !Acb_ObjIsAreaCritical(p, iFanin) ) |
| continue; |
| // collect fanins of the root node |
| Vec_IntClear( vSupp ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins2, iFanin2, k2 ) |
| if ( iFanin != iFanin2 ) |
| Vec_IntPush( vSupp, iFanin2 ); |
| // collect fanins of the selected node |
| Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 ) |
| Vec_IntPushUnique( vSupp, iFanin2 ); |
| // sort fanins by level |
| Vec_IntSelectSortCost( Vec_IntArray(vSupp), Vec_IntSize(vSupp), &p->vLevelD ); |
| //Acb_NtkOrderByRefCount( p, vSupp ); |
| Acb_NtkRemapIntoSatVariables( p, vSupp ); |
| // solve for these fanins |
| Vec_IntVars2Lits( vSupp, 2*nVars, 0 ); |
| status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| printf( "Failed internal check at node %d.\n", Pivot ); |
| assert( status == l_False ); |
| nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 ); |
| Vec_IntShrink( vSupp, nSuppNew ); |
| Vec_IntLits2Vars( vSupp, -2*nVars ); |
| if ( Vec_IntSize(vSupp) <= nLutSize ) |
| return 1; |
| } |
| return 0; |
| } |
| |
| int Acb_NtkFindSupp3( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp, int nLutSize, int fDelay ) |
| { |
| int nSuppNew, status, k, iFanin, * pFanins, k2, iFanin2, * pFanins2, k3, iFanin3, * pFanins3, NodeMark; |
| |
| if ( fDelay ) |
| return 0; |
| |
| // iterate through pairs of fanins with one fanouts |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| { |
| if ( !Acb_ObjIsAreaCritical(p, iFanin) ) |
| continue; |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins2, iFanin2, k2 ) |
| { |
| if ( !Acb_ObjIsAreaCritical(p, iFanin2) || k2 == k ) |
| continue; |
| // iFanin and iFanin2 have 1 fanout |
| assert( iFanin != iFanin2 ); |
| |
| // collect fanins of the root node |
| Vec_IntClear( vSupp ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins3, iFanin3, k3 ) |
| if ( iFanin3 != iFanin && iFanin3 != iFanin2 ) |
| { |
| assert( Acb_ObjFunc(p, iFanin3) >= 0 ); |
| Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars, 0) ); |
| } |
| NodeMark = Vec_IntSize(vSupp); |
| |
| // collect fanins of the second node |
| Acb_ObjForEachFaninFast( p, iFanin, pFanins3, iFanin3, k3 ) |
| { |
| assert( Acb_ObjFunc(p, iFanin3) >= 0 ); |
| Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) ); |
| } |
| // collect fanins of the third node |
| Acb_ObjForEachFaninFast( p, iFanin2, pFanins3, iFanin3, k3 ) |
| { |
| assert( Acb_ObjFunc(p, iFanin3) >= 0 ); |
| Vec_IntPushUnique( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) ); |
| } |
| assert( Vec_IntCheckUniqueSmall(vSupp) ); |
| |
| // sort fanins by level |
| //Vec_IntSelectSortCost( Vec_IntArray(vSupp) + NodeMark, Vec_IntSize(vSupp) - NodeMark, &p->vLevelD ); |
| // solve for these fanins |
| status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| continue; |
| assert( status == l_False ); |
| nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 ); |
| Vec_IntShrink( vSupp, nSuppNew ); |
| Vec_IntLits2Vars( vSupp, -6*nVars ); |
| Vec_IntSort( vSupp, 1 ); |
| // count how many belong to H; the rest belong to G |
| NodeMark = 0; |
| Vec_IntForEachEntry( vSupp, iFanin3, k3 ) |
| if ( iFanin3 >= nDivs ) |
| Vec_IntWriteEntry( vSupp, k3, iFanin3 - nDivs ); |
| else |
| NodeMark++; |
| if ( NodeMark == 0 ) |
| { |
| //printf( "Obj %d: Special case 1 (vars = %d)\n", Pivot, Vec_IntSize(vSupp) ); |
| continue; |
| } |
| assert( NodeMark > 0 ); |
| if ( Vec_IntSize(vSupp) - NodeMark <= nLutSize ) |
| return NodeMark; |
| } |
| } |
| |
| // iterate through fanins with one fanout and their fanins with one fanout |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k ) |
| { |
| if ( !Acb_ObjIsAreaCritical(p, iFanin) ) |
| continue; |
| Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 ) |
| { |
| if ( !Acb_ObjIsAreaCritical(p, iFanin2) ) |
| continue; |
| // iFanin and iFanin2 have 1 fanout |
| assert( iFanin != iFanin2 ); |
| |
| // collect fanins of the root node |
| Vec_IntClear( vSupp ); |
| Acb_ObjForEachFaninFast( p, Pivot, pFanins3, iFanin3, k3 ) |
| if ( iFanin3 != iFanin && iFanin3 != iFanin2 ) |
| Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars, 0) ); |
| NodeMark = Vec_IntSize(vSupp); |
| |
| // collect fanins of the second node |
| Acb_ObjForEachFaninFast( p, iFanin, pFanins3, iFanin3, k3 ) |
| if ( iFanin3 != iFanin2 ) |
| Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) ); |
| // collect fanins of the third node |
| Acb_ObjForEachFaninFast( p, iFanin2, pFanins3, iFanin3, k3 ) |
| { |
| assert( Acb_ObjFunc(p, iFanin3) >= 0 ); |
| Vec_IntPushUnique( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) ); |
| } |
| assert( Vec_IntCheckUniqueSmall(vSupp) ); |
| |
| // sort fanins by level |
| //Vec_IntSelectSortCost( Vec_IntArray(vSupp) + NodeMark, Vec_IntSize(vSupp) - NodeMark, &p->vLevelD ); |
| //Sat_SolverWriteDimacs( pSat, NULL, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0 ); |
| // solve for these fanins |
| status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 ); |
| if ( status != l_False ) |
| printf( "Failed internal check at node %d.\n", Pivot ); |
| assert( status == l_False ); |
| nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 ); |
| Vec_IntShrink( vSupp, nSuppNew ); |
| Vec_IntLits2Vars( vSupp, -6*nVars ); |
| Vec_IntSort( vSupp, 1 ); |
| // count how many belong to H; the rest belong to G |
| NodeMark = 0; |
| Vec_IntForEachEntry( vSupp, iFanin3, k3 ) |
| if ( iFanin3 >= nDivs ) |
| Vec_IntWriteEntry( vSupp, k3, iFanin3 - nDivs ); |
| else |
| NodeMark++; |
| if ( NodeMark == 0 ) |
| { |
| //printf( "Obj %d: Special case 2 (vars = %d)\n", Pivot, Vec_IntSize(vSupp) ); |
| continue; |
| } |
| assert( NodeMark > 0 ); |
| if ( Vec_IntSize(vSupp) - NodeMark <= nLutSize ) |
| return NodeMark; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| typedef struct Acb_Mfs_t_ Acb_Mfs_t; |
| struct Acb_Mfs_t_ |
| { |
| Acb_Ntk_t * pNtk; // network |
| Acb_Par_t * pPars; // parameters |
| sat_solver * pSat[3]; // SAT solvers |
| Vec_Int_t * vSupp; // support |
| Vec_Int_t * vFlip; // support |
| Vec_Int_t * vValues; // support |
| int nNodes; // nodes |
| int nWins; // windows |
| int nWinsAll; // windows |
| int nDivsAll; // windows |
| int nChanges[8]; // changes |
| int nOvers; // overflows |
| int nTwoNodes; // two nodes |
| abctime timeTotal; |
| abctime timeCnf; |
| abctime timeSol; |
| abctime timeWin; |
| abctime timeSat; |
| abctime timeSatU; |
| abctime timeSatS; |
| }; |
| Acb_Mfs_t * Acb_MfsStart( Acb_Ntk_t * pNtk, Acb_Par_t * pPars ) |
| { |
| Acb_Mfs_t * p = ABC_CALLOC( Acb_Mfs_t, 1 ); |
| p->pNtk = pNtk; |
| p->pPars = pPars; |
| p->timeTotal = Abc_Clock(); |
| p->pSat[0] = sat_solver_new(); |
| p->pSat[1] = sat_solver_new(); |
| p->pSat[2] = sat_solver_new(); |
| p->vSupp = Vec_IntAlloc(100); |
| p->vFlip = Vec_IntAlloc(100); |
| p->vValues = Vec_IntAlloc(100); |
| return p; |
| } |
| void Acb_MfsStop( Acb_Mfs_t * p ) |
| { |
| Vec_IntFree( p->vFlip ); |
| Vec_IntFree( p->vSupp ); |
| Vec_IntFree( p->vValues ); |
| sat_solver_delete( p->pSat[0] ); |
| sat_solver_delete( p->pSat[1] ); |
| sat_solver_delete( p->pSat[2] ); |
| ABC_FREE( p ); |
| } |
| static inline int Acb_NtkObjMffcEstimate( Acb_Ntk_t * pNtk, int iObj ) |
| { |
| int k, iFanin, * pFanins, Count = 0, iFaninCrit = -1; |
| Acb_ObjForEachFaninFast( pNtk, iObj, pFanins, iFanin, k ) |
| if ( Acb_ObjIsAreaCritical(pNtk, iFanin) ) |
| iFaninCrit = iFanin, Count++; |
| if ( Count != 1 ) |
| return Count; |
| Acb_ObjForEachFaninFast( pNtk, iFaninCrit, pFanins, iFanin, k ) |
| if ( Acb_ObjIsAreaCritical(pNtk, iFanin) ) |
| Count++; |
| return Count; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_NtkOptNodeAnalyze( Acb_Mfs_t * p, int PivotVar, int nDivs, int nValues, int * pValues, Vec_Int_t * vSupp ) |
| { |
| word OnSet[64] = {0}; |
| word OffSet[64] = {0}; |
| word Diffs[64] = {0}; |
| int s, nScope = 1 + 2*nDivs, d, i; |
| int f, nFrames = nValues / nScope; |
| int start = nDivs < 64 ? 0 : nDivs - 64; |
| int stop = nDivs < 64 ? nDivs : 64; |
| assert( nValues % nScope == 0 ); |
| assert( nFrames <= 16 ); |
| for ( f = 0; f < nFrames; f++ ) |
| { |
| int * pStart = pValues + f * nScope; |
| int * pOnSet = pStart + 1 + (pStart[0] ? 0 : nDivs); |
| int * pOffSet = pStart + 1 + (pStart[0] ? nDivs : 0); |
| |
| printf( "%2d:", f ); |
| for ( s = start; s < stop; s++ ) |
| printf( "%d", pOnSet[s] ); |
| printf( "\n" ); |
| |
| printf( "%2d:", f ); |
| for ( s = start; s < stop; s++ ) |
| printf( "%d", pOffSet[s] ); |
| printf( "\n" ); |
| |
| for ( s = start; s < stop; s++ ) |
| { |
| if ( pOnSet[s] ) OnSet[f] |= (((word)1) << (s-start)); |
| if ( pOffSet[s] ) OffSet[f] |= (((word)1) << (s-start)); |
| } |
| } |
| d = 0; |
| for ( f = 0; f < nFrames; f++ ) |
| for ( s = 0; s < nFrames; s++ ) |
| { |
| for ( i = 0; i < d; i++ ) |
| if ( Diffs[i] == (OnSet[f] ^ OffSet[s]) ) |
| break; |
| if ( i < d ) |
| continue; |
| if ( d < 64 ) |
| Diffs[d++] = OnSet[f] ^ OffSet[s]; |
| } |
| |
| printf( "Divisors = %d. Frames = %d. Patterns = %d.\n", nDivs, nFrames, d ); |
| printf( " " ); |
| for ( s = start; s < stop; s++ ) |
| printf( "%d", s / 10 ); |
| printf( "\n" ); |
| printf( " " ); |
| for ( s = start; s < stop; s++ ) |
| printf( "%d", s % 10 ); |
| printf( "\n" ); |
| printf( " " ); |
| for ( s = start; s < stop; s++ ) |
| printf( "%c", Vec_IntFind(vSupp, s) >= 0 ? 'a' + Vec_IntFind(vSupp, s) : ' ' ); |
| printf( "\n" ); |
| for ( s = 0; s < d; s++ ) |
| { |
| printf( "%2d:", s ); |
| for ( f = 0; f < stop; f++ ) |
| printf( "%c", ((Diffs[s] >> f) & 1) ? '*' : ' ' ); |
| printf( "\n" ); |
| } |
| } |
| |
| int Acb_NtkOptNode( Acb_Mfs_t * p, int Pivot ) |
| { |
| Cnf_Dat_t * pCnf = NULL; abctime clk; |
| Vec_Int_t * vWin = NULL; word uTruth; |
| int Result, PivotVar, nDivs = 0, RetValue = 0, c; |
| assert( Acb_ObjFanoutNum(p->pNtk, Pivot) > 0 ); |
| p->nWins++; |
| |
| // compute divisors and window for this target node with these taboo nodes |
| clk = Abc_Clock(); |
| vWin = Acb_NtkWindow( p->pNtk, Pivot, p->pPars->nTfiLevMax, p->pPars->nTfoLevMax, p->pPars->nFanoutMax, !p->pPars->fArea, &nDivs ); |
| p->nWinsAll += Vec_IntSize(vWin); |
| p->nDivsAll += nDivs; |
| p->timeWin += Abc_Clock() - clk; |
| PivotVar = Vec_IntFind( vWin, Abc_Var2Lit(Pivot, 0) ); |
| if ( p->pPars->fVerbose ) |
| printf( "Node %d: Window contains %d objects and %d divisors. ", Pivot, Vec_IntSize(vWin), nDivs ); |
| // Acb_WinPrint( p->pNtk, vWin, Pivot, nDivs ); |
| // Acb_NtkPrintVecWin( p->pNtk, vWin, "Win" ); |
| if ( Vec_IntSize(vWin) > p->pPars->nWinNodeMax ) |
| { |
| p->nOvers++; |
| if ( p->pPars->fVerbose ) |
| printf( "Too many divisors.\n" ); |
| goto cleanup; |
| } |
| |
| // derive CNF |
| clk = Abc_Clock(); |
| pCnf = Acb_NtkWindow2Cnf( p->pNtk, vWin, Pivot ); |
| assert( PivotVar == Acb_ObjFunc(p->pNtk, Pivot) ); |
| Cnf_DataCollectFlipLits( pCnf, PivotVar, p->vFlip ); |
| p->timeCnf += Abc_Clock() - clk; |
| |
| // derive SAT solver |
| clk = Abc_Clock(); |
| Acb_NtkWindow2Solver( p->pSat[0], pCnf, p->vFlip, PivotVar, nDivs, 1 ); |
| p->timeSol += Abc_Clock() - clk; |
| // check constants |
| for ( c = 0; c < 2; c++ ) |
| { |
| int Lit = Abc_Var2Lit( PivotVar, c ); |
| int status = sat_solver_solve( p->pSat[0], &Lit, &Lit + 1, 0, 0, 0, 0 ); |
| if ( status == l_False ) |
| { |
| p->nChanges[0]++; |
| if ( p->pPars->fVerbose ) |
| printf( "Found constant %d.\n", c ); |
| Acb_NtkUpdateNode( p->pNtk, Pivot, c ? ~(word)0 : 0, NULL ); |
| RetValue = 1; |
| goto cleanup; |
| } |
| assert( status == l_True ); |
| } |
| |
| // derive SAT solver |
| clk = Abc_Clock(); |
| Acb_NtkWindow2Solver( p->pSat[1], pCnf, p->vFlip, PivotVar, nDivs, 2 ); |
| p->timeSol += Abc_Clock() - clk; |
| |
| // try to remove useless fanins |
| if ( p->pPars->fArea ) |
| { |
| int fEnableProfile = 0; |
| if ( fEnableProfile ) |
| { |
| // alloc |
| if ( p->pSat[1]->user_values.cap == 0 ) |
| veci_new(&p->pSat[1]->user_values); |
| else |
| p->pSat[1]->user_values.size = 0; |
| if ( p->pSat[1]->user_vars.cap == 0 ) |
| veci_new(&p->pSat[1]->user_vars); |
| else |
| p->pSat[1]->user_vars.size = 0; |
| // set variables |
| veci_push(&p->pSat[1]->user_vars, PivotVar); |
| for ( c = 0; c < nDivs; c++ ) |
| veci_push(&p->pSat[1]->user_vars, c); |
| for ( c = 0; c < nDivs; c++ ) |
| veci_push(&p->pSat[1]->user_vars, c+pCnf->nVars); |
| } |
| |
| // perform solving |
| clk = Abc_Clock(); |
| Result = Acb_NtkFindSupp1( p->pNtk, Pivot, p->pSat[1], pCnf->nVars, nDivs, vWin, p->vSupp ); |
| p->timeSat += Abc_Clock() - clk; |
| // undo variables |
| p->pSat[1]->user_vars.size = 0; |
| if ( Result ) |
| { |
| if ( Vec_IntSize(p->vSupp) == 0 ) |
| p->nChanges[0]++; |
| else |
| p->nChanges[1]++; |
| assert( Vec_IntSize(p->vSupp) < p->pPars->nLutSize ); |
| if ( p->pPars->fVerbose ) |
| printf( "Found %d inputs: ", Vec_IntSize(p->vSupp) ); |
| uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 ); |
| if ( p->pPars->fVerbose ) |
| Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) ); |
| if ( p->pPars->fVerbose ) |
| printf( "\n" ); |
| // create support in terms of nodes |
| Vec_IntRemap( p->vSupp, vWin ); |
| Vec_IntLits2Vars( p->vSupp, 0 ); |
| Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp ); |
| RetValue = 1; |
| goto cleanup; |
| } |
| if ( fEnableProfile ) |
| { |
| // analyze the resulting values |
| Acb_NtkOptNodeAnalyze( p, PivotVar, nDivs, p->pSat[1]->user_values.size, p->pSat[1]->user_values.ptr, p->vSupp ); |
| p->pSat[1]->user_values.size = 0; |
| } |
| } |
| |
| if ( Acb_NtkObjMffcEstimate(p->pNtk, Pivot) >= 1 ) |
| { |
| // check for one-node implementation |
| clk = Abc_Clock(); |
| Result = Acb_NtkFindSupp2( p->pNtk, Pivot, p->pSat[1], pCnf->nVars, nDivs, vWin, p->vSupp, p->pPars->nLutSize, !p->pPars->fArea ); |
| p->timeSat += Abc_Clock() - clk; |
| if ( Result ) |
| { |
| p->nChanges[2]++; |
| assert( Vec_IntSize(p->vSupp) <= p->pPars->nLutSize ); |
| if ( p->pPars->fVerbose ) |
| printf( "Found %d inputs: ", Vec_IntSize(p->vSupp) ); |
| uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 ); |
| if ( p->pPars->fVerbose ) |
| Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) ); |
| if ( p->pPars->fVerbose ) |
| printf( "\n" ); |
| // create support in terms of nodes |
| Vec_IntRemap( p->vSupp, vWin ); |
| Vec_IntLits2Vars( p->vSupp, 0 ); |
| Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp ); |
| RetValue = 1; |
| goto cleanup; |
| } |
| } |
| |
| //#if 0 |
| if ( p->pPars->fUseAshen && Acb_NtkObjMffcEstimate(p->pNtk, Pivot) >= 2 )// && Pivot != 70 ) |
| { |
| p->nTwoNodes++; |
| // derive SAT solver |
| clk = Abc_Clock(); |
| Acb_NtkWindow2Solver( p->pSat[2], pCnf, p->vFlip, PivotVar, nDivs, 6 ); |
| p->timeSol += Abc_Clock() - clk; |
| |
| // check for two-node implementation |
| clk = Abc_Clock(); |
| Result = Acb_NtkFindSupp3( p->pNtk, Pivot, p->pSat[2], pCnf->nVars, nDivs, vWin, p->vSupp, p->pPars->nLutSize, !p->pPars->fArea ); |
| p->timeSat += Abc_Clock() - clk; |
| if ( Result ) |
| { |
| int fVerbose = 1; |
| int i, k, Lit, Var, Var2, status, NodeNew, fBecameUnsat = 0, fCompl = 0; |
| assert( Result < p->pPars->nLutSize ); |
| assert( Vec_IntSize(p->vSupp)-Result <= p->pPars->nLutSize ); |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( "Obj %5d: Found %d Hvars and %d Gvars: ", Pivot, Result, Vec_IntSize(p->vSupp)-Result ); |
| // p->vSupp contains G variables (Vec_IntSize(p->vSupp)-Result) followed by H variables (Result) |
| //sat_solver_restart( p->pSat[1] ); |
| //Acb_NtkWindow2Solver( p->pSat[1], pCnf, p->vFlip, PivotVar, nDivs, 2 ); |
| |
| // constrain H-variables to be equal |
| Vec_IntForEachEntryStart( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result ) // H variables |
| { |
| assert( Var >= 0 && Var < nDivs ); |
| assert( Var + 2*pCnf->nVars < sat_solver_nvars(p->pSat[1]) ); |
| Lit = Abc_Var2Lit( Var + 2*pCnf->nVars, 0 ); // HVars are the same |
| if ( !sat_solver_addclause( p->pSat[1], &Lit, &Lit + 1 ) ) |
| { if ( fVerbose || p->pPars->fVerbose ) printf( "Error: SAT solver became UNSAT at a wrong place (place 2). " ); fBecameUnsat = 1; } |
| } |
| // find one satisfying assighment |
| status = sat_solver_solve( p->pSat[1], NULL, NULL, 0, 0, 0, 0 ); |
| assert( status == l_True ); |
| // get assignment of the function |
| fCompl = !sat_solver_var_value( p->pSat[1], PivotVar ); |
| // constrain second set of G-vars to have values equal to the assignment |
| Vec_IntForEachEntryStop( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result ) // G variables |
| { |
| // check if this is a C-var |
| Vec_IntForEachEntryStart( p->vSupp, Var2, k, Vec_IntSize(p->vSupp)-Result ) // G variables |
| if ( Var == Var2 ) |
| break; |
| if ( k < Vec_IntSize(p->vSupp) ) // do not constrain a C-var |
| { |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( "Found C-var in object %d. ", Pivot ); |
| continue; |
| } |
| assert( Var >= 0 && Var < nDivs ); |
| Lit = sat_solver_var_literal( p->pSat[1], Var + pCnf->nVars ); |
| if ( !sat_solver_addclause( p->pSat[1], &Lit, &Lit + 1 ) ) |
| { if ( fVerbose || p->pPars->fVerbose ) printf( "Error: SAT solver became UNSAT at a wrong place (place 1). " ); fBecameUnsat = 1; } |
| } |
| if ( fBecameUnsat ) |
| { |
| StrCount++; |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( " Quitting.\n" ); |
| goto cleanup; |
| } |
| // consider only G variables |
| p->vSupp->nSize -= Result; |
| // truth table |
| uTruth = Acb_ComputeFunction( p->pSat[1], PivotVar, sat_solver_nvars(p->pSat[1])-1, p->vSupp, fCompl ); |
| if ( fVerbose || p->pPars->fVerbose ) |
| Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) ); |
| if ( uTruth == 0 || ~uTruth == 0 ) |
| { |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( " Quitting.\n" ); |
| goto cleanup; |
| } |
| p->nChanges[3]++; |
| // create new node |
| Vec_IntRemap( p->vSupp, vWin ); |
| Vec_IntLits2Vars( p->vSupp, 0 ); |
| NodeNew = Acb_NtkCreateNode( p->pNtk, uTruth, p->vSupp ); |
| Acb_DeriveCnfForWindowOne( p->pNtk, NodeNew ); |
| Acb_DeriveCnfForNode( p->pNtk, NodeNew, p->pSat[0], sat_solver_nvars(p->pSat[0])-2 ); |
| p->vSupp->nSize += Result; |
| // collect new variables |
| Vec_IntForEachEntryStart( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result ) |
| Vec_IntWriteEntry( p->vSupp, i-(Vec_IntSize(p->vSupp)-Result), Var ); |
| Vec_IntShrink( p->vSupp, Result ); |
| Vec_IntPush( p->vSupp, sat_solver_nvars(p->pSat[0])-2 ); |
| // truth table |
| uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 ); |
| // create new fanins of the node |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( " " ); |
| if ( fVerbose || p->pPars->fVerbose ) |
| Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) ); |
| if ( fVerbose || p->pPars->fVerbose ) |
| printf( "\n" ); |
| // create support in terms of nodes |
| Vec_IntPop( p->vSupp ); |
| Vec_IntRemap( p->vSupp, vWin ); |
| Vec_IntLits2Vars( p->vSupp, 0 ); |
| Vec_IntPush( p->vSupp, NodeNew ); |
| Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp ); |
| RetValue = 2; |
| goto cleanup; |
| } |
| } |
| //#endif |
| |
| if ( p->pPars->fVerbose ) |
| printf( "\n" ); |
| |
| cleanup: |
| sat_solver_restart( p->pSat[0] ); |
| sat_solver_restart( p->pSat[1] ); |
| sat_solver_restart( p->pSat[2] ); |
| if ( pCnf ) |
| { |
| Cnf_DataFree( pCnf ); |
| Acb_NtkWindowUndo( p->pNtk, vWin ); |
| } |
| Vec_IntFreeP( &vWin ); |
| return RetValue; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Acb_NtkOpt( Acb_Ntk_t * pNtk, Acb_Par_t * pPars ) |
| { |
| Acb_Mfs_t * pMan = Acb_MfsStart( pNtk, pPars ); |
| if ( pPars->fVerbose ) |
| printf( "%s-optimization parameters: TfiLev(I) = %d TfoLev(O) = %d WinMax(W) = %d LutSize = %d\n", |
| pMan->pPars->fArea ? "Area" : "Delay", pMan->pPars->nTfiLevMax, pMan->pPars->nTfoLevMax, pMan->pPars->nWinNodeMax, pMan->pPars->nLutSize ); |
| Acb_NtkCreateFanout( pNtk ); // fanout data structure |
| Acb_NtkCleanObjFuncs( pNtk ); // SAT variables |
| Acb_NtkCleanObjCnfs( pNtk ); // CNF representations |
| if ( pMan->pPars->fArea ) |
| { |
| int n = 0, iObj, RetValue, nNodes = Acb_NtkObjNumMax(pNtk); |
| Vec_Bit_t * vVisited = Vec_BitStart( Acb_NtkObjNumMax(pNtk) ); |
| Acb_NtkUpdateLevelD( pNtk, -1 ); // compute forward logic level |
| for ( n = 2; n >= 0; n-- ) |
| Acb_NtkForEachNode( pNtk, iObj ) |
| if ( iObj < nNodes && !Vec_BitEntry(vVisited, iObj) && Acb_NtkObjMffcEstimate(pNtk, iObj) >= n ) |
| { |
| pMan->nNodes++; |
| //if ( iObj != 103 ) |
| // continue; |
| //Acb_NtkOptNode( pMan, iObj ); |
| while ( (RetValue = Acb_NtkOptNode(pMan, iObj)) && Acb_ObjFaninNum(pNtk, iObj) ); |
| Vec_BitWriteEntry( vVisited, iObj, 1 ); |
| } |
| Vec_BitFree( vVisited ); |
| } |
| else |
| { |
| int Value; |
| Acb_NtkUpdateTiming( pNtk, -1 ); // compute delay information |
| while ( (Value = (int)Vec_QueTopPriority(pNtk->vQue)) > 0 ) |
| { |
| int iObj = Vec_QuePop(pNtk->vQue); |
| if ( !Acb_ObjType(pNtk, iObj) ) |
| continue; |
| //if ( iObj != 103 ) |
| // continue; |
| //printf( "Trying node %4d (%4d) ", iObj, Value ); |
| Acb_NtkOptNode( pMan, iObj ); |
| } |
| } |
| if ( pPars->fVerbose ) |
| { |
| pMan->timeTotal = Abc_Clock() - pMan->timeTotal; |
| printf( "Node = %d Win = %d (Ave = %d) DivAve = %d Change = %d C = %d N1 = %d N2 = %d N3 = %d Over = %d Str = %d 2Node = %d.\n", |
| pMan->nNodes, pMan->nWins, pMan->nWinsAll/Abc_MaxInt(1, pMan->nWins), pMan->nDivsAll/Abc_MaxInt(1, pMan->nWins), |
| pMan->nChanges[0] + pMan->nChanges[1] + pMan->nChanges[2] + pMan->nChanges[3], |
| pMan->nChanges[0], pMan->nChanges[1], pMan->nChanges[2], pMan->nChanges[3], pMan->nOvers, StrCount, pMan->nTwoNodes ); |
| ABC_PRTP( "Windowing ", pMan->timeWin, pMan->timeTotal ); |
| ABC_PRTP( "CNF compute", pMan->timeCnf, pMan->timeTotal ); |
| ABC_PRTP( "Make solver", pMan->timeSol, pMan->timeTotal ); |
| ABC_PRTP( "SAT solving", pMan->timeSat, pMan->timeTotal ); |
| // ABC_PRTP( " unsat ", pMan->timeSatU, pMan->timeTotal ); |
| // ABC_PRTP( " sat ", pMan->timeSatS, pMan->timeTotal ); |
| ABC_PRTP( "TOTAL ", pMan->timeTotal, pMan->timeTotal ); |
| fflush( stdout ); |
| } |
| Acb_MfsStop( pMan ); |
| StrCount = 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
