From e27edf5e1ee777d9a4256d94dce849155d85fdd3 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Thu, 15 Jan 2015 18:21:02 -0800 Subject: Various transformations of Cba_Ntk_t. --- src/base/cba/cba.h | 115 ++++++++++++++--- src/base/cba/cbaBlast.c | 305 ++++++++++++++++++++++++++++---------------- src/base/cba/cbaBuild.c | 207 ++++++++++++++---------------- src/base/cba/cbaNtk.c | 127 +++++++----------- src/base/cba/cbaSimple.c | 113 +++++----------- src/base/cba/cbaWriteBlif.c | 2 +- src/base/cba/cbaWriteVer.c | 40 +----- 7 files changed, 467 insertions(+), 442 deletions(-) (limited to 'src/base/cba') diff --git a/src/base/cba/cba.h b/src/base/cba/cba.h index 56db6f29..15e94461 100644 --- a/src/base/cba/cba.h +++ b/src/base/cba/cba.h @@ -61,19 +61,22 @@ typedef enum { // Verilog predefined models typedef enum { CBA_NODE_NONE = 0, // 0: unused - CBA_NODE_CONST, // 1: constant - CBA_NODE_BUF, // 2: buffer - CBA_NODE_INV, // 3: inverter - CBA_NODE_AND, // 4: AND - CBA_NODE_NAND, // 5: NAND - CBA_NODE_OR, // 6: OR - CBA_NODE_NOR, // 7: NOR - CBA_NODE_XOR, // 8: XOR - CBA_NODE_XNOR, // 9 .XNOR - CBA_NODE_MUX, // 10: MUX - CBA_NODE_MAJ, // 11: MAJ - CBA_NODE_KNOWN, // 12: unknown - CBA_NODE_UNKNOWN // 13: unknown + CBA_NODE_C0, // 1: logic node + CBA_NODE_C1, // 2: logic node + CBA_NODE_BUF, // 3: buffer + CBA_NODE_INV, // 4: inverter + CBA_NODE_AND, // 5: AND + CBA_NODE_NAND, // 6: NAND + CBA_NODE_OR, // 7: OR + CBA_NODE_NOR, // 8: NOR + CBA_NODE_XOR, // 9: XOR + CBA_NODE_XNOR, // 10 XNOR + CBA_NODE_MUX, // 11: MUX + CBA_NODE_MAJ, // 12: MAJ + CBA_NODE_AND00, // 13: AND00 + CBA_NODE_AND01, // 14: AND01 + CBA_NODE_AND10, // 15: AND10 + CBA_NODE_UNKNOWN // 16: unknown } Cba_NodeType_t; @@ -150,7 +153,8 @@ static inline char * Cba_NtkFuncStr( Cba_Ntk_t * p, int i ) { r static inline Vec_Set_t * Cba_NtkMem( Cba_Ntk_t * p ) { return Cba_ManMem(p->pDesign); } static inline int Cba_NtkMemSave( Cba_Ntk_t * p, int * d, int s ) { return Cba_ManMemSave(p->pDesign, d, s); } static inline int * Cba_NtkMemRead( Cba_Ntk_t * p, int h ) { return Cba_ManMemRead(p->pDesign, h); } -static inline Cba_Ntk_t * Cba_NtkHost( Cba_Ntk_t * p ) { return Cba_ManNtk(p->pDesign, p->iBoxNtk); } +static inline Cba_Ntk_t * Cba_NtkHostNtk( Cba_Ntk_t * p ) { return Cba_ManNtk(p->pDesign, p->iBoxNtk); } +static inline int Cba_NtkHostObj( Cba_Ntk_t * p ) { return p->iBoxObj; } static inline void Cba_NtkSetHost( Cba_Ntk_t * p, int n, int i ) { p->iBoxNtk = n; p->iBoxObj = i; } static inline Vec_Int_t * Cba_NtkCopies( Cba_Ntk_t * p ) { return &p->pDesign->vCopies; } static inline int Cba_NtkCopy( Cba_Ntk_t * p, int i ) { return Vec_IntEntry( Cba_NtkCopies(p), p->iObjStart + i ); } @@ -175,15 +179,17 @@ static inline int Cba_ObjIsCo( Cba_Ntk_t * p, int i ) { r static inline int Cba_ObjIsCio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsCi(p, i) || Cba_ObjIsCo(p, i); } static inline int Cba_ObjIsBio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsBi(p, i) || Cba_ObjIsBo(p, i); } -static inline int Cba_ObjFanin0( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsPo(p, i) || Cba_ObjIsBio(p, i)); return Cba_ObjFuncId(p, i); } +static inline int Cba_ObjFanin0( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsPo(p, i) || Cba_ObjIsBio(p, i)); return Cba_ObjFaninId(p, i); } static inline int * Cba_ObjFaninArray( Cba_Ntk_t * p, int i ) { assert(Cba_ObjType(p, i) >= CBA_OBJ_NODE); return Cba_NtkMemRead(p, Cba_ObjFaninId(p, i)); } static inline int Cba_ObjFaninNum( Cba_Ntk_t * p, int i ) { return *Cba_ObjFaninArray(p, i); } static inline int * Cba_ObjFanins( Cba_Ntk_t * p, int i ) { return Cba_ObjFaninArray(p, i) + 1; } static inline Vec_Int_t * Cba_ObjFaninVec( Cba_Ntk_t * p, int i ) { static Vec_Int_t V; V.pArray = Cba_ObjFaninArray(p, i); V.nSize = V.nCap = V.pArray ? *V.pArray++ : 0; return &V; } static inline Vec_Int_t * Cba_ObjFaninVec2( Cba_Ntk_t * p, int i ) { static Vec_Int_t W; W.pArray = Cba_ObjFaninArray(p, i); W.nSize = W.nCap = W.pArray ? *W.pArray++ : 0; return &W; } -static inline Cba_NodeType_t Cba_ObjNodeType( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsNode(p, i)); return Cba_ObjFaninId(p, i); } +static inline Cba_NodeType_t Cba_ObjNodeType( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsNode(p, i)); return Cba_ObjFuncId(p, i); } static inline int Cba_ObjBoxModelId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_ObjFuncId(p, i); } static inline Cba_Ntk_t * Cba_ObjBoxModel( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_ManNtk(p->pDesign, Cba_ObjBoxModelId(p, i)); } +static inline int Cba_ObjBoxSize( Cba_Ntk_t * p, int i ) { return 1 + Cba_NtkPiNum(Cba_ObjBoxModel(p, i)) + Cba_NtkPoNum(Cba_ObjBoxModel(p, i)); } + static inline int Cba_ObjBoxBiNum( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_NtkPiNum(Cba_ObjBoxModel(p, i)); } static inline int Cba_ObjBoxBoNum( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_NtkPoNum(Cba_ObjBoxModel(p, i)); } static inline int Cba_ObjBoxBi( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b - Cba_ObjBoxBiNum(p, b) + i; } @@ -253,7 +259,7 @@ static inline int Cba_ManHandleBuffer( Cba_Man_t * p, int iFanin ) { int h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * 2 ); int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h ); - pArray[0] = 1; + pArray[0] = (iFanin >= 0) ? 1 : 0; pArray[1] = iFanin; return h; } @@ -289,6 +295,14 @@ static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName ) printf( "Model with name %s already exists.\n", pName ); return pNtk; } +static inline void Cba_NtkResize( Cba_Ntk_t * p, int nObjs ) +{ + assert( Vec_IntSize(&p->vTypes) == 0 ); + Cba_ManFetchArray( p->pDesign, &p->vTypes, nObjs ); + Cba_ManFetchArray( p->pDesign, &p->vFuncs, nObjs ); + Cba_ManFetchArray( p->pDesign, &p->vFanins, nObjs ); + Cba_ManFetchArray( p->pDesign, &p->vNameIds, nObjs ); +} static inline Cba_Man_t * Cba_ManAlloc( char * pFileName ) { Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 ); @@ -304,15 +318,25 @@ static inline Cba_Man_t * Cba_ManAlloc( char * pFileName ) } static inline Cba_Man_t * Cba_ManClone( Cba_Man_t * pOld ) { + Cba_Ntk_t * pNtk, * pNtkNew; int i; Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 ); p->pName = Extra_FileDesignName( pOld->pName ); p->pSpec = Abc_UtilStrsav( pOld->pSpec ); p->pNames = Abc_NamRef( pOld->pNames ); p->pModels = Abc_NamRef( pOld->pModels ); p->pFuncs = Abc_NamRef( pOld->pFuncs ); + p->iRoot = 1; Vec_SetAlloc_( &p->Mem, 20 ); Vec_PtrPush( &p->vNtks, NULL ); - p->iRoot = 1; + Cba_ManForEachNtk( pOld, pNtk, i ) + { + pNtkNew = Cba_NtkAlloc( p, Cba_NtkName(pNtk) ); + Cba_ManFetchArray( p, &pNtkNew->vInputs, Cba_NtkPiNum(pNtk) ); + Cba_ManFetchArray( p, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) ); + Cba_ManFetchArray( p, &pNtkNew->vBoxes, Cba_NtkBoxNum(pNtk) ); + Vec_IntShrink( &pNtkNew->vBoxes, 0 ); + } + assert( Cba_ManNtkNum(p) == Cba_ManNtkNum(pOld) ); return p; } @@ -343,6 +367,58 @@ static inline int Cba_ManMemory( Cba_Man_t * p ) return nMem; } +static inline Cba_NodeType_t Ptr_SopToType( char * pSop ) +{ + if ( !strcmp(pSop, " 1\n") ) return CBA_NODE_C0; + if ( !strcmp(pSop, " 0\n") ) return CBA_NODE_C1; + if ( !strcmp(pSop, "1 1\n") ) return CBA_NODE_BUF; + if ( !strcmp(pSop, "0 1\n") ) return CBA_NODE_INV; + if ( !strcmp(pSop, "11 1\n") ) return CBA_NODE_AND; + if ( !strcmp(pSop, "00 1\n") ) return CBA_NODE_AND00; + if ( !strcmp(pSop, "01 1\n") ) return CBA_NODE_AND01; + if ( !strcmp(pSop, "10 1\n") ) return CBA_NODE_AND10; + if ( !strcmp(pSop, "00 0\n") ) return CBA_NODE_OR; + if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_NODE_OR; + if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_NODE_OR; + if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_NODE_XOR; + if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_NODE_XOR; + if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_NODE_XNOR; + if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_NODE_XNOR; + assert( 0 ); + return CBA_NODE_NONE; +} +static inline char * Ptr_TypeToName( Cba_NodeType_t Type ) +{ + if ( Type == CBA_NODE_C0 ) return "const0"; + if ( Type == CBA_NODE_C1 ) return "const1"; + if ( Type == CBA_NODE_BUF ) return "buf"; + if ( Type == CBA_NODE_INV ) return "not"; + if ( Type == CBA_NODE_AND ) return "and"; + if ( Type == CBA_NODE_AND00 ) return "and00"; + if ( Type == CBA_NODE_AND01 ) return "and01"; + if ( Type == CBA_NODE_AND10 ) return "and10"; + if ( Type == CBA_NODE_OR ) return "or"; + if ( Type == CBA_NODE_XOR ) return "xor"; + if ( Type == CBA_NODE_XNOR ) return "xnor"; + assert( 0 ); + return "???"; +} +static inline char * Ptr_TypeToSop( Cba_NodeType_t Type ) +{ + if ( Type == CBA_NODE_C0 ) return " 0\n"; + if ( Type == CBA_NODE_C1 ) return " 1\n"; + if ( Type == CBA_NODE_BUF ) return "1 1\n"; + if ( Type == CBA_NODE_INV ) return "0 1\n"; + if ( Type == CBA_NODE_AND ) return "11 1\n"; + if ( Type == CBA_NODE_AND00 ) return "00 1\n"; + if ( Type == CBA_NODE_AND01 ) return "01 1\n"; + if ( Type == CBA_NODE_AND10 ) return "10 1\n"; + if ( Type == CBA_NODE_OR ) return "00 0\n"; + if ( Type == CBA_NODE_XOR ) return "01 1\n10 1\n"; + if ( Type == CBA_NODE_XNOR ) return "00 1\n11 1\n"; + assert( 0 ); + return "???"; +} /*=== cbaBuild.c =========================================================*/ extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ); @@ -359,8 +435,7 @@ extern void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p ); extern void Cba_ManAssignInternNames( Cba_Man_t * p ); extern int Cba_NtkNodeNum( Cba_Ntk_t * p ); extern int Cba_ManObjNum( Cba_Man_t * p ); -extern void Cba_ManSetNtkBoxes( Cba_Man_t * p ); -extern Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vObjCounts ); +extern Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vNtkSizes ); extern Cba_Man_t * Cba_ManDup( Cba_Man_t * p ); diff --git a/src/base/cba/cbaBlast.c b/src/base/cba/cbaBlast.c index 8d2d53cd..26931e38 100644 --- a/src/base/cba/cbaBlast.c +++ b/src/base/cba/cbaBlast.c @@ -42,12 +42,15 @@ ABC_NAMESPACE_IMPL_START SeeAlso [] ***********************************************************************/ -void Cba_ManExtractSave( Cba_Man_t * p, int iLNtk, int iLObj, int iRNtk, int iRObj ) +int Cba_ManAddBarbuf( Gia_Man_t * pNew, int iRes, Cba_Man_t * p, int iLNtk, int iLObj, int iRNtk, int iRObj ) { +// if ( iRes == 0 || iRes == 1 ) +// return iRes; Vec_IntPush( p->vBuf2LeafNtk, iLNtk ); Vec_IntPush( p->vBuf2LeafObj, iLObj ); Vec_IntPush( p->vBuf2RootNtk, iRNtk ); Vec_IntPush( p->vBuf2RootObj, iRObj ); + return Gia_ManAppendBuf( pNew, iRes ); } int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i ) { @@ -61,44 +64,64 @@ int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i ) Cba_Ntk_t * pBox = Cba_ObjBoModel( p, i ); int iObj = Cba_NtkPo( pBox, Cba_ObjCioIndex(p, i) ); iRes = Cba_ManExtract_rec( pNew, pBox, iObj ); - iRes = Gia_ManAppendBuf( pNew, iRes ); - Cba_ManExtractSave( p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj ); + iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj ); } else if ( Cba_ObjIsPi(p, i) ) { - Cba_Ntk_t * pHost = Cba_NtkHost( p ); - int iObj = Cba_ObjBoxBi( pHost, p->iBoxObj, Cba_ObjCioIndex(p, i) ); + Cba_Ntk_t * pHost = Cba_NtkHostNtk( p ); + int iObj = Cba_ObjBoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjCioIndex(p, i) ); iRes = Cba_ManExtract_rec( pNew, pHost, iObj ); - iRes = Gia_ManAppendBuf( pNew, iRes ); - Cba_ManExtractSave( p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj ); + iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj ); } else if ( Cba_ObjIsNode(p, i) ) { int * pFanins = Cba_ObjFaninArray(p, i); int k, pLits[3], Type = Cba_ObjNodeType(p, i); assert( pFanins[0] <= 3 ); - for ( k = 0; k < pFanins[0]; k++ ) - pLits[k] = Cba_ManExtract_rec( pNew, p, pFanins[k+1] ); - if ( Type == CBA_NODE_AND ) - iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); - else if ( Type == CBA_NODE_OR ) - iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); - else if ( Type == CBA_NODE_XOR ) - iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] ); - else if ( Type == CBA_NODE_XNOR ) - iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) ); - else assert( 0 ), iRes = -1; + if ( pFanins[0] == 0 ) + { + if ( Type == CBA_NODE_C0 ) + iRes = 0; + else if ( Type == CBA_NODE_C1 ) + iRes = 1; + else assert( 0 ); + } + else if ( pFanins[0] == 1 ) + { + if ( Type == CBA_NODE_BUF ) + iRes = Cba_ManExtract_rec( pNew, p, pFanins[1] ); + else if ( Type == CBA_NODE_INV ) + iRes = Abc_LitNot( Cba_ManExtract_rec( pNew, p, pFanins[1] ) ); + else assert( 0 ); + } + else + { + for ( k = 0; k < pFanins[0]; k++ ) + pLits[k] = Cba_ManExtract_rec( pNew, p, pFanins[k+1] ); + if ( Type == CBA_NODE_AND ) + iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); + else if ( Type == CBA_NODE_OR ) + iRes = Gia_ManHashOr( pNew, pLits[0], pLits[1] ); + else if ( Type == CBA_NODE_XOR ) + iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] ); + else if ( Type == CBA_NODE_XNOR ) + iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) ); + else assert( 0 ); + } } else assert( 0 ); Cba_NtkSetCopy( p, i, iRes ); return iRes; } - Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) { Cba_Ntk_t * pRoot = Cba_ManRoot(p); Gia_Man_t * pNew, * pTemp; int i, iObj; + Vec_IntFreeP( &p->vBuf2LeafNtk ); + Vec_IntFreeP( &p->vBuf2LeafObj ); + Vec_IntFreeP( &p->vBuf2RootNtk ); + Vec_IntFreeP( &p->vBuf2RootObj ); p->vBuf2LeafNtk = Vec_IntAlloc( 1000 ); p->vBuf2LeafObj = Vec_IntAlloc( 1000 ); p->vBuf2RootNtk = Vec_IntAlloc( 1000 ); @@ -108,12 +131,13 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) pNew = Gia_ManStart( Cba_ManObjNum(p) ); pNew->pName = Abc_UtilStrsav(p->pName); pNew->pSpec = Abc_UtilStrsav(p->pSpec); - Vec_IntFill( &p->vCopies, Cba_ManObjNum(p), -1 ); Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) ); + Gia_ManHashAlloc( pNew ); Cba_NtkForEachPo( pRoot, iObj, i ) Cba_ManExtract_rec( pNew, pRoot, iObj ); + Gia_ManHashStop( pNew ); Cba_NtkForEachPo( pRoot, iObj, i ) Gia_ManAppendCo( pNew, Cba_NtkCopy(pRoot, iObj) ); assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs ); @@ -121,7 +145,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) // cleanup pNew = Gia_ManCleanup( pTemp = pNew ); Gia_ManStop( pTemp ); -// Gia_ManPrintStats( pNew, NULL ); + Gia_ManPrintStats( pNew, NULL ); // pNew = Gia_ManSweepHierarchy( pTemp = pNew ); // Gia_ManStop( pTemp ); // Gia_ManPrintStats( pNew, NULL ); @@ -130,7 +154,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) /**Function************************************************************* - Synopsis [] + Synopsis [Returns the number of objects in each network.] Description [] @@ -139,122 +163,179 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) SeeAlso [] ***********************************************************************/ -// return the array of object counters for each network -void Cba_ManCountNodes_rec( Cba_Man_t * p, Abc_Obj_t * pObj, int iNtk, Vec_Int_t * vObjCounts, Vec_Int_t * vBufDrivers, Vec_Int_t * vObj2Ntk, Vec_Int_t * vObj2Obj ) +Vec_Int_t * Cba_ManCountGia( Cba_Man_t * p, Gia_Man_t * pGia, int fAlwaysAdd ) { - if ( Abc_ObjIsBarBuf(pObj) ) + Cba_Ntk_t * pNtk; + Gia_Obj_t * pObj; + int i, k, iBox, Count = 0; + Vec_Int_t * vNtkSizes = Vec_IntStart( Cba_ManNtkNum(p) + 1 ); + Vec_Int_t * vDrivenCos = Vec_IntStart( Cba_ManNtkNum(p) + 1 ); + assert( Vec_IntSize(p->vBuf2LeafNtk) == Gia_ManBufNum(pGia) ); + // assing for each GIA node, the network it belongs to and count nodes for all networks + Gia_ManConst0(pGia)->Value = 1; + Gia_ManForEachPi( pGia, pObj, i ) + pObj->Value = 1; + Gia_ManForEachAnd( pGia, pObj, i ) { - Abc_Obj_t * pFanin = Abc_ObjFanin0(pObj); - if ( Abc_ObjIsPi(pFanin) || (Abc_ObjIsNode(pFanin) && Abc_ObjFaninNum(pFanin) > 0) ) - Vec_IntAddToEntry( vBufDrivers, iNtk, 1 ); - Cba_ManCountNodes_rec( p, Abc_ObjFanin0(pObj), pObj->iTemp, vObjCounts, vBufDrivers, vObj2Ntk, vObj2Obj ); + if ( Gia_ObjIsBuf(pObj) ) + { + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ) + Vec_IntAddToEntry( vDrivenCos, Gia_ObjFanin0(pObj)->Value, 1 ); + pObj->Value = Vec_IntEntry( p->vBuf2LeafNtk, Count++ ); + } + else + { + pObj->Value = Gia_ObjFanin0(pObj)->Value; + assert( pObj->Value == Gia_ObjFanin1(pObj)->Value ); + Vec_IntAddToEntry( vNtkSizes, pObj->Value, 1 ); + } } - else if ( Abc_ObjFaninNum(pObj) > 0 ) + assert( Count == Gia_ManBufNum(pGia) ); + Gia_ManForEachPo( pGia, pObj, i ) { - Abc_Obj_t * pFanin; int i; - Abc_ObjForEachFanin( pObj, pFanin, i ) - Cba_ManCountNodes_rec( p, pFanin, iNtk, vObjCounts, vBufDrivers, vObj2Ntk, vObj2Obj ); - Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), iNtk ); - Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(vObjCounts, iNtk) ); - Vec_IntAddToEntry( vObjCounts, iNtk, 1 ); + assert( Gia_ObjFanin0(pObj)->Value == 1 ); + pObj->Value = Gia_ObjFanin0(pObj)->Value; + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ) + Vec_IntAddToEntry( vDrivenCos, pObj->Value, 1 ); } -} -Vec_Int_t * Cba_ManCountNodes( Cba_Man_t * p, Abc_Ntk_t * pAbcNtk, Vec_Int_t * vBuf2RootNtk, Vec_Int_t ** pvObj2Ntk, Vec_Int_t ** pvObj2Obj ) -{ - Cba_Ntk_t * pNtk; - Abc_Obj_t * pObj; - Vec_Int_t * vObjCounts = Vec_IntStart( Cba_ManNtkNum(p) + 1 ); - Vec_Int_t * vBufDrivers = Vec_IntStart( Cba_ManNtkNum(p) + 1 ); - // set networks to which barbufs belong - int i, k, iBox, iBarBuf = Vec_IntSize( vBuf2RootNtk ); - assert( Vec_IntSize(vBuf2RootNtk) == pAbcNtk->nBarBufs2 ); - Abc_NtkForEachNodeReverse( pAbcNtk, pObj, i ) - pObj->iTemp = Vec_IntEntry( vBuf2RootNtk, --iBarBuf ); - assert( iBarBuf == 0 ); - // start with primary inputs + // for each network, count the total number of COs Cba_ManForEachNtk( p, pNtk, i ) { - Vec_IntAddToEntry( vObjCounts, i, Cba_NtkPiNum(pNtk) ); + Count = Cba_NtkPiNum(pNtk) + 2 * Cba_NtkPoNum(pNtk) - (fAlwaysAdd ? 0 : Vec_IntEntry(vDrivenCos, i)); Cba_NtkForEachBox( pNtk, iBox, k ) - Vec_IntAddToEntry( vObjCounts, i, Cba_NtkPiNum(Cba_ObjBoxModel(pNtk, iBox)) + Cba_NtkPoNum(Cba_ObjBoxModel(pNtk, iBox)) + 1 ); + Count += Cba_ObjBoxSize(pNtk, iBox) + Cba_ObjBoxBiNum(pNtk, iBox); + Vec_IntAddToEntry( vNtkSizes, i, Count ); } - // count internal nodes (network is in topo order) - *pvObj2Ntk = Vec_IntStartFull( Abc_NtkObjNumMax(pAbcNtk) ); - *pvObj2Obj = Vec_IntStartFull( Abc_NtkObjNumMax(pAbcNtk) ); - Abc_NtkForEachPo( pAbcNtk, pObj, i ) - Cba_ManCountNodes_rec( p, Abc_ObjFanin0(pObj), p->iRoot, vObjCounts, vBufDrivers, *pvObj2Ntk, *pvObj2Obj ); - // count PIs, POs, and PO drivers - Cba_ManForEachNtk( p, pNtk, i ) - Vec_IntAddToEntry( vObjCounts, i, 2 * Cba_NtkPoNum(pNtk) - Vec_IntEntry(vBufDrivers, i) ); - Vec_IntFree( vBufDrivers ); - return vObjCounts; + Vec_IntFree( vDrivenCos ); + return vNtkSizes; } -Cba_Man_t * Cba_ManInsert( Cba_Man_t * p, Abc_Ntk_t * pAbcNtk, int fVerbose ) +void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p ) { - Cba_Man_t * pNew; - Cba_Ntk_t * pNtk; - Abc_Obj_t * pObj, * pFanin; - Vec_Int_t * vObj2Ntk, * vObj2Obj; - Vec_Int_t * vObjCounts = Cba_ManCountNodes( p, pAbcNtk, p->vBuf2RootNtk, &vObj2Ntk, &vObj2Obj ); - Vec_Int_t * vFanins; - int i, k, iNtk, iBuf = 0; - // create initial mapping - pNew = Cba_ManDupStart( p, vObjCounts ); - // set PIs point to the leaves - Abc_NtkForEachPi( pAbcNtk, pObj, i ) + Cba_Ntk_t * pNtk; int Entry, i; + assert( p->vBuf2RootNtk != NULL ); + assert( pNew->vBuf2RootNtk == NULL ); + pNew->vBuf2RootNtk = Vec_IntDup( p->vBuf2RootNtk ); + pNew->vBuf2RootObj = Vec_IntDup( p->vBuf2RootObj ); + pNew->vBuf2LeafNtk = Vec_IntDup( p->vBuf2LeafNtk ); + pNew->vBuf2LeafObj = Vec_IntDup( p->vBuf2LeafObj ); + Vec_IntForEachEntry( p->vBuf2LeafObj, Entry, i ) { - Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), p->iRoot ); - Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), i ); + pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2LeafNtk, i) ); + Vec_IntWriteEntry( pNew->vBuf2LeafObj, i, Cba_NtkCopy(pNtk, Entry) ); } - // set buffers to point to the leaves - assert( Vec_IntSize(p->vBuf2LeafNtk) == pAbcNtk->nBarBufs2 ); - assert( Vec_IntSize(p->vBuf2LeafObj) == pAbcNtk->nBarBufs2 ); - Abc_NtkForEachBarBuf( pAbcNtk, pObj, i ) + Vec_IntForEachEntry( p->vBuf2RootObj, Entry, i ) { - Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2LeafNtk, iBuf) ); - Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2LeafObj, iBuf) ); - iBuf++; + pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, i) ); + Vec_IntWriteEntry( pNew->vBuf2RootObj, i, Cba_NtkCopy(pNtk, Entry) ); } - assert( iBuf == pAbcNtk->nBarBufs2 ); - // copy internal nodes - vFanins = Vec_IntAlloc( 100 ); - Abc_NtkForEachNode( pAbcNtk, pObj, i ) +} +void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * pNtk, int iTerm ) +{ + Vec_IntWriteEntry( &pNtk->vTypes, pNtk->nObjs, CBA_OBJ_NODE ); + if ( !pGia || !Gia_ObjFaninId0p(pGia, pObj) ) + { + Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, pGia && Gia_ObjFaninC0(pObj) ? CBA_NODE_C1 : CBA_NODE_C0 ); + Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleBuffer(pNtk->pDesign, -1) ); + } + else { - if ( Abc_ObjIsBarBuf(pObj) ) - continue; - if ( Abc_ObjFaninNum(pObj) == 0 ) - continue; - Vec_IntClear( vFanins ); - iNtk = Vec_IntEntry(vObj2Ntk, Abc_ObjId(pObj)); - Abc_ObjForEachFanin( pObj, pFanin, k ) + Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, Gia_ObjFaninC0(pObj) ? CBA_NODE_INV : CBA_NODE_BUF ); + Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleBuffer(pNtk->pDesign, Gia_ObjFanin0(pObj)->Value) ); + } + Vec_IntWriteEntry( &pNtk->vNameIds, pNtk->nObjs, Cba_ObjNameId(pNtk, iTerm) ); + Vec_IntWriteEntry( &pNtk->vFanins, iTerm, pNtk->nObjs++ ); +} +void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ) +{ + Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot( p ); + Vec_Int_t * vTemp = Vec_IntAlloc( 100 ); + int i, j, k, iBox, iTerm, Count = 0; + Gia_Obj_t * pObj; + + Gia_ManConst0(pGia)->Value = ~0; + Gia_ManForEachPi( pGia, pObj, i ) + pObj->Value = Cba_NtkPi( pRoot, i ); + Gia_ManForEachAnd( pGia, pObj, i ) + { + if ( Gia_ObjIsBuf(pObj) ) + { + pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, Count) ); + iTerm = Vec_IntEntry( p->vBuf2RootObj, Count ); + assert( Cba_ObjIsCo(pNtk, iTerm) ); + Cba_NtkCreateAndConnectBuffer( pGia, pObj, pNtk, iTerm ); + // prepare leaf + pObj->Value = Vec_IntEntry( p->vBuf2LeafObj, Count++ ); + } + else { - assert( Vec_IntEntry(vObj2Ntk, Abc_ObjId(pFanin)) == iNtk ); - Vec_IntPush( vFanins, Vec_IntEntry(vObj2Obj, Abc_ObjId(pFanin)) ); + Cba_NodeType_t Type; + pNtk = Cba_ManNtk( p, pObj->Value ); + if ( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) ) + Type = CBA_NODE_AND00; + else if ( Gia_ObjFaninC0(pObj) ) + Type = CBA_NODE_AND01; + else if ( Gia_ObjFaninC1(pObj) ) + Type = CBA_NODE_AND10; + else + Type = CBA_NODE_AND; + Vec_IntFillTwo( vTemp, 2, Gia_ObjFanin0(pObj)->Value, Gia_ObjFanin1(pObj)->Value ); + Vec_IntWriteEntry( &pNtk->vTypes, pNtk->nObjs, CBA_OBJ_NODE ); + Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, Type ); + Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleArray(p, vTemp) ); + pObj->Value = pNtk->nObjs++; } - pNtk = Cba_ManNtk( pNew, iNtk ); - Vec_IntPush( &pNtk->vTypes, CBA_OBJ_NODE ); - Vec_IntPush( &pNtk->vFuncs, -1 ); - Vec_IntPush( &pNtk->vFanins, Cba_ManHandleArray(pNew, vFanins) ); } - // set buffers to point to the roots - assert( Vec_IntSize(p->vBuf2RootNtk) == pAbcNtk->nBarBufs2 ); - assert( Vec_IntSize(p->vBuf2RootObj) == pAbcNtk->nBarBufs2 ); - iBuf = 0; - Abc_NtkForEachBarBuf( pAbcNtk, pObj, i ) + assert( Count == Gia_ManBufNum(pGia) ); + Vec_IntFree( vTemp ); + + // create constant 0 drivers for COs without barbufs + Cba_ManForEachNtk( p, pNtk, i ) { - Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootNtk, iBuf) ); - Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootObj, iBuf) ); - iBuf++; + Cba_NtkForEachBox( pNtk, iBox, k ) + Cba_BoxForEachBi( pNtk, iBox, iTerm, j ) + if ( Cba_ObjFanin0(pNtk, iTerm) == -1 ) + Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm ); + Cba_NtkForEachPo( pNtk, iTerm, k ) + if ( pNtk != pRoot && Cba_ObjFanin0(pNtk, iTerm) == -1 ) + Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm ); } - assert( iBuf == pAbcNtk->nBarBufs2 ); - // connect driven root nodes + // create node and connect POs + Gia_ManForEachPo( pGia, pObj, i ) + Cba_NtkCreateAndConnectBuffer( pGia, pObj, pRoot, Cba_NtkPo(pRoot, i) ); + assert( Cba_NtkObjNum(pRoot) == pRoot->nObjs ); +} +Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ) +{ + Vec_Int_t * vNtkSizes = Cba_ManCountGia( p, pGia, 1 ); + Cba_Man_t * pNew = Cba_ManDupStart( p, vNtkSizes ); + Cba_ManRemapBarbufs( pNew, p ); + Cba_NtkInsertGia( pNew, pGia ); + Vec_IntFree( vNtkSizes ); + return pNew; + +} +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] - Vec_IntFree( vObj2Ntk ); - Vec_IntFree( vObj2Obj ); +***********************************************************************/ +Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p ) +{ + Gia_Man_t * pGia = Cba_ManExtract( p, 0 ); + Cba_Man_t * pNew = Cba_ManInsertGia( p, pGia ); + Gia_ManStop( pGia ); + Cba_ManAssignInternNames( pNew ); return pNew; } + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/base/cba/cbaBuild.c b/src/base/cba/cbaBuild.c index d47563d1..b4f95f23 100644 --- a/src/base/cba/cbaBuild.c +++ b/src/base/cba/cbaBuild.c @@ -26,15 +26,6 @@ ABC_NAMESPACE_IMPL_START /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// -/* - Elaboration input data: - Vec_Int_t vInputs; // inputs (used by parser to store signals as NameId) - Vec_Int_t vOutputs; // outputs (used by parser to store signals as NameId) - Vec_Int_t vTypes; // types (used by parser to store Cba_PrsType_t) - Vec_Int_t vFuncs; // functions (used by parser to store function) - Vec_Int_t vFanins; // fanins (used by parser to store fanin/fanout signals as NameId) -*/ - //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// @@ -90,12 +81,45 @@ void Cba_NtkRemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) Cba_BoxRemap( pNtk, iBox, vMap ); } // create maps of NameId and boxes -int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) +void Cba_NtkFindNonDriven( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, int nObjCount, Vec_Int_t * vNonDriven ) +{ + int i, iObj, Type, NameId, Index; + // consider input node names + Vec_IntClear( vNonDriven ); + Cba_NtkForEachObjType( pNtk, Type, iObj ) + { + if ( Type == CBA_OBJ_NODE ) + { + Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj ); + Vec_IntForEachEntryStart( vFanins, NameId, i, 1 ) + if ( Vec_IntEntry(vMap, NameId) == -1 ) + Vec_IntWriteEntry( vMap, NameId, nObjCount++ ), Vec_IntPush(vNonDriven, NameId); + } + else if ( Type == CBA_OBJ_BOX ) + { + Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); + Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj ); + Vec_IntForEachEntry( vFanins, Index, i ) + { + i++; + if ( Index >= Cba_NtkPiNum(pNtkBox) ) + continue; + NameId = Vec_IntEntry( vFanins, i ); + if ( Vec_IntEntry(vMap, NameId) == -1 ) + Vec_IntWriteEntry( vMap, NameId, nObjCount++ ), Vec_IntPush(vNonDriven, NameId); + } + } + } + Cba_NtkForEachPo( pNtk, NameId, i ) + if ( Vec_IntEntry(vMap, NameId) == -1 ) + Vec_IntWriteEntry( vMap, NameId, nObjCount++ ), Vec_IntPush(vNonDriven, NameId); + if ( Vec_IntSize(vNonDriven) > 0 ) + printf( "Module %s has %d non-driven nets (for example, %s).\n", Cba_NtkName(pNtk), Vec_IntSize(vNonDriven), Cba_NtkStr(pNtk, Vec_IntEntry(vNonDriven, 0)) ); +} +int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes, Vec_Int_t * vNonDriven ) { - Vec_Int_t * vFanins; int i, iObj, Type, Index, NameId; int nObjCount = 0; - // map old name IDs into new object IDs Vec_IntClear( vBoxes ); Cba_NtkForEachPi( pNtk, NameId, i ) @@ -109,7 +133,7 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) if ( Type == CBA_OBJ_NODE ) { // consider node output name - vFanins = Cba_ObjFaninVec( pNtk, iObj ); + Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj ); NameId = Vec_IntEntry( vFanins, 0 ); if ( Vec_IntEntry(vMap, NameId) != -1 ) printf( "Node output name %d is already driven.\n", NameId ); @@ -117,10 +141,10 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) } else if ( Type == CBA_OBJ_BOX ) { + Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj ); Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); nObjCount += Cba_NtkPiNum(pNtkBox); Vec_IntPush( vBoxes, nObjCount++ ); - vFanins = Cba_ObjFaninVec( pNtk, iObj ); Vec_IntForEachEntry( vFanins, Index, i ) { i++; @@ -136,83 +160,11 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) nObjCount += Cba_NtkPoNum(pNtkBox); } } - // add outputs - nObjCount += Cba_NtkPoNum(pNtk); + Cba_NtkFindNonDriven( pNtk, vMap, nObjCount, vNonDriven ); + nObjCount += Vec_IntSize(vNonDriven) + Cba_NtkPoNum(pNtk); return nObjCount; } -void Cba_NtkCleanMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) -{ - Vec_Int_t * vFanins; - int i, iObj, Type, NameId; - Cba_NtkForEachPi( pNtk, NameId, i ) - Vec_IntWriteEntry( vMap, NameId, -1 ); - Cba_NtkForEachObjType( pNtk, Type, iObj ) - { - vFanins = Cba_ObjFaninVec( pNtk, iObj ); - if ( Type == CBA_OBJ_NODE ) - { - Vec_IntForEachEntry( vFanins, NameId, i ) - Vec_IntWriteEntry( vMap, NameId, -1 ); - } - else if ( Type == CBA_OBJ_BOX ) - { - Vec_IntForEachEntry( vFanins, NameId, i ) - Vec_IntWriteEntry( vMap, Vec_IntEntry(vFanins, ++i), -1 ); - } - } - Cba_NtkForEachPo( pNtk, NameId, i ) - Vec_IntWriteEntry( vMap, NameId, -1 ); -} -int Cba_NtkCheckNonDriven( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, int nObjCount ) -{ - Vec_Int_t * vFanins; - int i, iObj, Type, NameId, Index; - int NonDriven = 0; - // check non-driven nets - Cba_NtkForEachObjType( pNtk, Type, iObj ) - { - if ( Type == CBA_OBJ_NODE ) - { - // consider node input names - vFanins = Cba_ObjFaninVec( pNtk, iObj ); - Vec_IntForEachEntryStart( vFanins, NameId, i, 1 ) - { - if ( Vec_IntEntry(vMap, NameId) != -1 ) - continue; - if ( NonDriven++ == 0 ) nObjCount++; - Vec_IntWriteEntry( vMap, NameId, nObjCount-1 ); - } - } - else if ( Type == CBA_OBJ_BOX ) - { - Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); - vFanins = Cba_ObjFaninVec( pNtk, iObj ); - Vec_IntForEachEntry( vFanins, Index, i ) - { - i++; - if ( Index >= Cba_NtkPiNum(pNtkBox) ) - continue; - // consider box input name - NameId = Vec_IntEntry( vFanins, i ); - if ( Vec_IntEntry(vMap, NameId) != -1 ) - continue; - if ( NonDriven++ == 0 ) nObjCount++; - Vec_IntWriteEntry( vMap, NameId, nObjCount-1 ); - } - } - } - Cba_NtkForEachPo( pNtk, NameId, i ) - { - if ( Vec_IntEntry(vMap, NameId) != -1 ) - continue; - if ( NonDriven++ == 0 ) nObjCount++; - Vec_IntWriteEntry( vMap, NameId, nObjCount-1 ); - } - if ( NonDriven > 0 ) - printf( "Detected %d non-driven nets.\n", NonDriven ); - return NonDriven; -} -Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes, Vec_Int_t * vTemp, int nObjCount ) +Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vNonDriven, Vec_Int_t * vTemp, int nObjCount ) { Vec_Int_t * vFanins; Cba_Ntk_t * pNtkNew, * pNtkBox; @@ -220,11 +172,7 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, // start network pNtkNew = Cba_ManNtk( pNew, Cba_NtkId(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vTypes, nObjCount ); - Cba_ManFetchArray( pNew, &pNtkNew->vFuncs, nObjCount ); - Cba_ManFetchArray( pNew, &pNtkNew->vFanins, nObjCount ); - Cba_ManFetchArray( pNew, &pNtkNew->vNameIds, nObjCount ); - Cba_ManSetupArray( pNew, &pNtkNew->vBoxes, vBoxes ); + Cba_NtkResize( pNtkNew, nObjCount ); // fill object information Cba_NtkForEachPi( pNtk, NameId, i ) @@ -235,7 +183,6 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, i ); Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); } - Cba_NtkForEachObjType( pNtk, Type, iObj ) { vFanins = Cba_ObjFaninVec( pNtk, iObj ); @@ -285,18 +232,29 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, { Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BI ); Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i ); - Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, Cba_ManHandleBuffer(pNew, Vec_IntEntry(vTemp, i)) ); + Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, Vec_IntEntry(vTemp, i) ); } // create box outputs Cba_BoxForEachBo( pNtkNew, ObjId, FaninId, i ) { Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BO ); Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i ); - Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, Cba_ManHandleBuffer(pNew, ObjId) ); + Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, ObjId ); } } } assert( nBoxes == Vec_IntSize(&pNtkNew->vBoxes) ); + // add constants for nondriven nodes + Vec_IntForEachEntry( vNonDriven, NameId, i ) + { + ObjId = Vec_IntEntry( vMap, NameId ); + Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId ); + Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_NODE ); + Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, CBA_NODE_C0 ); + Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, Cba_ManHandleBuffer(pNew, -1) ); + Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); + } + // add PO nodes Cba_NtkForEachPo( pNtk, NameId, i ) { ObjId = nObjCount - Cba_NtkPoNum(pNtk) + i; @@ -305,45 +263,66 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId ); Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_PO ); Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, i ); - Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, Cba_ManHandleBuffer(pNew, FaninId) ); + Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, FaninId ); // remove NameId from the driver and assign it to the output //Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 ); Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); } return pNtkNew; } -Cba_Man_t * Cba_ManPreBuild( Cba_Man_t * p ) +void Cba_NtkCleanMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) { - Cba_Man_t * pNew = Cba_ManClone( p ); - Cba_Ntk_t * pNtk, * pNtkNew; int i; - Cba_ManForEachNtk( p, pNtk, i ) + Vec_Int_t * vFanins; + int i, iObj, Type, NameId; + Cba_NtkForEachPi( pNtk, NameId, i ) + Vec_IntWriteEntry( vMap, NameId, -1 ); + Cba_NtkForEachObjType( pNtk, Type, iObj ) { - pNtkNew = Cba_NtkAlloc( pNew, Cba_NtkName(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vInputs, Cba_NtkPiNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) ); + vFanins = Cba_ObjFaninVec( pNtk, iObj ); + if ( Type == CBA_OBJ_NODE ) + { + Vec_IntForEachEntry( vFanins, NameId, i ) + Vec_IntWriteEntry( vMap, NameId, -1 ); + } + else if ( Type == CBA_OBJ_BOX ) + { + Vec_IntForEachEntry( vFanins, NameId, i ) + Vec_IntWriteEntry( vMap, Vec_IntEntry(vFanins, ++i), -1 ); + } } - assert( Cba_ManNtkNum(pNew) == Cba_ManNtkNum(p) ); - return pNew; + Cba_NtkForEachPo( pNtk, NameId, i ) + Vec_IntWriteEntry( vMap, NameId, -1 ); } + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ) { - Cba_Man_t * pNew = Cba_ManPreBuild( p ); + Cba_Man_t * pNew = Cba_ManClone( p ); Vec_Int_t * vMap = Vec_IntStartFull( Abc_NamObjNumMax(p->pNames) + 1 ); - Vec_Int_t * vBoxes = Vec_IntAlloc( 1000 ); + Vec_Int_t * vNonDr = Vec_IntAlloc( 1000 ); Vec_Int_t * vTemp = Vec_IntAlloc( 1000 ); Cba_Ntk_t * pNtk; int i, nObjs; assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 ); Cba_ManForEachNtk( p, pNtk, i ) { Cba_NtkRemapBoxes( pNtk, vMap ); - nObjs = Cba_NtkCreateMap( pNtk, vMap, vBoxes ); - Cba_NtkCheckNonDriven( pNtk, vMap, nObjs ); - Cba_NtkBuild( pNew, pNtk, vMap, vBoxes, vTemp, nObjs ); + nObjs = Cba_NtkCreateMap( pNtk, vMap, &Cba_ManNtk(pNew, i)->vBoxes, vNonDr ); + Cba_NtkBuild( pNew, pNtk, vMap, vNonDr, vTemp, nObjs ); Cba_NtkCleanMap( pNtk, vMap ); } - Vec_IntFree( vTemp ); - Vec_IntFree( vBoxes ); Vec_IntFree( vMap ); + Vec_IntFree( vNonDr ); + Vec_IntFree( vTemp ); return pNew; } diff --git a/src/base/cba/cbaNtk.c b/src/base/cba/cbaNtk.c index 30e721a6..9d2fe6d1 100644 --- a/src/base/cba/cbaNtk.c +++ b/src/base/cba/cbaNtk.c @@ -47,7 +47,7 @@ void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p ) int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) ); Cba_NtkForEachObjType( p, Type, i ) { - if ( Type == CBA_OBJ_NODE ) + if ( Type == CBA_OBJ_NODE && Cba_ObjNameId(p, i) == -1 ) { char Buffer[100]; sprintf( Buffer, "%s%0*d", "_n_", nDigits, i ); @@ -92,20 +92,6 @@ int Cba_ManObjNum( Cba_Man_t * p ) } return Count; } -void Cba_ManSetNtkBoxes( Cba_Man_t * p ) -{ - Cba_Ntk_t * pNtk, * pBox; - int i, k, Type; - Cba_ManForEachNtk( p, pNtk, i ) - Cba_NtkForEachObjType( pNtk, Type, k ) - if ( Type == CBA_OBJ_BOX ) - { - pBox = Cba_ObjBoxModel(pNtk, k); - assert( pBox->iBoxNtk == 0 ); - pBox->iBoxNtk = i; - pBox->iBoxObj = k; - } -} /**Function************************************************************* @@ -118,61 +104,74 @@ void Cba_ManSetNtkBoxes( Cba_Man_t * p ) SeeAlso [] ***********************************************************************/ -void Cba_ObjDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int iObj ) +// duplicate PI/PO/boxes +void Cba_ObjDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int iObj ) { if ( Cba_ObjIsPi(p, iObj) ) - Vec_IntWriteEntry( &pNew->vInputs, Cba_ObjFuncId(pNew, iObj), pNew->nObjs ); + Vec_IntWriteEntry( &pNew->vInputs, Cba_ObjFuncId(p, iObj), pNew->nObjs ); if ( Cba_ObjIsPo(p, iObj) ) - Vec_IntWriteEntry( &pNew->vOutputs, Cba_ObjFuncId(pNew, iObj), pNew->nObjs ); - if ( Cba_ObjIsBox(p, iObj) ) - Vec_IntPush( &pNew->vBoxes, pNew->nObjs ); + Vec_IntWriteEntry( &pNew->vOutputs, Cba_ObjFuncId(p, iObj), pNew->nObjs ); Vec_IntWriteEntry( &pNew->vTypes, pNew->nObjs, Cba_ObjType(p, iObj) ); - Vec_IntWriteEntry( &pNew->vFuncs, pNew->nObjs, Cba_ObjFuncId(pNew, iObj) ); + Vec_IntWriteEntry( &pNew->vFuncs, pNew->nObjs, Cba_ObjFuncId(p, iObj) ); Vec_IntWriteEntry( &pNew->vNameIds, pNew->nObjs, Cba_ObjNameId(p, iObj) ); + if ( Cba_ObjIsBox(p, iObj) ) + Cba_NtkSetHost( Cba_ObjBoxModel(pNew, pNew->nObjs), Cba_NtkId(pNew), pNew->nObjs ); + if ( Cba_ObjIsBox(p, iObj) ) + Vec_IntPush( &pNew->vBoxes, pNew->nObjs ); Cba_NtkSetCopy( p, iObj, pNew->nObjs++ ); } - -// allocates memory -Cba_Ntk_t * Cba_NtkDupAlloc( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, int nObjs ) -{ - Cba_Ntk_t * pNtkNew = Cba_NtkAlloc( pNew, Cba_NtkName(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vInputs, Cba_NtkPiNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vTypes, nObjs ); - Cba_ManFetchArray( pNew, &pNtkNew->vFuncs, nObjs ); - Cba_ManFetchArray( pNew, &pNtkNew->vFanins, nObjs ); - Cba_ManFetchArray( pNew, &pNtkNew->vNameIds, nObjs ); - Cba_ManFetchArray( pNew, &pNtkNew->vBoxes, Cba_NtkBoxNum(pNtk) ); - Vec_IntShrink( &pNtkNew->vBoxes, 0 ); - return pNtkNew; -} -// duplicate PI/PO/boxes -int Cba_NtkDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p ) +void Cba_NtkDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p ) { - int i, k, iObj; + int i, k, iObj, iTerm; + assert( Vec_IntSize(&pNew->vBoxes) == 0 ); pNew->nObjs = 0; Cba_NtkForEachPi( p, iObj, i ) - Cba_ObjDup( pNew, p, iObj ); + Cba_ObjDupStart( pNew, p, iObj ); Cba_NtkForEachPo( p, iObj, i ) - Cba_ObjDup( pNew, p, iObj ); + Cba_ObjDupStart( pNew, p, iObj ); Cba_NtkForEachBox( p, iObj, i ) { Cba_Ntk_t * pBox = Cba_ObjBoxModel( p, iObj ); - for ( k = 0; k < Cba_NtkPiNum(pBox); k++ ) - Cba_ObjDup( pNew, p, Cba_ObjBoxBi(p, iObj, k) ); - Cba_ObjDup( pNew, p, iObj ); - for ( k = 0; k < Cba_NtkPoNum(pBox); k++ ) - Cba_ObjDup( pNew, p, Cba_ObjBoxBo(p, iObj, k) ); + Cba_BoxForEachBi( p, iObj, iTerm, k ) + Cba_ObjDupStart( pNew, p, iTerm ); + Cba_ObjDupStart( pNew, p, iObj ); + Cba_BoxForEachBo( p, iObj, iTerm, k ) + Cba_ObjDupStart( pNew, p, iTerm ); } - return pNew->nObjs; + assert( Cba_NtkBoxNum(p) == Cba_NtkBoxNum(pNew) ); +} +Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vNtkSizes ) +{ + Cba_Ntk_t * pNtk; int i; + Cba_Man_t * pNew = Cba_ManClone( p ); + Cba_ManForEachNtk( p, pNtk, i ) + Cba_NtkResize( Cba_ManNtk(pNew, i), vNtkSizes ? Vec_IntEntry(vNtkSizes, i) : Cba_NtkObjNum(pNtk) ); + Vec_IntFill( &p->vCopies, Cba_ManObjNum(p), -1 ); + Cba_ManForEachNtk( p, pNtk, i ) + Cba_NtkDupStart( Cba_ManNtk(pNew, i), pNtk ); + return pNew; } + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ // duplicate internal nodes void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp ) { Vec_Int_t * vFanins; int i, k, Type, iTerm, iObj; + // dup nodes Cba_NtkForEachNode( p, iObj ) - Cba_ObjDup( pNew, p, iObj ); + Cba_ObjDupStart( pNew, p, iObj ); + assert( pNew->nObjs == Cba_NtkObjNum(pNew) ); // connect Cba_NtkForEachObjType( p, Type, i ) { @@ -190,33 +189,6 @@ void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp ) Vec_IntPush( vTemp, Cba_NtkCopy(p, iTerm) ); Vec_IntWriteEntry( &pNew->vFanins, Cba_NtkCopy(p, i), Cba_ManHandleArray(pNew->pDesign, vTemp) ); } - -} -// finalize network -void Cba_NtkDupFinish( Cba_Ntk_t * pNew ) -{ - int iObj; - // add constant drivers - Cba_NtkForEachCo( pNew, iObj ) - { - } - // restrict - Vec_IntShrink( &pNew->vTypes, pNew->nObjs ); - Vec_IntShrink( &pNew->vFuncs, pNew->nObjs ); - Vec_IntShrink( &pNew->vFanins, pNew->nObjs ); - Vec_IntShrink( &pNew->vNameIds, pNew->nObjs ); -} - -Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vObjCounts ) -{ - Cba_Ntk_t * pNtk; int i; - Cba_Man_t * pNew = Cba_ManAlloc( Cba_ManName(p) ); - Cba_ManForEachNtk( p, pNtk, i ) - Cba_NtkDupAlloc( pNew, pNtk, vObjCounts ? Cba_NtkObjNum(pNtk) : Vec_IntEntry(vObjCounts, i) ); - Vec_IntFill( &p->vCopies, Cba_ManObjNum(pNew), -1 ); - Cba_ManForEachNtk( p, pNtk, i ) - Cba_NtkDupStart( Cba_ManNtk(pNew, i), pNtk ); - return pNew; } Cba_Man_t * Cba_ManDup( Cba_Man_t * p ) { @@ -225,13 +197,12 @@ Cba_Man_t * Cba_ManDup( Cba_Man_t * p ) Cba_Man_t * pNew = Cba_ManDupStart( p, NULL ); Cba_ManForEachNtk( p, pNtk, i ) Cba_NtkDupNodes( Cba_ManNtk(pNew, i), pNtk, vTemp ); - Cba_ManForEachNtk( p, pNtk, i ) - Cba_NtkDupFinish( Cba_ManNtk(pNew, i) ); - Vec_IntClear( vTemp ); + Vec_IntFree( vTemp ); return pNew; } + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/base/cba/cbaSimple.c b/src/base/cba/cbaSimple.c index fb04b657..8b4c336f 100644 --- a/src/base/cba/cbaSimple.c +++ b/src/base/cba/cbaSimple.c @@ -36,33 +36,6 @@ node = array containing output name, followed by node type, followed by input box = array containing model name, instance name, followed by pairs of formal/actual names for each port */ -typedef enum { - PTR_OBJ_NONE, // 0: non-existent object - PTR_OBJ_CONST0, // 1: constant node - PTR_OBJ_PI, // 2: primary input - PTR_OBJ_PO, // 3: primary output - PTR_OBJ_FAN, // 4: box output - PTR_OBJ_FLOP, // 5: flip-flop - PTR_OBJ_BOX, // 6: box - PTR_OBJ_NODE, // 7: logic node - - PTR_OBJ_C0, // 8: logic node - PTR_OBJ_C1, // 9: logic node - PTR_OBJ_BUF, // 0: logic node - PTR_OBJ_INV, // 1: logic node - PTR_OBJ_AND, // 2: logic node - PTR_OBJ_OR, // 3: logic node - PTR_OBJ_XOR, // 4: logic node - PTR_OBJ_NAND, // 5: logic node - PTR_OBJ_NOR, // 6: logic node - PTR_OBJ_XNOR, // 7: logic node - PTR_OBJ_MUX, // 8: logic node - PTR_OBJ_MAJ, // 9: logic node - - PTR_VOID // 0: placeholder -} Ptr_ObjType_t; - - //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// @@ -78,44 +51,7 @@ typedef enum { SeeAlso [] ***********************************************************************/ -char * Ptr_TypeToName( Ptr_ObjType_t Type ) -{ - if ( Type == PTR_OBJ_BUF ) return "buf"; - if ( Type == PTR_OBJ_INV ) return "not"; - if ( Type == PTR_OBJ_AND ) return "and"; - if ( Type == PTR_OBJ_OR ) return "or"; - if ( Type == PTR_OBJ_XOR ) return "xor"; - if ( Type == PTR_OBJ_XNOR ) return "xnor"; - assert( 0 ); - return "???"; -} -char * Ptr_TypeToSop( int Type ) -{ - if ( Type == PTR_OBJ_BUF ) return "1 1\n"; - if ( Type == PTR_OBJ_INV ) return "0 1\n"; - if ( Type == PTR_OBJ_AND ) return "11 1\n"; - if ( Type == PTR_OBJ_OR ) return "00 0\n"; - if ( Type == PTR_OBJ_XOR ) return "01 1\n10 1\n"; - if ( Type == PTR_OBJ_XNOR ) return "00 1\n11 1\n"; - assert( 0 ); - return "???"; -} -Ptr_ObjType_t Ptr_SopToType( char * pSop ) -{ - if ( !strcmp(pSop, "1 1\n") ) return PTR_OBJ_BUF; - if ( !strcmp(pSop, "0 1\n") ) return PTR_OBJ_INV; - if ( !strcmp(pSop, "11 1\n") ) return PTR_OBJ_AND; - if ( !strcmp(pSop, "00 0\n") ) return PTR_OBJ_OR; - if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return PTR_OBJ_OR; - if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return PTR_OBJ_OR; - if ( !strcmp(pSop, "01 1\n10 1\n") ) return PTR_OBJ_XOR; - if ( !strcmp(pSop, "10 1\n01 1\n") ) return PTR_OBJ_XOR; - if ( !strcmp(pSop, "11 1\n00 1\n") ) return PTR_OBJ_XNOR; - if ( !strcmp(pSop, "00 1\n11 1\n") ) return PTR_OBJ_XNOR; - assert( 0 ); - return PTR_OBJ_NONE; -} -Ptr_ObjType_t Ptr_HopToType( Abc_Obj_t * pObj ) +Cba_NodeType_t Ptr_HopToType( Abc_Obj_t * pObj ) { static word uTruth, uTruths6[3] = { ABC_CONST(0xAAAAAAAAAAAAAAAA), @@ -124,14 +60,14 @@ Ptr_ObjType_t Ptr_HopToType( Abc_Obj_t * pObj ) }; assert( Abc_ObjIsNode(pObj) ); uTruth = Hop_ManComputeTruth6( (Hop_Man_t *)Abc_ObjNtk(pObj)->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj) ); - if ( uTruth == uTruths6[0] ) return PTR_OBJ_BUF; - if ( uTruth == ~uTruths6[0] ) return PTR_OBJ_INV; - if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return PTR_OBJ_AND; - if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return PTR_OBJ_OR; - if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return PTR_OBJ_XOR; - if ( uTruth == (uTruths6[0] ^~uTruths6[1]) ) return PTR_OBJ_XNOR; + if ( uTruth == uTruths6[0] ) return CBA_NODE_BUF; + if ( uTruth == ~uTruths6[0] ) return CBA_NODE_INV; + if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return CBA_NODE_AND; + if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return CBA_NODE_OR; + if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return CBA_NODE_XOR; + if ( uTruth == (uTruths6[0] ^~uTruths6[1]) ) return CBA_NODE_XNOR; assert( 0 ); - return PTR_OBJ_NONE; + return CBA_NODE_NONE; } /**Function************************************************************* @@ -315,11 +251,9 @@ void Ptr_ManDumpModuleBlif( FILE * pFile, Vec_Ptr_t * vNtk ) fprintf( pFile, "\n" ); fprintf( pFile, ".outputs" ); Ptr_ManDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 ); - fprintf( pFile, "\n\n" ); - Ptr_ManDumpNodesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) ); fprintf( pFile, "\n" ); + Ptr_ManDumpNodesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) ); Ptr_ManDumpBoxesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) ); - fprintf( pFile, "\n" ); fprintf( pFile, ".end\n\n" ); } void Ptr_ManDumpBlif( char * pFileName, Vec_Ptr_t * vDes ) @@ -352,7 +286,7 @@ void Ptr_ManDumpBlif( char * pFileName, Vec_Ptr_t * vDes ) void Ptr_ManDumpNodeVerilog( FILE * pFile, Vec_Ptr_t * vNode ) { char * pName; int i; - fprintf( pFile, "%s", Ptr_TypeToName( (Ptr_ObjType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ) ); + fprintf( pFile, "%s", Ptr_TypeToName( (Cba_NodeType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ) ); fprintf( pFile, "( %s", (char *)Vec_PtrEntry(vNode, 0) ); Vec_PtrForEachEntryStart( char *, vNode, pName, i, 2 ) fprintf( pFile, ", %s", pName ); @@ -651,7 +585,7 @@ void Cba_PrsReadNodes( Cba_Man_t * p, Vec_Ptr_t * vNodes, Vec_Int_t * vTypesCur, Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i ) { Vec_IntPush( vTypesCur, CBA_OBJ_NODE ); - Vec_IntPush( vFuncsCur, (Ptr_ObjType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ); + Vec_IntPush( vFuncsCur, (Cba_NodeType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ); Vec_IntPush( vInstIdsCur, 0 ); Vec_IntPush( vFaninsCur, Cba_ManHandleArray(p, Cba_PrsReadList(p, vNode, vList, 1, -1)) ); } @@ -676,6 +610,7 @@ void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk ) Vec_Int_t * vInstIdsCur = Vec_IntAlloc( 1000 ); Vec_Int_t * vFaninsCur = Vec_IntAlloc( 1000 ); Vec_Int_t * vList = Vec_IntAlloc( 1000 ); + Vec_Int_t * vBoxes = Vec_IntStart( Vec_PtrSize((Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4)) ); Cba_Ntk_t * pNtk = Cba_NtkAlloc( p, (char *)Vec_PtrEntry(vNtk, 0) ); Cba_PrsReadList( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), vInputsCur, -1, -1 ); @@ -689,6 +624,7 @@ void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk ) Cba_ManSetupArray( p, &pNtk->vFuncs, vFuncsCur ); Cba_ManSetupArray( p, &pNtk->vInstIds, vInstIdsCur ); Cba_ManSetupArray( p, &pNtk->vFanins, vFaninsCur ); + Cba_ManSetupArray( p, &pNtk->vBoxes, vBoxes ); Vec_IntFree( vInputsCur ); Vec_IntFree( vOutputsCur ); @@ -697,6 +633,7 @@ void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk ) Vec_IntFree( vInstIdsCur ); Vec_IntFree( vFaninsCur ); Vec_IntFree( vList ); + Vec_IntFree( vBoxes ); } Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes ) { @@ -721,6 +658,7 @@ Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes ) ***********************************************************************/ void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk ) { + extern Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p ); abctime clk = Abc_Clock(); Cba_Man_t * p, * pTemp; char * pFileName; @@ -751,9 +689,28 @@ void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk ) // dump pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out3.blif"); Cba_ManWriteBlif( pFileName, p ); - Cba_ManFree( p ); printf( "Finished writing output file \"%s\". ", pFileName ); Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); + + // duplicate CBA + p = Cba_ManDup( pTemp = p ); + Cba_ManFree( pTemp ); + // dump + pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out4.blif"); + Cba_ManWriteBlif( pFileName, p ); + printf( "Finished writing output file \"%s\". ", pFileName ); + Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); + + // CBA->GIA->CBA + p = Cba_ManBlastTest( pTemp = p ); + Cba_ManFree( pTemp ); + // dump + pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out5.blif"); + Cba_ManWriteBlif( pFileName, p ); + printf( "Finished writing output file \"%s\". ", pFileName ); + Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); + + Cba_ManFree( p ); } //////////////////////////////////////////////////////////////////////// diff --git a/src/base/cba/cbaWriteBlif.c b/src/base/cba/cbaWriteBlif.c index 001a291c..ea141005 100644 --- a/src/base/cba/cbaWriteBlif.c +++ b/src/base/cba/cbaWriteBlif.c @@ -75,7 +75,7 @@ void Cba_PrsWriteBlifLines( FILE * pFile, Cba_Ntk_t * p ) else if ( Type == CBA_OBJ_BOX ) // .names/assign/box2 (no formal/actual binding) { fprintf( pFile, ".subckt" ); - fprintf( pFile, " %s", Cba_ObjFuncStr(p, i) ); + fprintf( pFile, " %s", Cba_NtkName(Cba_ObjBoxModel(p, i)) ); Cba_PrsWriteBlifArray2( pFile, p, Cba_ObjFaninVec(p, i) ); } else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding) diff --git a/src/base/cba/cbaWriteVer.c b/src/base/cba/cbaWriteVer.c index 39ab1faf..8e72ee9a 100644 --- a/src/base/cba/cbaWriteVer.c +++ b/src/base/cba/cbaWriteVer.c @@ -26,44 +26,6 @@ ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// -/* - -// node types during parsing -typedef enum { - CBA_NODE_NONE = 0, // 0: unused - CBA_NODE_CONST, // 1: constant - CBA_NODE_BUF, // 2: buffer - CBA_NODE_INV, // 3: inverter - CBA_NODE_AND, // 4: AND - CBA_NODE_OR, // 5: OR - CBA_NODE_XOR, // 6: XOR - CBA_NODE_NAND, // 7: NAND - CBA_NODE_NOR, // 8: NOR - CBA_NODE_XNOR, // 9 .XNOR - CBA_NODE_MUX, // 10: MUX - CBA_NODE_MAJ, // 11: MAJ - CBA_NODE_KNOWN // 12: unknown - CBA_NODE_UNKNOWN // 13: unknown -} Cba_NodeType_t; - -*/ - -const char * s_NodeTypes[CBA_NODE_UNKNOWN+1] = { - NULL, // 0: unused - "const", // 1: constant - "buf", // 2: buffer - "not", // 3: inverter - "and", // 4: AND - "nand", // 5: OR - "or", // 6: XOR - "nor", // 7: NAND - "xor", // 8: NOR - "xnor", // 9: .XNOR - "mux", // 10: MUX - "maj", // 11: MAJ - "???" // 12: known - "???" // 13: unknown -}; //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// @@ -139,7 +101,7 @@ void Cba_PrsWriteVerilogNodes( FILE * pFile, Cba_Ntk_t * p ) Func = Cba_ObjFuncId(p, i); if ( Func >= CBA_NODE_BUF && Func <= CBA_NODE_XNOR ) { - fprintf( pFile, " %s (", s_NodeTypes[Func] ); + fprintf( pFile, " %s (", Ptr_TypeToName(Func) ); Cba_PrsWriteVerilogArray2( pFile, p, Cba_ObjFaninVec(p, i) ); fprintf( pFile, ");\n" ); } -- cgit v1.2.3