| /**CFile**************************************************************** |
| |
| FileName [acecCover.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [CEC for arithmetic circuits.] |
| |
| Synopsis [Core procedures.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - June 20, 2005.] |
| |
| Revision [$Id: acecCover.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "acecInt.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Gia_AcecMark_rec( Gia_Man_t * p, int iObj, int fFirst ) |
| { |
| Gia_Obj_t * pObj = Gia_ManObj( p, iObj ); |
| if ( pObj->fMark0 && !fFirst ) |
| return; |
| assert( Gia_ObjIsAnd(pObj) ); |
| pObj->fMark1 = 1; |
| Gia_AcecMark_rec( p, Gia_ObjFaninId0(pObj, iObj), 0 ); |
| Gia_AcecMark_rec( p, Gia_ObjFaninId1(pObj, iObj), 0 ); |
| } |
| void Gia_AcecMarkFadd( Gia_Man_t * p, int * pSigs ) |
| { |
| // if ( Gia_ManObj(p, pSigs[3])->fMark1 || Gia_ManObj(p, pSigs[4])->fMark1 ) |
| // return; |
| Gia_ManObj( p, pSigs[0] )->fMark0 = 1; |
| Gia_ManObj( p, pSigs[1] )->fMark0 = 1; |
| Gia_ManObj( p, pSigs[2] )->fMark0 = 1; |
| // assert( !Gia_ManObj(p, pSigs[3])->fMark1 ); |
| // assert( !Gia_ManObj(p, pSigs[4])->fMark1 ); |
| Gia_AcecMark_rec( p, pSigs[3], 1 ); |
| Gia_AcecMark_rec( p, pSigs[4], 1 ); |
| } |
| void Gia_AcecMarkHadd( Gia_Man_t * p, int * pSigs ) |
| { |
| Gia_Obj_t * pObj = Gia_ManObj( p, pSigs[0] ); |
| int iFan0 = Gia_ObjFaninId0( pObj, pSigs[0] ); |
| int iFan1 = Gia_ObjFaninId1( pObj, pSigs[0] ); |
| Gia_ManObj( p, iFan0 )->fMark0 = 1; |
| Gia_ManObj( p, iFan1 )->fMark0 = 1; |
| Gia_AcecMark_rec( p, pSigs[0], 1 ); |
| Gia_AcecMark_rec( p, pSigs[1], 1 ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collect XORs reachable from the last output.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Gia_AcecCollectXors_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Bit_t * vMap, Vec_Int_t * vXors ) |
| { |
| if ( !Gia_ObjIsXor(pObj) )//|| Vec_BitEntry(vMap, Gia_ObjId(p, pObj)) ) |
| return; |
| Vec_IntPush( vXors, Gia_ObjId(p, pObj) ); |
| Gia_AcecCollectXors_rec( p, Gia_ObjFanin0(pObj), vMap, vXors ); |
| Gia_AcecCollectXors_rec( p, Gia_ObjFanin1(pObj), vMap, vXors ); |
| } |
| Vec_Int_t * Gia_AcecCollectXors( Gia_Man_t * p, Vec_Bit_t * vMap ) |
| { |
| Vec_Int_t * vXors = Vec_IntAlloc( 100 ); |
| Gia_Obj_t * pObj = Gia_ObjFanin0( Gia_ManCo(p, Gia_ManCoNum(p)-1) ); |
| Gia_AcecCollectXors_rec( p, pObj, vMap, vXors ); |
| return vXors; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Gia_AcecExplore( Gia_Man_t * p, int fVerbose ) |
| { |
| Vec_Int_t * vNodes = Vec_IntAlloc( 100 ); |
| Vec_Int_t * vFadds, * vHadds, * vXors; |
| Vec_Bit_t * vMap = Vec_BitStart( Gia_ManObjNum(p) ); |
| Gia_Obj_t * pObj; |
| int i, nSupp, nCone, nHadds = 0; |
| assert( p->pMuxes != NULL ); |
| vFadds = Gia_ManDetectFullAdders( p, fVerbose, NULL ); |
| vHadds = Gia_ManDetectHalfAdders( p, fVerbose ); |
| |
| pObj = Gia_ManObj( p, 352 ); |
| printf( "Xor = %d.\n", Gia_ObjIsXor(pObj) ); |
| printf( "Fanin0 = %d. Fanin1 = %d.\n", Gia_ObjFaninId0(pObj, 352), Gia_ObjFaninId1(pObj, 352) ); |
| printf( "Fan00 = %d. Fan01 = %d. Fan10 = %d. Fan11 = %d.\n", |
| Gia_ObjFaninId0(Gia_ObjFanin0(pObj), Gia_ObjFaninId0(pObj, 352)), |
| Gia_ObjFaninId1(Gia_ObjFanin0(pObj), Gia_ObjFaninId0(pObj, 352)), |
| Gia_ObjFaninId0(Gia_ObjFanin1(pObj), Gia_ObjFaninId1(pObj, 352)), |
| Gia_ObjFaninId1(Gia_ObjFanin1(pObj), Gia_ObjFaninId1(pObj, 352)) ); |
| |
| // create a map of all HADD/FADD outputs |
| for ( i = 0; i < Vec_IntSize(vHadds)/2; i++ ) |
| { |
| int * pSigs = Vec_IntEntryP(vHadds, 2*i); |
| Vec_BitWriteEntry( vMap, pSigs[0], 1 ); |
| Vec_BitWriteEntry( vMap, pSigs[1], 1 ); |
| } |
| for ( i = 0; i < Vec_IntSize(vFadds)/5; i++ ) |
| { |
| int * pSigs = Vec_IntEntryP(vFadds, 5*i); |
| Vec_BitWriteEntry( vMap, pSigs[3], 1 ); |
| Vec_BitWriteEntry( vMap, pSigs[4], 1 ); |
| } |
| |
| Gia_ManCleanMark01( p ); |
| |
| // mark outputs |
| Gia_ManForEachCo( p, pObj, i ) |
| Gia_ObjFanin0(pObj)->fMark0 = 1; |
| |
| // collect XORs |
| vXors = Gia_AcecCollectXors( p, vMap ); |
| Vec_BitFree( vMap ); |
| |
| printf( "Collected XORs: " ); |
| Vec_IntPrint( vXors ); |
| |
| // mark their fanins |
| Gia_ManForEachObjVec( vXors, p, pObj, i ) |
| { |
| pObj->fMark1 = 1; |
| Gia_ObjFanin0(pObj)->fMark0 = 1; |
| Gia_ObjFanin1(pObj)->fMark0 = 1; |
| } |
| |
| // mark FADDs |
| for ( i = 0; i < Vec_IntSize(vFadds)/5; i++ ) |
| Gia_AcecMarkFadd( p, Vec_IntEntryP(vFadds, 5*i) ); |
| |
| // iterate through HADDs and find those that fit in |
| while ( 1 ) |
| { |
| int fChange = 0; |
| for ( i = 0; i < Vec_IntSize(vHadds)/2; i++ ) |
| { |
| int * pSigs = Vec_IntEntryP(vHadds, 2*i); |
| if ( !Gia_ManObj(p, pSigs[0])->fMark0 || !Gia_ManObj(p, pSigs[1])->fMark0 ) |
| continue; |
| if ( Gia_ManObj(p, pSigs[0])->fMark1 || Gia_ManObj(p, pSigs[1])->fMark1 ) |
| continue; |
| Gia_AcecMarkHadd( p, pSigs ); |
| fChange = 1; |
| nHadds++; |
| } |
| if ( !fChange ) |
| break; |
| } |
| // print inputs to the adder network |
| Gia_ManForEachAnd( p, pObj, i ) |
| if ( pObj->fMark0 && !pObj->fMark1 ) |
| { |
| nSupp = Gia_ManSuppSize( p, &i, 1 ); |
| nCone = Gia_ManConeSize( p, &i, 1 ); |
| printf( "Node %5d : Supp = %5d. Cone = %5d.\n", i, nSupp, nCone ); |
| Vec_IntPush( vNodes, i ); |
| } |
| printf( "Fadds = %d. Hadds = %d. Root nodes found = %d.\n", Vec_IntSize(vFadds)/5, nHadds, Vec_IntSize(vNodes) ); |
| |
| Gia_ManCleanMark01( p ); |
| |
| Gia_ManForEachObjVec( vNodes, p, pObj, i ) |
| pObj->fMark0 = 1; |
| |
| Vec_IntFree( vFadds ); |
| Vec_IntFree( vHadds ); |
| Vec_IntFree( vNodes ); |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Gia_AcecCover( Gia_Man_t * p ) |
| { |
| int fVerbose = 1; |
| int i, k, Entry; |
| Gia_Obj_t * pObj; |
| Vec_Int_t * vCutsXor2 = NULL; |
| Vec_Int_t * vFadds = Gia_ManDetectFullAdders( p, fVerbose, &vCutsXor2 ); |
| |
| // mark FADDs |
| Gia_ManCleanMark01( p ); |
| for ( i = 0; i < Vec_IntSize(vFadds)/5; i++ ) |
| Gia_AcecMarkFadd( p, Vec_IntEntryP(vFadds, 5*i) ); |
| |
| k = 0; |
| Vec_IntForEachEntry( vCutsXor2, Entry, i ) |
| { |
| if ( i % 3 != 2 ) |
| continue; |
| pObj = Gia_ManObj( p, Entry ); |
| if ( pObj->fMark1 ) |
| continue; |
| printf( "%d ", Entry ); |
| } |
| printf( "\n" ); |
| |
| Gia_ManCleanMark01( p ); |
| |
| Vec_IntFree( vFadds ); |
| Vec_IntFree( vCutsXor2 ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
