From 2b2f05bacd6349310ba05b5123570705892768f0 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Tue, 13 Jan 2015 17:05:22 -0800 Subject: Various transformations of Cba_Ntk_t. --- src/base/cba/cba.h | 176 +++++++++++++++++++++++------------- src/base/cba/cbaBlast.c | 212 ++++++++++++++++++++++++++++++++++++++++++++ src/base/cba/cbaBuild.c | 125 ++++++++++++++++---------- src/base/cba/cbaNtk.c | 171 ++++++++++++++++++++++++++++++++++- src/base/cba/cbaSimple.c | 2 +- src/base/cba/cbaWriteBlif.c | 2 +- 6 files changed, 577 insertions(+), 111 deletions(-) (limited to 'src') diff --git a/src/base/cba/cba.h b/src/base/cba/cba.h index 88b601cf..8ef5d868 100644 --- a/src/base/cba/cba.h +++ b/src/base/cba/cba.h @@ -46,13 +46,13 @@ ABC_NAMESPACE_HEADER_START // network objects typedef enum { CBA_OBJ_NONE = 0, // 0: unused - CBA_OBJ_BARBUF, // 1: barrier buffer - CBA_OBJ_PI, // 2: input - CBA_OBJ_PO, // 3: output - CBA_OBJ_PIO, // 4: input - CBA_OBJ_NODE, // 5: node - CBA_OBJ_BOX, // 6: box - CBA_OBJ_PIN, // 7: box output + CBA_OBJ_BI, // 1: box input + CBA_OBJ_BO, // 2: box output + CBA_OBJ_PI, // 3: input + CBA_OBJ_PO, // 4: output + CBA_OBJ_PIO, // 5: input + CBA_OBJ_NODE, // 6: node + CBA_OBJ_BOX, // 7: box CBA_OBJ_LATCH, // 8: latch CBA_OBJ_UNKNOWN // 9: unknown } Cba_ObjType_t; @@ -91,6 +91,11 @@ struct Cba_Man_t_ Vec_Set_t Mem; // memory Vec_Ptr_t vNtks; // networks int iRoot; // root network + Vec_Int_t vCopies; // copies + Vec_Int_t * vBuf2RootNtk; + Vec_Int_t * vBuf2RootObj; + Vec_Int_t * vBuf2LeafNtk; + Vec_Int_t * vBuf2LeafObj; }; // network @@ -99,6 +104,11 @@ struct Cba_Ntk_t_ { char * pName; // name Cba_Man_t * pDesign; // design + int Id; // network ID + int iBoxNtk; // instance network ID + int iBoxObj; // instance object ID + int nObjs; // object counter + int iObjStart;// first object in global order // interface Vec_Int_t vInouts; // inouts (used by parser to store signals as NameId) Vec_Int_t vInputs; // inputs (used by parser to store signals as NameId) @@ -106,65 +116,85 @@ struct Cba_Ntk_t_ Vec_Int_t vWires; // wires (used by parser to store signals as NameId) // objects 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 vInstIds; // instance names (used by parser to store instance name as NameId) - Vec_Int_t vFanins; // fanins (used by parser to store fanin/fanout/range as NameId) + Vec_Int_t vFuncs; // functions (used by parser to store function) (node: function; box: model; CI/CO: index) + Vec_Int_t vInstIds; // instance names (used by parser to store instance name as NameId) + Vec_Int_t vFanins; // fanins (used by parser to store fanin/fanout/range as NameId) (node: handle; CO/BI fanin0) // attributes Vec_Int_t vBoxes; // box objects Vec_Int_t vNameIds; // original names as NameId Vec_Int_t vRanges; // ranges as NameId - Vec_Int_t vCopies; // copy pointers }; -static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; } -static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return Vec_PtrSize(&p->vNtks) - 1; } -static inline int Cba_ManNtkId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pModels, pName); } -static inline Cba_Ntk_t * Cba_ManNtk( Cba_Man_t * p, int i ) { assert( i > 0 ); return (Cba_Ntk_t *)Vec_PtrEntry(&p->vNtks, i); } -static inline Cba_Ntk_t * Cba_ManRoot( Cba_Man_t * p ) { return Cba_ManNtk(p, p->iRoot); } -static inline Vec_Set_t * Cba_ManMem( Cba_Man_t * p ) { return &p->Mem; } -static inline int Cba_ManMemSave( Cba_Man_t * p, int * d, int s ) { return Vec_SetAppend(Cba_ManMem(p), d, s); } -static inline int * Cba_ManMemRead( Cba_Man_t * p, int h ) { return h ? (int *)Vec_SetEntry(Cba_ManMem(p), h) : NULL; } - -static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return p->pName; } -static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; } -static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFanins); } -static inline int Cba_NtkPiNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); } -static inline int Cba_NtkPoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); } -static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vBoxes); } -static inline int Cba_NtkNodeNum( Cba_Ntk_t * p ) { return Cba_NtkObjNum(p) - Cba_NtkPiNum(p) - Cba_NtkPoNum(p) - Cba_NtkBoxNum(p); } -static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); } -static inline int Cba_NtkPo( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); } -static inline char * Cba_NtkStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pNames, i); } -static inline char * Cba_NtkModelStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pModels, i); } -static inline char * Cba_NtkFuncStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pFuncs, i); } -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_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vTypes, i); } -static inline int Cba_ObjIsPi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PI; } -static inline int Cba_ObjIsPo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PO; } -static inline int Cba_ObjIsNode( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_NODE; } -static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; } -static inline int Cba_ObjIsPin( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PIN; } -static inline int Cba_ObjFuncId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vFuncs, i); } -static inline int Cba_ObjInstId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInstIds, i); } -static inline int * Cba_ObjFaninArray( Cba_Ntk_t * p, int i ) { return Cba_NtkMemRead(p, Vec_IntEntry(&p->vFanins, 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_Ntk_t * Cba_ObjModel( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_ManNtk(p->pDesign, Cba_ObjFuncId(p, i)); } - -static inline int Cba_ObjNameId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vNameIds, i); } -static inline int Cba_ObjRangeId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vRanges, i); } -static inline int Cba_ObjCopyId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCopies, i); } - -static inline char * Cba_ObjFuncStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjFuncId(p, i)); } -static inline char * Cba_ObjInstStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjInstId(p, i)); } -static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjNameId(p, i)); } -static inline char * Cba_ObjRangeStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjRangeId(p, i)); } +static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; } +static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return Vec_PtrSize(&p->vNtks) - 1; } +static inline int Cba_ManNtkId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pModels, pName); } +static inline Cba_Ntk_t * Cba_ManNtk( Cba_Man_t * p, int i ) { assert( i > 0 ); return (Cba_Ntk_t *)Vec_PtrEntry(&p->vNtks, i); } +static inline Cba_Ntk_t * Cba_ManRoot( Cba_Man_t * p ) { return Cba_ManNtk(p, p->iRoot); } +static inline Vec_Set_t * Cba_ManMem( Cba_Man_t * p ) { return &p->Mem; } +static inline int Cba_ManMemSave( Cba_Man_t * p, int * d, int s ) { return Vec_SetAppend(Cba_ManMem(p), d, s); } +static inline int * Cba_ManMemRead( Cba_Man_t * p, int h ) { return h ? (int *)Vec_SetEntry(Cba_ManMem(p), h) : NULL; } + +static inline int Cba_NtkId( Cba_Ntk_t * p ) { return p->Id; } +static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return p->pName; } +static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; } +static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFanins); } +static inline int Cba_NtkPiNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); } +static inline int Cba_NtkPoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); } +static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vBoxes); } +static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); } +static inline int Cba_NtkPo( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); } +static inline char * Cba_NtkStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pNames, i); } +static inline char * Cba_NtkModelStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pModels, i); } +static inline char * Cba_NtkFuncStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pFuncs, i); } +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 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 ); } +static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( Cba_NtkCopies(p), p->iObjStart + i, x ); } + +static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vTypes, i); } +static inline int Cba_ObjFuncId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vFuncs, i); } +static inline int Cba_ObjInstId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInstIds, i); } +static inline int Cba_ObjFaninId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vFanins, i); } +static inline int Cba_ObjNameId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vNameIds, i); } +static inline int Cba_ObjRangeId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vRanges, i); } + +static inline int Cba_ObjIsPi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PI; } +static inline int Cba_ObjIsPo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PO; } +static inline int Cba_ObjIsBi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BI; } +static inline int Cba_ObjIsBo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BO; } +static inline int Cba_ObjIsNode( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_NODE; } +static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; } +static inline int Cba_ObjIsCi( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsBo(p, i); } +static inline int Cba_ObjIsCo( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPo(p, i) || Cba_ObjIsBi(p, i); } +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_ObjFaninArray( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsNode(p, i)); 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 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_ObjBoxBi( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, i)); return b - Cba_NtkPiNum(Cba_ObjBoxModel(p, b)) + i; } +static inline int Cba_ObjBoxBo( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, i)); return b + 1 + i; } +static inline int Cba_ObjBiModelId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBi(p, i)); while (!Cba_ObjIsBox(p, i)) i++; return Cba_ObjBoxModelId(p, i); } +static inline int Cba_ObjBoModelId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBo(p, i)); return Cba_ObjBoxModelId(p, Cba_ObjFanin0(p, i)); } +static inline Cba_Ntk_t * Cba_ObjBiModel( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_ObjBiModelId(p, i) ); } +static inline Cba_Ntk_t * Cba_ObjBoModel( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_ObjBoModelId(p, i) ); } +static inline int Cba_ObjCioIndex( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCio(p, i) || Cba_ObjIsBio(p, i)); return Cba_ObjFuncId(p, i); } + +static inline char * Cba_ObjFuncStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjFuncId(p, i)); } +static inline char * Cba_ObjInstStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjInstId(p, i)); } +static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjNameId(p, i)); } +static inline char * Cba_ObjRangeStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjRangeId(p, i)); } //////////////////////////////////////////////////////////////////////// @@ -179,9 +209,9 @@ static inline char * Cba_ObjRangeStr( Cba_Ntk_t * p, int i ) { re #define Cba_ManForEachNtk( p, pNtk, i ) \ for ( i = 1; (i <= Cba_ManNtkNum(p)) && (((pNtk) = Cba_ManNtk(p, i)), 1); i++ ) -#define Cba_NtkForEachPi( p, iObj, i ) \ +#define Cba_NtkForEachPi( p, iObj, i ) \ for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Vec_IntEntry(&p->vInputs, i)), 1); i++ ) -#define Cba_NtkForEachPo( p, iObj, i ) \ +#define Cba_NtkForEachPo( p, iObj, i ) \ for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Vec_IntEntry(&p->vOutputs, i)), 1); i++ ) #define Cba_NtkForEachObjType( p, Type, i ) \ @@ -189,6 +219,15 @@ static inline char * Cba_ObjRangeStr( Cba_Ntk_t * p, int i ) { re #define Cba_NtkForEachObjTypeFuncFanins( p, Type, Func, vFanins, i ) \ for ( i = 0; (i < Cba_NtkObjNum(p)) && (((Type) = Cba_ObjType(p, i)), 1) && (((Func) = Cba_ObjFuncId(p, i)), 1) && (((vFanins) = Cba_ObjFaninVec(p, i)), 1); i++ ) +#define Cba_NtkForEachBox( p, iObj, i ) \ + for ( i = 0; (i < Cba_NtkBoxNum(p)) && (((iObj) = Vec_IntEntry(&p->vBoxes, i)), 1); i++ ) +#define Cba_NtkForEachNode( p, i ) \ + for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( Cba_ObjType(p, i) != CBA_OBJ_NODE ) {} else + +#define Cba_NtkForEachCi( p, i ) \ + for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( Cba_ObjType(p, i) != CBA_OBJ_PI && Cba_ObjType(p, i) != CBA_OBJ_BO ) {} else +#define Cba_NtkForEachCo( p, i ) \ + for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( Cba_ObjType(p, i) != CBA_OBJ_PO && Cba_ObjType(p, i) != CBA_OBJ_BI ) {} else //////////////////////////////////////////////////////////////////////// /// FUNCTION DECLARATIONS /// @@ -237,6 +276,7 @@ static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName ) memset( pNtk, 0, sizeof(Cba_Ntk_t) ); pNtk->pDesign = p; pNtk->pName = Vec_SetStrsav( Cba_ManMem(p), pName ); + pNtk->Id = Vec_PtrSize(&p->vNtks); Vec_PtrPush( &p->vNtks, pNtk ); return pNtk; } @@ -254,6 +294,11 @@ static inline Cba_Man_t * Cba_ManAlloc( char * pFileName ) } static inline void Cba_ManFree( Cba_Man_t * p ) { + Vec_IntFreeP( &p->vBuf2LeafNtk ); + Vec_IntFreeP( &p->vBuf2LeafObj ); + Vec_IntFreeP( &p->vBuf2RootNtk ); + Vec_IntFreeP( &p->vBuf2RootObj ); + ABC_FREE( p->vCopies.pArray ); ABC_FREE( p->vNtks.pArray ); Vec_SetFree_( &p->Mem ); Abc_NamStop( p->pNames ); @@ -275,6 +320,8 @@ static inline int Cba_ManMemory( Cba_Man_t * p ) } +/*=== cbaBuild.c =========================================================*/ +extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ); /*=== cbaReadBlif.c =========================================================*/ extern Cba_Man_t * Cba_PrsReadBlif( char * pFileName ); /*=== cbaWriteBlif.c ========================================================*/ @@ -285,8 +332,11 @@ extern Cba_Man_t * Cba_PrsReadVerilog( char * pFileName ); extern void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * pDes ); /*=== cbaNtk.c =========================================================*/ extern void Cba_ManAssignInternNames( Cba_Man_t * p ); -/*=== cbaBuild.c =========================================================*/ -extern Cba_Man_t * Cba_ManBuild( 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_ManDup( Cba_Man_t * p ); diff --git a/src/base/cba/cbaBlast.c b/src/base/cba/cbaBlast.c index f4cea24a..8d2d53cd 100644 --- a/src/base/cba/cbaBlast.c +++ b/src/base/cba/cbaBlast.c @@ -19,6 +19,7 @@ ***********************************************************************/ #include "cba.h" +#include "base/abc/abc.h" ABC_NAMESPACE_IMPL_START @@ -41,7 +42,218 @@ ABC_NAMESPACE_IMPL_START SeeAlso [] ***********************************************************************/ +void Cba_ManExtractSave( Cba_Man_t * p, int iLNtk, int iLObj, int iRNtk, int iRObj ) +{ + Vec_IntPush( p->vBuf2LeafNtk, iLNtk ); + Vec_IntPush( p->vBuf2LeafObj, iLObj ); + Vec_IntPush( p->vBuf2RootNtk, iRNtk ); + Vec_IntPush( p->vBuf2RootObj, iRObj ); +} +int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i ) +{ + int iRes = Cba_NtkCopy( p, i ); + if ( iRes >= 0 ) + return iRes; + if ( Cba_ObjIsCo(p, i) ) + iRes = Cba_ManExtract_rec( pNew, p, Cba_ObjFanin0(p, i) ); + else if ( Cba_ObjIsBo(p, 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 ); + } + else if ( Cba_ObjIsPi(p, i) ) + { + Cba_Ntk_t * pHost = Cba_NtkHost( p ); + int iObj = Cba_ObjBoxBi( pHost, p->iBoxObj, 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 ); + } + 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; + } + 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; + p->vBuf2LeafNtk = Vec_IntAlloc( 1000 ); + p->vBuf2LeafObj = Vec_IntAlloc( 1000 ); + p->vBuf2RootNtk = Vec_IntAlloc( 1000 ); + p->vBuf2RootObj = Vec_IntAlloc( 1000 ); + + // start the manager + 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) ); + Cba_NtkForEachPo( pRoot, iObj, i ) + Cba_ManExtract_rec( pNew, pRoot, iObj ); + Cba_NtkForEachPo( pRoot, iObj, i ) + Gia_ManAppendCo( pNew, Cba_NtkCopy(pRoot, iObj) ); + assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs ); + + // cleanup + pNew = Gia_ManCleanup( pTemp = pNew ); + Gia_ManStop( pTemp ); +// Gia_ManPrintStats( pNew, NULL ); +// pNew = Gia_ManSweepHierarchy( pTemp = pNew ); +// Gia_ManStop( pTemp ); +// Gia_ManPrintStats( pNew, NULL ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + 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 ) +{ + if ( Abc_ObjIsBarBuf(pObj) ) + { + 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 ); + } + else if ( Abc_ObjFaninNum(pObj) > 0 ) + { + 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 ); + } +} +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 + Cba_ManForEachNtk( p, pNtk, i ) + { + Vec_IntAddToEntry( vObjCounts, i, Cba_NtkPiNum(pNtk) ); + Cba_NtkForEachBox( pNtk, iBox, k ) + Vec_IntAddToEntry( vObjCounts, i, Cba_NtkPiNum(Cba_ObjBoxModel(pNtk, iBox)) + Cba_NtkPoNum(Cba_ObjBoxModel(pNtk, iBox)) + 1 ); + } + // 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; +} +Cba_Man_t * Cba_ManInsert( Cba_Man_t * p, Abc_Ntk_t * pAbcNtk, int fVerbose ) +{ + 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 ) + { + Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), p->iRoot ); + Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), i ); + } + // 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_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2LeafNtk, iBuf) ); + Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2LeafObj, iBuf) ); + iBuf++; + } + assert( iBuf == pAbcNtk->nBarBufs2 ); + // copy internal nodes + vFanins = Vec_IntAlloc( 100 ); + Abc_NtkForEachNode( pAbcNtk, pObj, i ) + { + 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 ) + { + assert( Vec_IntEntry(vObj2Ntk, Abc_ObjId(pFanin)) == iNtk ); + Vec_IntPush( vFanins, Vec_IntEntry(vObj2Obj, Abc_ObjId(pFanin)) ); + } + 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 ) + { + Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootNtk, iBuf) ); + Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootObj, iBuf) ); + iBuf++; + } + assert( iBuf == pAbcNtk->nBarBufs2 ); + // connect driven root nodes + + + Vec_IntFree( vObj2Ntk ); + Vec_IntFree( vObj2Obj ); + return pNew; +} //////////////////////////////////////////////////////////////////////// /// END OF FILE /// diff --git a/src/base/cba/cbaBuild.c b/src/base/cba/cbaBuild.c index db29cc49..41830208 100644 --- a/src/base/cba/cbaBuild.c +++ b/src/base/cba/cbaBuild.c @@ -51,9 +51,9 @@ ABC_NAMESPACE_IMPL_START ***********************************************************************/ // replaces NameIds of formal names by their index in the box model -void Cba_RemapBox( Cba_Ntk_t * pNtk, int iBox, Vec_Int_t * vMap ) +void Cba_BoxRemap( Cba_Ntk_t * pNtk, int iBox, Vec_Int_t * vMap ) { - Cba_Ntk_t * pBoxModel = Cba_ObjModel( pNtk, iBox ); + Cba_Ntk_t * pBoxModel = Cba_ObjBoxModel( pNtk, iBox ); Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iBox ); int i, NameId; // map formal names into I/O indexes @@ -80,19 +80,19 @@ void Cba_RemapBox( Cba_Ntk_t * pNtk, int iBox, Vec_Int_t * vMap ) Cba_NtkForEachPo( pBoxModel, NameId, i ) Vec_IntWriteEntry( vMap, NameId, -1 ); } -void Cba_RemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) +void Cba_NtkRemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) { int Type, iBox; Cba_NtkForEachObjType( pNtk, Type, iBox ) if ( Type == CBA_OBJ_BOX ) - Cba_RemapBox( pNtk, iBox, vMap ); + Cba_BoxRemap( pNtk, iBox, vMap ); } -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 ) +// create maps of NameId and boxes +int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) { Vec_Int_t * vFanins; - Cba_Ntk_t * pNtkNew, * pNtkBox; - int i, iObj, ObjId, FaninId, Type, Index, NameId; - int nBoxes = 0, nObjCount = 0, NonDriven = 0; + int i, iObj, Type, Index, NameId; + int nObjCount = 0; // map old name IDs into new object IDs Vec_IntClear( vBoxes ); @@ -104,10 +104,10 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, } Cba_NtkForEachObjType( pNtk, Type, iObj ) { - vFanins = Cba_ObjFaninVec( pNtk, iObj ); if ( Type == CBA_OBJ_NODE ) { // consider node output name + 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 ); @@ -115,13 +115,16 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, } else if ( Type == CBA_OBJ_BOX ) { + Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); + nObjCount += Cba_NtkPiNum(pNtkBox); Vec_IntPush( vBoxes, nObjCount++ ); - pNtkBox = Cba_ObjModel( pNtk, iObj ); + vFanins = Cba_ObjFaninVec( pNtk, iObj ); Vec_IntForEachEntry( vFanins, Index, i ) { i++; if ( Index < Cba_NtkPiNum(pNtkBox) ) continue; + assert( Index - Cba_NtkPiNum(pNtkBox) < Cba_NtkPoNum(pNtkBox) ); // consider box output name NameId = Vec_IntEntry( vFanins, i ); if ( Vec_IntEntry(vMap, NameId) != -1 ) @@ -131,14 +134,45 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, nObjCount += Cba_NtkPoNum(pNtkBox); } } - - // check non-driven nets + // add outputs + nObjCount += 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 ) @@ -149,7 +183,8 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, } else if ( Type == CBA_OBJ_BOX ) { - pNtkBox = Cba_ObjModel( pNtk, iObj ); + Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); + vFanins = Cba_ObjFaninVec( pNtk, iObj ); Vec_IntForEachEntry( vFanins, Index, i ) { i++; @@ -173,16 +208,22 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, } if ( NonDriven > 0 ) printf( "Detected %d non-driven nets.\n", NonDriven ); - assert( NonDriven == 0 ); + 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 ) +{ + Vec_Int_t * vFanins; + Cba_Ntk_t * pNtkNew, * pNtkBox; + int i, iObj, ObjId, FaninId, Type, Index, NameId, nBoxes = 0; // start network 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, nObjCount + Cba_NtkPoNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vFuncs, nObjCount + Cba_NtkPoNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vFanins, nObjCount + Cba_NtkPoNum(pNtk) ); - Cba_ManFetchArray( pNew, &pNtkNew->vNameIds, nObjCount + Cba_NtkPoNum(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 ); // fill object information @@ -212,7 +253,9 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, else if ( Type == CBA_OBJ_BOX ) { ObjId = Vec_IntEntry( vBoxes, nBoxes++ ); - pNtkBox = Cba_ObjModel( pNtk, iObj ); + pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); + Cba_NtkSetHost( pNtkBox, Cba_NtkId(pNtk), ObjId ); + // collect fanins Vec_IntFill( vTemp, Cba_NtkPiNum(pNtkBox), -1 ); Vec_IntForEachEntry( vFanins, Index, i ) { @@ -225,6 +268,13 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, } Vec_IntForEachEntry( vTemp, Index, i ) assert( Index >= 0 ); + // create box inputs + for ( i = 0; i < Cba_NtkPiNum(pNtkBox); i++ ) + { + Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId - Cba_NtkPiNum(pNtkBox) + i, CBA_OBJ_BI ); + Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId - Cba_NtkPiNum(pNtkBox) + i, i ); + Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId - Cba_NtkPiNum(pNtkBox) + i, Cba_ManHandleBuffer(pNew, Vec_IntEntry(vTemp, i)) ); + } // craete box Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_BOX ); Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, Cba_ManNtkId(pNew, Cba_NtkName(pNtkBox)) ); @@ -232,8 +282,8 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, // create box outputs for ( i = 1; i <= Cba_NtkPoNum(pNtkBox); i++ ) { - Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId + i, CBA_OBJ_PIN ); - Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId + i, -1 ); + Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId + i, CBA_OBJ_BO ); + Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId + i, i-1 ); Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId + i, Cba_ManHandleBuffer(pNew, ObjId) ); } } @@ -241,7 +291,7 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, assert( nBoxes == Vec_IntSize(vBoxes) ); Cba_NtkForEachPo( pNtk, NameId, i ) { - ObjId = nObjCount + i; + ObjId = nObjCount - Cba_NtkPoNum(pNtk) + i; FaninId = Vec_IntEntry( vMap, NameId ); assert( FaninId != -1 ); Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId ); @@ -252,26 +302,6 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 ); Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); } - - // clean map - 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, Index, i ) - Vec_IntWriteEntry( vMap, Vec_IntEntry(vFanins, ++i), -1 ); - } - } - Cba_NtkForEachPo( pNtk, NameId, i ) - Vec_IntWriteEntry( vMap, NameId, -1 ); return pNtkNew; } Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ) @@ -280,13 +310,18 @@ Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ) Vec_Int_t * vMap = Vec_IntStartFull( Abc_NamObjNumMax(p->pNames) + 1 ); Vec_Int_t * vBoxes = Vec_IntAlloc( 1000 ); Vec_Int_t * vTemp = Vec_IntAlloc( 1000 ); - Cba_Ntk_t * pNtk; int i; + Cba_Ntk_t * pNtk; int i, nObjs; Cba_ManForEachNtk( p, pNtk, i ) Abc_NamStrFindOrAdd( p->pModels, Cba_NtkName(pNtk), NULL ); assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 ); - Cba_RemapBoxes( pNtk, vMap ); Cba_ManForEachNtk( p, pNtk, i ) - Cba_NtkBuild( p, pNtk, vMap, vBoxes, vTemp ); + { + Cba_NtkRemapBoxes( pNtk, vMap ); + nObjs = Cba_NtkCreateMap( pNtk, vMap, vBoxes ); + Cba_NtkCheckNonDriven( pNtk, vMap, nObjs ); + Cba_NtkBuild( pNew, pNtk, vMap, vBoxes, vTemp, nObjs ); + Cba_NtkCleanMap( pNtk, vMap ); + } Vec_IntFree( vTemp ); Vec_IntFree( vBoxes ); Vec_IntFree( vMap ); diff --git a/src/base/cba/cbaNtk.c b/src/base/cba/cbaNtk.c index c0c63bec..30e721a6 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 || Type == CBA_OBJ_PIN ) + if ( Type == CBA_OBJ_NODE ) { char Buffer[100]; sprintf( Buffer, "%s%0*d", "_n_", nDigits, i ); @@ -63,6 +63,175 @@ void Cba_ManAssignInternNames( Cba_Man_t * p ) Cba_ManAssignInternNamesNtk( pNtk ); } +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cba_NtkNodeNum( Cba_Ntk_t * p ) +{ + int iObj, Count = 0; + Cba_NtkForEachNode( p, iObj ) + Count++; + return Count; +} +int Cba_ManObjNum( Cba_Man_t * p ) +{ + Cba_Ntk_t * pNtk; + int i, Count = 0; + Cba_ManForEachNtk( p, pNtk, i ) + { + pNtk->iObjStart = Count; + Count += Cba_NtkObjNum(pNtk); + } + 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************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cba_ObjDup( 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 ); + 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->vTypes, pNew->nObjs, Cba_ObjType(p, iObj) ); + Vec_IntWriteEntry( &pNew->vFuncs, pNew->nObjs, Cba_ObjFuncId(pNew, iObj) ); + Vec_IntWriteEntry( &pNew->vNameIds, pNew->nObjs, Cba_ObjNameId(p, iObj) ); + 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 ) +{ + int i, k, iObj; + pNew->nObjs = 0; + Cba_NtkForEachPi( p, iObj, i ) + Cba_ObjDup( pNew, p, iObj ); + Cba_NtkForEachPo( p, iObj, i ) + Cba_ObjDup( 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) ); + } + return pNew->nObjs; +} +// 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; + Cba_NtkForEachNode( p, iObj ) + Cba_ObjDup( pNew, p, iObj ); + // connect + Cba_NtkForEachObjType( p, Type, i ) + { + if ( Type == CBA_OBJ_PI || Type == CBA_OBJ_BOX ) + continue; + if ( Type == CBA_OBJ_PO || Type == CBA_OBJ_BI || Type == CBA_OBJ_BO ) + { + Vec_IntWriteEntry( &pNew->vFanins, Cba_NtkCopy(p, i), Cba_NtkCopy(p, Cba_ObjFanin0(p, i)) ); + continue; + } + assert( Type == CBA_OBJ_NODE ); + Vec_IntClear( vTemp ); + vFanins = Cba_ObjFaninVec( p, i ); + Vec_IntForEachEntry( vFanins, iTerm, k ) + 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 ) +{ + Cba_Ntk_t * pNtk; int i; + Vec_Int_t * vTemp = Vec_IntAlloc( 100 ); + 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 ); + return pNew; + +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/base/cba/cbaSimple.c b/src/base/cba/cbaSimple.c index a58b8d9b..eb7dde09 100644 --- a/src/base/cba/cbaSimple.c +++ b/src/base/cba/cbaSimple.c @@ -554,7 +554,7 @@ Vec_Ptr_t * Ptr_CbaDeriveBox( Cba_Ntk_t * pNtk, int iObj ) { int i, iTerm; Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj ); - Cba_Ntk_t * pModel = Cba_ObjModel( pNtk, iObj ); + Cba_Ntk_t * pModel = Cba_ObjBoxModel( pNtk, iObj ); Vec_Ptr_t * vBox = Vec_PtrAlloc( 2 + Cba_NtkPiNum(pModel) + Cba_NtkPoNum(pModel) ); assert( Cba_ObjIsBox(pNtk, iObj) ); assert( Cba_NtkPiNum(pModel) == Vec_IntSize(vFanins) ); diff --git a/src/base/cba/cbaWriteBlif.c b/src/base/cba/cbaWriteBlif.c index ef6b31fc..a3966cda 100644 --- a/src/base/cba/cbaWriteBlif.c +++ b/src/base/cba/cbaWriteBlif.c @@ -143,7 +143,7 @@ void Cba_ManWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, int iObj ) { int iTerm, i; Vec_Int_t * vFanins = Cba_ObjFaninVec( p, iObj ); - Cba_Ntk_t * pModel = Cba_ObjModel( p, iObj ); + Cba_Ntk_t * pModel = Cba_ObjBoxModel( p, iObj ); Cba_NtkForEachPi( pModel, iTerm, i ) fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Vec_IntEntry(vFanins, i)) ); Cba_NtkForEachPo( pModel, iTerm, i ) -- cgit v1.2.3