| /**CFile**************************************************************** |
| |
| FileName [sfmLib.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [SAT-based optimization using internal don't-cares.] |
| |
| Synopsis [Preprocessing genlib library.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - June 20, 2005.] |
| |
| Revision [$Id: sfmLib.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "sfmInt.h" |
| #include "misc/st/st.h" |
| #include "map/mio/mio.h" |
| #include "misc/vec/vecMem.h" |
| #include "misc/util/utilTruth.h" |
| #include "misc/extra/extra.h" |
| #include "map/mio/exp.h" |
| #include "opt/dau/dau.h" |
| #include "base/main/main.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| struct Sfm_Fun_t_ |
| { |
| int Next; // next function in the list |
| int Area; // area of this function |
| char pFansT[SFM_SUPP_MAX+1]; // top gate ID, followed by fanin perm |
| char pFansB[SFM_SUPP_MAX+1]; // bottom gate ID, followed by fanin perm |
| }; |
| struct Sfm_Lib_t_ |
| { |
| int nVars; // variable count |
| int nWords; // truth table words |
| int fVerbose; // verbose statistics |
| Mio_Cell2_t * pCells; // library gates |
| int nCells; // library gate count |
| int fDelay; // uses delay profile |
| int nObjs; // object count |
| int nObjsAlloc; // object count |
| Sfm_Fun_t * pObjs; // objects |
| Vec_Mem_t * vTtMem; // truth tables |
| Vec_Int_t vLists; // lists of funcs for each truth table |
| Vec_Int_t vCounts; // counters of functions for each truth table |
| Vec_Int_t vHits; // the number of times this function was used |
| Vec_Int_t vProfs; // area/delay profiles |
| Vec_Int_t vStore; // storage for area/delay profiles |
| Vec_Int_t vTemp; // temporary storage for candidates |
| int nObjSkipped; |
| int nObjRemoved; |
| }; |
| |
| static inline Sfm_Fun_t * Sfm_LibFun( Sfm_Lib_t * p, int i ) { return i == -1 ? NULL : p->pObjs + i; } |
| static inline int Sfm_LibFunId( Sfm_Lib_t * p, Sfm_Fun_t * pFun ) { return pFun - p->pObjs; } |
| |
| #define Sfm_LibForEachSuper( p, pObj, Func ) \ |
| for ( pObj = Sfm_LibFun(p, Vec_IntEntry(&p->vLists, Func)); pObj; pObj = Sfm_LibFun(p, pObj->Next) ) |
| |
| |
| static word s_Truth8[8][4] = { |
| { ABC_CONST(0xAAAAAAAAAAAAAAAA),ABC_CONST(0xAAAAAAAAAAAAAAAA),ABC_CONST(0xAAAAAAAAAAAAAAAA),ABC_CONST(0xAAAAAAAAAAAAAAAA) }, |
| { ABC_CONST(0xCCCCCCCCCCCCCCCC),ABC_CONST(0xCCCCCCCCCCCCCCCC),ABC_CONST(0xCCCCCCCCCCCCCCCC),ABC_CONST(0xCCCCCCCCCCCCCCCC) }, |
| { ABC_CONST(0xF0F0F0F0F0F0F0F0),ABC_CONST(0xF0F0F0F0F0F0F0F0),ABC_CONST(0xF0F0F0F0F0F0F0F0),ABC_CONST(0xF0F0F0F0F0F0F0F0) }, |
| { ABC_CONST(0xFF00FF00FF00FF00),ABC_CONST(0xFF00FF00FF00FF00),ABC_CONST(0xFF00FF00FF00FF00),ABC_CONST(0xFF00FF00FF00FF00) }, |
| { ABC_CONST(0xFFFF0000FFFF0000),ABC_CONST(0xFFFF0000FFFF0000),ABC_CONST(0xFFFF0000FFFF0000),ABC_CONST(0xFFFF0000FFFF0000) }, |
| { ABC_CONST(0xFFFFFFFF00000000),ABC_CONST(0xFFFFFFFF00000000),ABC_CONST(0xFFFFFFFF00000000),ABC_CONST(0xFFFFFFFF00000000) }, |
| { ABC_CONST(0x0000000000000000),ABC_CONST(0xFFFFFFFFFFFFFFFF),ABC_CONST(0x0000000000000000),ABC_CONST(0xFFFFFFFFFFFFFFFF) }, |
| { ABC_CONST(0x0000000000000000),ABC_CONST(0x0000000000000000),ABC_CONST(0xFFFFFFFFFFFFFFFF),ABC_CONST(0xFFFFFFFFFFFFFFFF) } |
| }; |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Sfm_DecCreateCnf( Vec_Int_t * vGateSizes, Vec_Wrd_t * vGateFuncs, Vec_Wec_t * vGateCnfs ) |
| { |
| Vec_Str_t * vCnf, * vCnfBase; |
| Vec_Int_t * vCover; |
| word uTruth; |
| int i, nCubes; |
| vCnf = Vec_StrAlloc( 100 ); |
| vCover = Vec_IntAlloc( 100 ); |
| Vec_WrdForEachEntry( vGateFuncs, uTruth, i ) |
| { |
| nCubes = Sfm_TruthToCnf( uTruth, Vec_IntEntry(vGateSizes, i), vCover, vCnf ); |
| vCnfBase = (Vec_Str_t *)Vec_WecEntry( vGateCnfs, i ); |
| Vec_StrGrow( vCnfBase, Vec_StrSize(vCnf) ); |
| memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(vCnf), Vec_StrSize(vCnf) ); |
| vCnfBase->nSize = Vec_StrSize(vCnf); |
| } |
| Vec_IntFree( vCover ); |
| Vec_StrFree( vCnf ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Preprocess the library.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Sfm_LibPreprocess( Mio_Library_t * pLib, Vec_Int_t * vGateSizes, Vec_Wrd_t * vGateFuncs, Vec_Wec_t * vGateCnfs, Vec_Ptr_t * vGateHands ) |
| { |
| Mio_Gate_t * pGate; |
| int nGates = Mio_LibraryReadGateNum(pLib); |
| Vec_IntGrow( vGateSizes, nGates ); |
| Vec_WrdGrow( vGateFuncs, nGates ); |
| Vec_WecInit( vGateCnfs, nGates ); |
| Vec_PtrGrow( vGateHands, nGates ); |
| Mio_LibraryForEachGate( pLib, pGate ) |
| { |
| Vec_IntPush( vGateSizes, Mio_GateReadPinNum(pGate) ); |
| Vec_WrdPush( vGateFuncs, Mio_GateReadTruth(pGate) ); |
| Mio_GateSetValue( pGate, Vec_PtrSize(vGateHands) ); |
| Vec_PtrPush( vGateHands, pGate ); |
| } |
| Sfm_DecCreateCnf( vGateSizes, vGateFuncs, vGateCnfs ); |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Sfm_LibFindComplInputGate( Vec_Wrd_t * vFuncs, int iGate, int nFanins, int iFanin, int * piFaninNew ) |
| { |
| word uTruthGate = Vec_WrdEntry( vFuncs, iGate ); |
| word uTruthFlip = Abc_Tt6Flip( uTruthGate, iFanin ); |
| word uTruth, uTruthSwap; int i; |
| assert( iFanin >= 0 && iFanin < nFanins ); |
| if ( piFaninNew ) *piFaninNew = iFanin; |
| Vec_WrdForEachEntry( vFuncs, uTruth, i ) |
| if ( uTruth == uTruthFlip ) |
| return i; |
| if ( iFanin-1 >= 0 ) |
| { |
| if ( piFaninNew ) *piFaninNew = iFanin-1; |
| uTruthSwap = Abc_Tt6SwapAdjacent( uTruthFlip, iFanin-1 ); |
| Vec_WrdForEachEntry( vFuncs, uTruth, i ) |
| if ( uTruth == uTruthSwap ) |
| return i; |
| } |
| if ( iFanin+1 < nFanins ) |
| { |
| if ( piFaninNew ) *piFaninNew = iFanin+1; |
| uTruthSwap = Abc_Tt6SwapAdjacent( uTruthFlip, iFanin ); |
| Vec_WrdForEachEntry( vFuncs, uTruth, i ) |
| if ( uTruth == uTruthSwap ) |
| return i; |
| } |
| // add checking for complemeting control input of a MUX |
| if ( piFaninNew ) *piFaninNew = -1; |
| return -1; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Sfm_Lib_t * Sfm_LibStart( int nVars, int fDelay, int fVerbose ) |
| { |
| Sfm_Lib_t * p = ABC_CALLOC( Sfm_Lib_t, 1 ); |
| assert( nVars <= SFM_SUPP_MAX ); |
| p->vTtMem = Vec_MemAllocForTT( nVars, 0 ); |
| Vec_IntGrow( &p->vLists, (1 << 16) ); |
| Vec_IntGrow( &p->vCounts, (1 << 16) ); |
| Vec_IntGrow( &p->vHits, (1 << 16) ); |
| Vec_IntFill( &p->vLists, 2, -1 ); |
| Vec_IntFill( &p->vCounts, 2, -1 ); |
| Vec_IntFill( &p->vHits, 2, -1 ); |
| p->nObjsAlloc = (1 << 16); |
| p->pObjs = ABC_CALLOC( Sfm_Fun_t, p->nObjsAlloc ); |
| p->fDelay = fDelay; |
| if ( fDelay ) Vec_IntGrow( &p->vProfs, (1 << 16) ); |
| if ( fDelay ) Vec_IntGrow( &p->vStore, (1 << 18) ); |
| Vec_IntGrow( &p->vTemp, 16 ); |
| p->nVars = nVars; |
| p->nWords = Abc_TtWordNum( nVars ); |
| p->fVerbose = fVerbose; |
| return p; |
| } |
| void Sfm_LibStop( Sfm_Lib_t * p ) |
| { |
| Vec_MemHashFree( p->vTtMem ); |
| Vec_MemFree( p->vTtMem ); |
| Vec_IntErase( &p->vLists ); |
| Vec_IntErase( &p->vCounts ); |
| Vec_IntErase( &p->vHits ); |
| Vec_IntErase( &p->vProfs ); |
| Vec_IntErase( &p->vStore ); |
| Vec_IntErase( &p->vTemp ); |
| ABC_FREE( p->pCells ); |
| ABC_FREE( p->pObjs ); |
| ABC_FREE( p ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| word Sfm_LibTruth6Two( Mio_Cell2_t * pCellBot, Mio_Cell2_t * pCellTop, int InTop ) |
| { |
| word uFanins[SFM_SUPP_MAX]; int i, k; |
| word uTruthBot = Exp_Truth6( pCellBot->nFanins, pCellBot->vExpr, NULL ); |
| assert( InTop >= 0 && InTop < (int)pCellTop->nFanins ); |
| for ( i = 0, k = pCellBot->nFanins; i < (int)pCellTop->nFanins; i++ ) |
| if ( i == InTop ) |
| uFanins[i] = uTruthBot; |
| else |
| uFanins[i] = s_Truths6[k++]; |
| assert( (int)pCellBot->nFanins + (int)pCellTop->nFanins == k + 1 ); |
| uTruthBot = Exp_Truth6( pCellTop->nFanins, pCellTop->vExpr, uFanins ); |
| return uTruthBot; |
| } |
| void Sfm_LibTruth8Two( Mio_Cell2_t * pCellBot, Mio_Cell2_t * pCellTop, int InTop, word * pRes ) |
| { |
| word uTruthBot[4], * puFanins[SFM_SUPP_MAX]; int i, k; |
| Exp_Truth8( pCellBot->nFanins, pCellBot->vExpr, NULL, uTruthBot ); |
| assert( InTop >= 0 && InTop < (int)pCellTop->nFanins ); |
| for ( i = 0, k = pCellBot->nFanins; i < (int)pCellTop->nFanins; i++ ) |
| if ( i == InTop ) |
| puFanins[i] = uTruthBot; |
| else |
| puFanins[i] = s_Truth8[k++]; |
| assert( (int)pCellBot->nFanins + (int)pCellTop->nFanins == k + 1 ); |
| Exp_Truth8( pCellTop->nFanins, pCellTop->vExpr, puFanins, pRes ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| /* |
| void Sfm_LibCellProfile( Mio_Cell2_t * pCellBot, Mio_Cell2_t * pCellTop, int InTop, int nFanins, int * Perm, int * pProf ) |
| { |
| int i, DelayAdd = pCellTop ? pCellTop->iDelays[InTop] : 0; |
| for ( i = 0; i < nFanins; i++ ) |
| if ( Perm[i] < (int)pCellBot->nFanins ) |
| pProf[i] = pCellBot->iDelays[Perm[i]] + DelayAdd; |
| else if ( Perm[i] < (int)pCellBot->nFanins + InTop ) |
| pProf[i] = pCellTop->iDelays[Perm[i] - (int)pCellBot->nFanins]; |
| else // if ( Perm[i] >= (int)pCellBot->nFanins + InTop ) |
| pProf[i] = pCellTop->iDelays[Perm[i] - (int)pCellBot->nFanins + 1]; |
| } |
| */ |
| void Sfm_LibCellProfile( Mio_Cell2_t * pCellBot, Mio_Cell2_t * pCellTop, int InTop, int nFanins, int * Perm, int * pProf ) |
| { |
| int i, DelayAdd = pCellTop ? 1 : 0; |
| for ( i = 0; i < nFanins; i++ ) |
| if ( Perm[i] < (int)pCellBot->nFanins ) |
| pProf[i] = 1 + DelayAdd; |
| else if ( Perm[i] < (int)pCellBot->nFanins + InTop ) |
| pProf[i] = 1; |
| else // if ( Perm[i] >= (int)pCellBot->nFanins + InTop ) |
| pProf[i] = 1; |
| } |
| static inline int Sfm_LibNewIsContained( Sfm_Fun_t * pObj, int * pProf, int Area, int * pProfNew, int nFanins ) |
| { |
| int k; |
| if ( Area < pObj->Area ) |
| return 0; |
| for ( k = 0; k < nFanins; k++ ) |
| if ( pProfNew[k] < pProf[k] ) |
| return 0; |
| return 1; |
| } |
| static inline int Sfm_LibNewContains( Sfm_Fun_t * pObj, int * pProf, int Area, int * pProfNew, int nFanins ) |
| { |
| int k; |
| if ( Area > pObj->Area ) |
| return 0; |
| for ( k = 0; k < nFanins; k++ ) |
| if ( pProfNew[k] > pProf[k] ) |
| return 0; |
| return 1; |
| } |
| void Sfm_LibPrepareAdd( Sfm_Lib_t * p, word * pTruth, int * Perm, int nFanins, Mio_Cell2_t * pCellBot, Mio_Cell2_t * pCellTop, int InTop ) |
| { |
| Sfm_Fun_t * pObj; |
| int InvPerm[SFM_SUPP_MAX], Profile[SFM_SUPP_MAX]; |
| int Area = (int)pCellBot->AreaW + (pCellTop ? (int)pCellTop->AreaW : 0); |
| int i, k, Id, Prev, Offset, * pProf, iFunc = Vec_MemHashInsert( p->vTtMem, pTruth ); |
| if ( iFunc == Vec_IntSize(&p->vLists) ) |
| { |
| Vec_IntPush( &p->vLists, -1 ); |
| Vec_IntPush( &p->vCounts, 0 ); |
| Vec_IntPush( &p->vHits, 0 ); |
| } |
| assert( pCellBot != NULL ); |
| // iterate through the supergates of this truth table |
| if ( p->fDelay ) |
| { |
| assert( Vec_IntSize(&p->vProfs) == p->nObjs ); |
| Sfm_LibCellProfile( pCellBot, pCellTop, InTop, nFanins, Perm, Profile ); |
| // check if new one is contained in old ones |
| Vec_IntClear( &p->vTemp ); |
| Sfm_LibForEachSuper( p, pObj, iFunc ) |
| { |
| Vec_IntPush( &p->vTemp, Sfm_LibFunId(p, pObj) ); |
| Offset = Vec_IntEntry( &p->vProfs, Sfm_LibFunId(p, pObj) ); |
| pProf = Vec_IntEntryP( &p->vStore, Offset ); |
| if ( Sfm_LibNewIsContained(pObj, pProf, Area, Profile, nFanins) ) |
| { |
| p->nObjSkipped++; |
| return; |
| } |
| } |
| // check if old ones are contained in new one |
| k = 0; |
| Vec_IntForEachEntry( &p->vTemp, Id, i ) |
| { |
| Offset = Vec_IntEntry( &p->vProfs, Id ); |
| pProf = Vec_IntEntryP( &p->vStore, Offset ); |
| if ( !Sfm_LibNewContains(Sfm_LibFun(p, Id), pProf, Area, Profile, nFanins) ) |
| Vec_IntWriteEntry( &p->vTemp, k++, Id ); |
| else |
| p->nObjRemoved++; |
| } |
| if ( k < i ) // change |
| { |
| if ( k == 0 ) |
| Vec_IntWriteEntry( &p->vLists, iFunc, -1 ); |
| else |
| { |
| Vec_IntShrink( &p->vTemp, k ); |
| Prev = Vec_IntEntry(&p->vTemp, 0); |
| Vec_IntWriteEntry( &p->vLists, iFunc, Prev ); |
| Vec_IntForEachEntryStart( &p->vTemp, Id, i, 1 ) |
| { |
| Sfm_LibFun(p, Prev)->Next = Id; |
| Prev = Id; |
| } |
| Sfm_LibFun(p, Prev)->Next = -1; |
| } |
| } |
| } |
| else |
| { |
| Sfm_LibForEachSuper( p, pObj, iFunc ) |
| { |
| if ( Area >= pObj->Area ) |
| return; |
| } |
| } |
| for ( k = 0; k < nFanins; k++ ) |
| InvPerm[Perm[k]] = k; |
| // create delay profile |
| if ( p->fDelay ) |
| { |
| Vec_IntPush( &p->vProfs, Vec_IntSize(&p->vStore) ); |
| for ( k = 0; k < nFanins; k++ ) |
| Vec_IntPush( &p->vStore, Profile[k] ); |
| } |
| // create new object |
| if ( p->nObjs == p->nObjsAlloc ) |
| { |
| int nObjsAlloc = 2 * p->nObjsAlloc; |
| p->pObjs = ABC_REALLOC( Sfm_Fun_t, p->pObjs, nObjsAlloc ); |
| memset( p->pObjs + p->nObjsAlloc, 0, sizeof(Sfm_Fun_t) * p->nObjsAlloc ); |
| p->nObjsAlloc = nObjsAlloc; |
| } |
| pObj = p->pObjs + p->nObjs; |
| pObj->Area = Area; |
| pObj->Next = Vec_IntEntry(&p->vLists, iFunc); |
| Vec_IntWriteEntry( &p->vLists, iFunc, p->nObjs++ ); |
| Vec_IntAddToEntry( &p->vCounts, iFunc, 1 ); |
| // create gate |
| assert( pCellBot->Id < 128 ); |
| pObj->pFansB[0] = (char)pCellBot->Id; |
| for ( k = 0; k < (int)pCellBot->nFanins; k++ ) |
| pObj->pFansB[k+1] = InvPerm[k]; |
| if ( pCellTop == NULL ) |
| return; |
| assert( pCellTop->Id < 128 ); |
| pObj->pFansT[0] = (char)pCellTop->Id; |
| for ( i = 0; i < (int)pCellTop->nFanins; i++ ) |
| pObj->pFansT[i+1] = (char)(i == InTop ? 16 : InvPerm[k++]); |
| assert( k == nFanins ); |
| } |
| Sfm_Lib_t * Sfm_LibPrepare( int nVars, int fTwo, int fDelay, int fVerbose, int fLibVerbose ) |
| { |
| abctime clk = Abc_Clock(); |
| Sfm_Lib_t * p = Sfm_LibStart( nVars, fDelay, fLibVerbose ); |
| Mio_Cell2_t * pCell1, * pCell2, * pLimit; |
| int * pPerm[SFM_SUPP_MAX+1], * Perm1, * Perm2, Perm[SFM_SUPP_MAX]; |
| int nPerms[SFM_SUPP_MAX+1], i, f, n; |
| word tTemp1[4], tCur[4]; |
| char pRes[1000]; |
| assert( nVars <= SFM_SUPP_MAX ); |
| // precompute gates |
| p->pCells = Mio_CollectRootsNewDefault2( Abc_MinInt(6, nVars), &p->nCells, 0 ); |
| pLimit = p->pCells + p->nCells; |
| // find useful ones |
| for ( pCell1 = p->pCells + 4; pCell1 < pLimit; pCell1++ ) |
| { |
| word uTruth = pCell1->uTruth; |
| pCell1->Type = 0; |
| if ( Abc_Tt6IsAndType(uTruth, pCell1->nFanins) || Abc_Tt6IsOrType(uTruth, pCell1->nFanins) ) |
| pCell1->Type = 1; |
| else if ( Dau_DsdDecompose(&uTruth, pCell1->nFanins, 0, 0, pRes) <= 3 ) |
| pCell1->Type = 2; |
| else if ( fLibVerbose ) |
| printf( "Skipping gate \"%s\" with non-DSD function %s\n", pCell1->pName, pRes ); |
| } |
| // generate permutations |
| for ( i = 2; i <= nVars; i++ ) |
| pPerm[i] = Extra_PermSchedule( i ); |
| for ( i = 2; i <= nVars; i++ ) |
| nPerms[i] = Extra_Factorial( i ); |
| // add single cells |
| for ( pCell1 = p->pCells + 4; pCell1 < pLimit; pCell1++ ) |
| { |
| int nFanins = pCell1->nFanins; |
| assert( nFanins >= 2 && nFanins <= nVars ); |
| for ( i = 0; i < nFanins; i++ ) |
| Perm[i] = i; |
| // permute truth table |
| tCur[0] = tTemp1[0] = pCell1->uTruth; |
| if ( p->nVars > 6 ) |
| tTemp1[1] = tTemp1[2] = tTemp1[3] = tCur[1] = tCur[2] = tCur[3] = tCur[0]; |
| for ( n = 0; n < nPerms[nFanins]; n++ ) |
| { |
| Sfm_LibPrepareAdd( p, tCur, Perm, nFanins, pCell1, NULL, -1 ); |
| // update |
| Abc_TtSwapAdjacent( tCur, p->nWords, pPerm[nFanins][n] ); |
| Perm1 = Perm + pPerm[nFanins][n]; |
| Perm2 = Perm1 + 1; |
| ABC_SWAP( int, *Perm1, *Perm2 ); |
| } |
| assert( Abc_TtEqual(tTemp1, tCur, p->nWords) ); |
| } |
| // add double cells |
| if ( fTwo ) |
| for ( pCell1 = p->pCells + 4; pCell1 < pLimit; pCell1++ ) // Bot |
| if ( pCell1->Type > 0 ) |
| for ( pCell2 = p->pCells + 4; pCell2 < pLimit; pCell2++ ) // Top |
| if ( pCell2->Type > 0 )//&& pCell1->Type + pCell2->Type <= 2 ) |
| if ( (int)pCell1->nFanins + (int)pCell2->nFanins <= nVars + 1 ) |
| for ( f = 0; f < (int)pCell2->nFanins; f++ ) |
| { |
| int nFanins = pCell1->nFanins + pCell2->nFanins - 1; |
| assert( nFanins >= 2 && nFanins <= nVars ); |
| for ( i = 0; i < nFanins; i++ ) |
| Perm[i] = i; |
| // permute truth table |
| if ( p->nVars > 6 ) |
| { |
| Sfm_LibTruth8Two( pCell1, pCell2, f, tCur ); |
| Abc_TtCopy( tTemp1, tCur, p->nWords, 0 ); |
| } |
| else |
| tCur[0] = tTemp1[0] = Sfm_LibTruth6Two( pCell1, pCell2, f ); |
| for ( n = 0; n < nPerms[nFanins]; n++ ) |
| { |
| Sfm_LibPrepareAdd( p, tCur, Perm, nFanins, pCell1, pCell2, f ); |
| if ( nFanins > 5 ) |
| break; |
| // update |
| Abc_TtSwapAdjacent( tCur, p->nWords, pPerm[nFanins][n] ); |
| Perm1 = Perm + pPerm[nFanins][n]; |
| Perm2 = Perm1 + 1; |
| ABC_SWAP( int, *Perm1, *Perm2 ); |
| } |
| assert( Abc_TtEqual(tTemp1, tCur, p->nWords) ); |
| } |
| // cleanup |
| for ( i = 2; i <= nVars; i++ ) |
| ABC_FREE( pPerm[i] ); |
| if ( fVerbose ) |
| { |
| printf( "Library processing: Var = %d. Cell = %d. Fun = %d. Obj = %d. Ave = %.2f. Skip = %d. Rem = %d. ", |
| nVars, p->nCells, Vec_MemEntryNum(p->vTtMem)-2, |
| p->nObjs-p->nObjRemoved, 1.0*(p->nObjs-p->nObjRemoved)/(Vec_MemEntryNum(p->vTtMem)-2), |
| p->nObjSkipped, p->nObjRemoved ); |
| Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); |
| } |
| return p; |
| } |
| void Sfm_LibPrintGate( Mio_Cell2_t * pCell, char * pFanins, Mio_Cell2_t * pCell2, char * pFanins2 ) |
| { |
| int k; |
| printf( " %-20s(", pCell->pName ); |
| for ( k = 0; k < (int)pCell->nFanins; k++ ) |
| if ( pFanins[k] == (char)16 ) |
| Sfm_LibPrintGate( pCell2, pFanins2, NULL, NULL ); |
| else |
| printf( " %c", 'a' + pFanins[k] ); |
| printf( " )" ); |
| } |
| void Sfm_LibPrintObj( Sfm_Lib_t * p, Sfm_Fun_t * pObj ) |
| { |
| Mio_Cell2_t * pCellB = p->pCells + (int)pObj->pFansB[0]; |
| Mio_Cell2_t * pCellT = p->pCells + (int)pObj->pFansT[0]; |
| int i, nFanins = pCellB->nFanins + (pCellT == p->pCells ? 0 : pCellT->nFanins - 1); |
| printf( "F = %d A =%6.2f ", nFanins, Scl_Int2Flt(pObj->Area) ); |
| if ( pCellT == p->pCells ) |
| Sfm_LibPrintGate( pCellB, pObj->pFansB + 1, NULL, NULL ); |
| else |
| Sfm_LibPrintGate( pCellT, pObj->pFansT + 1, pCellB, pObj->pFansB + 1 ); |
| // get hold of delay info |
| if ( p->fDelay ) |
| { |
| int Offset = Vec_IntEntry( &p->vProfs, Sfm_LibFunId(p, pObj) ); |
| int * pProf = Vec_IntEntryP( &p->vStore, Offset ); |
| for ( i = 0; i < nFanins; i++ ) |
| printf( "%6.2f ", Scl_Int2Flt(pProf[i]) ); |
| } |
| } |
| void Sfm_LibPrint( Sfm_Lib_t * p ) |
| { |
| Sfm_Fun_t * pObj; word * pTruth; int i, nFanins; |
| Vec_MemForEachEntry( p->vTtMem, pTruth, i ) |
| { |
| if ( i < 2 || Vec_IntEntry(&p->vHits, i) == 0 ) |
| continue; |
| nFanins = Abc_TtSupportSize(pTruth, p->nVars); |
| printf( "%8d : ", i ); |
| printf( "Num =%5d ", Vec_IntEntry(&p->vCounts, i) ); |
| printf( "Hit =%4d ", Vec_IntEntry(&p->vHits, i) ); |
| Sfm_LibForEachSuper( p, pObj, i ) |
| { |
| Sfm_LibPrintObj( p, pObj ); |
| break; |
| } |
| printf( " " ); |
| Dau_DsdPrintFromTruth( pTruth, nFanins ); |
| } |
| } |
| void Sfm_LibTest() |
| { |
| Sfm_Lib_t * p; |
| int fVerbose = 1; |
| if ( Abc_FrameReadLibGen() == NULL ) |
| { |
| printf( "There is no current library.\n" ); |
| return; |
| } |
| p = Sfm_LibPrepare( 7, 1, 1, 1, fVerbose ); |
| if ( fVerbose ) |
| Sfm_LibPrint( p ); |
| Sfm_LibStop( p ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Sfm_LibFindAreaMatch( Sfm_Lib_t * p, word * pTruth, int nFanins, int * piObj ) |
| { |
| Sfm_Fun_t * pObj = NULL; |
| int iFunc = *Vec_MemHashLookup( p->vTtMem, pTruth ); |
| if ( iFunc == -1 ) |
| return -1; |
| Sfm_LibForEachSuper( p, pObj, iFunc ) |
| break; |
| if ( piObj ) |
| *piObj = pObj - p->pObjs; |
| return pObj->Area; |
| } |
| int Sfm_LibFindDelayMatches( Sfm_Lib_t * p, word * pTruth, int * pFanins, int nFanins, Vec_Ptr_t * vGates, Vec_Ptr_t * vFans ) |
| { |
| Sfm_Fun_t * pObj; |
| Mio_Cell2_t * pCellB, * pCellT; |
| int iFunc; |
| if ( nFanins > 6 ) |
| { |
| word pCopy[4]; |
| Abc_TtCopy( pCopy, pTruth, 4, 0 ); |
| Dau_DsdPrintFromTruth( pCopy, p->nVars ); |
| } |
| Vec_PtrClear( vGates ); |
| Vec_PtrClear( vFans ); |
| // look for gate |
| assert( !Abc_TtIsConst0(pTruth, p->nWords) && |
| !Abc_TtIsConst1(pTruth, p->nWords) && |
| !Abc_TtEqual(pTruth, s_Truth8[0], p->nWords) && |
| !Abc_TtOpposite(pTruth, s_Truth8[0], p->nWords) ); |
| iFunc = *Vec_MemHashLookup( p->vTtMem, pTruth ); |
| if ( iFunc == -1 ) |
| { |
| // print functions not found in the library |
| if ( p->fVerbose || nFanins > 6 ) |
| { |
| printf( "Not found in the precomputed library: " ); |
| Dau_DsdPrintFromTruth( pTruth, nFanins ); |
| } |
| return 0; |
| } |
| Vec_IntAddToEntry( &p->vHits, iFunc, 1 ); |
| // collect matches |
| Sfm_LibForEachSuper( p, pObj, iFunc ) |
| { |
| pCellB = p->pCells + (int)pObj->pFansB[0]; |
| pCellT = p->pCells + (int)pObj->pFansT[0]; |
| Vec_PtrPush( vGates, pCellB->pMioGate ); |
| Vec_PtrPush( vGates, pCellT == p->pCells ? NULL : pCellT->pMioGate ); |
| Vec_PtrPush( vFans, pObj->pFansB + 1 ); |
| Vec_PtrPush( vFans, pCellT == p->pCells ? NULL : pObj->pFansT + 1 ); |
| } |
| return Vec_PtrSize(vGates) / 2; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Sfm_LibImplementSimple( Sfm_Lib_t * p, word * pTruth, int * pFanins, int nFanins, Vec_Int_t * vGates, Vec_Wec_t * vFanins ) |
| { |
| Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen(); |
| Mio_Gate_t * pGate; |
| Vec_Int_t * vLevel; |
| if ( Abc_TtIsConst0(pTruth, p->nWords) || Abc_TtIsConst1(pTruth, p->nWords) ) |
| { |
| assert( nFanins == 0 ); |
| pGate = Abc_TtIsConst1(pTruth, p->nWords) ? Mio_LibraryReadConst1(pLib) : Mio_LibraryReadConst0(pLib); |
| Vec_IntPush( vGates, Mio_GateReadValue(pGate) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| return 1; |
| } |
| if ( Abc_TtEqual(pTruth, s_Truth8[0], p->nWords) || Abc_TtOpposite(pTruth, s_Truth8[0], p->nWords) ) |
| { |
| assert( nFanins == 1 ); |
| pGate = Abc_TtEqual(pTruth, s_Truth8[0], p->nWords) ? Mio_LibraryReadBuf(pLib) : Mio_LibraryReadInv(pLib); |
| Vec_IntPush( vGates, Mio_GateReadValue(pGate) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| Vec_IntPush( vLevel, pFanins[0] ); |
| return 1; |
| } |
| assert( 0 ); |
| return -1; |
| } |
| int Sfm_LibImplementGatesArea( Sfm_Lib_t * p, int * pFanins, int nFanins, int iObj, Vec_Int_t * vGates, Vec_Wec_t * vFanins ) |
| { |
| Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen(); |
| Sfm_Fun_t * pObjMin = p->pObjs + iObj; |
| Mio_Cell2_t * pCellB, * pCellT; |
| Mio_Gate_t * pGate; |
| Vec_Int_t * vLevel; |
| int i; |
| // get the gates |
| pCellB = p->pCells + (int)pObjMin->pFansB[0]; |
| pCellT = p->pCells + (int)pObjMin->pFansT[0]; |
| // create bottom gate |
| pGate = Mio_LibraryReadGateByName( pLib, pCellB->pName, NULL ); |
| assert( pGate == pCellB->pMioGate ); |
| Vec_IntPush( vGates, Mio_GateReadValue(pGate) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| for ( i = 0; i < (int)pCellB->nFanins; i++ ) |
| Vec_IntPush( vLevel, pFanins[(int)pObjMin->pFansB[i+1]] ); |
| if ( pCellT == p->pCells ) |
| return 1; |
| // create top gate |
| pGate = Mio_LibraryReadGateByName( pLib, pCellT->pName, NULL ); |
| assert( pGate == pCellT->pMioGate ); |
| Vec_IntPush( vGates, Mio_GateReadValue(pGate) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| for ( i = 0; i < (int)pCellT->nFanins; i++ ) |
| if ( pObjMin->pFansT[i+1] == (char)16 ) |
| Vec_IntPush( vLevel, Vec_WecSize(vFanins)-2 ); |
| else |
| Vec_IntPush( vLevel, pFanins[(int)pObjMin->pFansT[i+1]] ); |
| return 2; |
| } |
| int Sfm_LibImplementGatesDelay( Sfm_Lib_t * p, int * pFanins, Mio_Gate_t * pGateB, Mio_Gate_t * pGateT, char * pFansB, char * pFansT, Vec_Int_t * vGates, Vec_Wec_t * vFanins ) |
| { |
| Vec_Int_t * vLevel; |
| int i, nFanins; |
| // create bottom gate |
| Vec_IntPush( vGates, Mio_GateReadValue(pGateB) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| nFanins = Mio_GateReadPinNum( pGateB ); |
| for ( i = 0; i < nFanins; i++ ) |
| Vec_IntPush( vLevel, pFanins[(int)pFansB[i]] ); |
| if ( pGateT == NULL ) |
| return 1; |
| // create top gate |
| Vec_IntPush( vGates, Mio_GateReadValue(pGateT) ); |
| vLevel = Vec_WecPushLevel( vFanins ); |
| nFanins = Mio_GateReadPinNum( pGateT ); |
| for ( i = 0; i < nFanins; i++ ) |
| if ( pFansT[i] == (char)16 ) |
| Vec_IntPush( vLevel, Vec_WecSize(vFanins)-2 ); |
| else |
| Vec_IntPush( vLevel, pFanins[(int)pFansT[i]] ); |
| return 2; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
