Skip to content

A
abc
Commit e27edf5e by Alan Mishchenko
Options

Various transformations of Cba_Ntk_t.

parent 8ac8923a
Showing with 467 additions and 442 deletions
src/base/cba/cba.h
...@@ -61,19 +61,22 @@ typedef enum { ...@@ -61,19 +61,22 @@ typedef enum {
// Verilog predefined models // Verilog predefined models
typedef enum { typedef enum {
CBA_NODE_NONE = 0, // 0: unused CBA_NODE_NONE = 0, // 0: unused
CBA_NODE_CONST, // 1: constant CBA_NODE_C0, // 1: logic node
CBA_NODE_BUF, // 2: buffer CBA_NODE_C1, // 2: logic node
CBA_NODE_INV, // 3: inverter CBA_NODE_BUF, // 3: buffer
CBA_NODE_AND, // 4: AND CBA_NODE_INV, // 4: inverter
CBA_NODE_NAND, // 5: NAND CBA_NODE_AND, // 5: AND
CBA_NODE_OR, // 6: OR CBA_NODE_NAND, // 6: NAND
CBA_NODE_NOR, // 7: NOR CBA_NODE_OR, // 7: OR
CBA_NODE_XOR, // 8: XOR CBA_NODE_NOR, // 8: NOR
CBA_NODE_XNOR, // 9 .XNOR CBA_NODE_XOR, // 9: XOR
CBA_NODE_MUX, // 10: MUX CBA_NODE_XNOR, // 10 XNOR
CBA_NODE_MAJ, // 11: MAJ CBA_NODE_MUX, // 11: MUX
CBA_NODE_KNOWN, // 12: unknown CBA_NODE_MAJ, // 12: MAJ
CBA_NODE_UNKNOWN // 13: unknown CBA_NODE_AND00, // 13: AND00
CBA_NODE_AND01, // 14: AND01
CBA_NODE_AND10, // 15: AND10
CBA_NODE_UNKNOWN // 16: unknown
} Cba_NodeType_t; } Cba_NodeType_t;
...@@ -150,7 +153,8 @@ static inline char * Cba_NtkFuncStr( Cba_Ntk_t * p, int i ) { r ...@@ -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 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_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 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 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 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 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 ...@@ -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_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_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_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_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 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_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 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 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 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_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_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; } 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 ) ...@@ -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 h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * 2 );
int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h ); int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h );
pArray[0] = 1; pArray[0] = (iFanin >= 0) ? 1 : 0;
pArray[1] = iFanin; pArray[1] = iFanin;
return h; return h;
} }
...@@ -289,6 +295,14 @@ static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName ) ...@@ -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 ); printf( "Model with name %s already exists.\n", pName );
return pNtk; 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 ) static inline Cba_Man_t * Cba_ManAlloc( char * pFileName )
{ {
Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 ); Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 );
...@@ -304,15 +318,25 @@ static inline Cba_Man_t * Cba_ManAlloc( char * pFileName ) ...@@ -304,15 +318,25 @@ static inline Cba_Man_t * Cba_ManAlloc( char * pFileName )
} }
static inline Cba_Man_t * Cba_ManClone( Cba_Man_t * pOld ) 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 ); Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 );
p->pName = Extra_FileDesignName( pOld->pName ); p->pName = Extra_FileDesignName( pOld->pName );
p->pSpec = Abc_UtilStrsav( pOld->pSpec ); p->pSpec = Abc_UtilStrsav( pOld->pSpec );
p->pNames = Abc_NamRef( pOld->pNames ); p->pNames = Abc_NamRef( pOld->pNames );
p->pModels = Abc_NamRef( pOld->pModels ); p->pModels = Abc_NamRef( pOld->pModels );
p->pFuncs = Abc_NamRef( pOld->pFuncs ); p->pFuncs = Abc_NamRef( pOld->pFuncs );
p->iRoot = 1;
Vec_SetAlloc_( &p->Mem, 20 ); Vec_SetAlloc_( &p->Mem, 20 );
Vec_PtrPush( &p->vNtks, NULL ); 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; return p;
} }
...@@ -343,6 +367,58 @@ static inline int Cba_ManMemory( Cba_Man_t * p ) ...@@ -343,6 +367,58 @@ static inline int Cba_ManMemory( Cba_Man_t * p )
return nMem; 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 =========================================================*/ /*=== cbaBuild.c =========================================================*/
extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ); extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p );
...@@ -359,8 +435,7 @@ extern void Cba_PrsWriteVerilog( char * pFileName, 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 void Cba_ManAssignInternNames( Cba_Man_t * p );
extern int Cba_NtkNodeNum( Cba_Ntk_t * p ); extern int Cba_NtkNodeNum( Cba_Ntk_t * p );
extern int Cba_ManObjNum( Cba_Man_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 * vNtkSizes );
extern Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vObjCounts );
extern Cba_Man_t * Cba_ManDup( Cba_Man_t * p ); extern Cba_Man_t * Cba_ManDup( Cba_Man_t * p );
......
src/base/cba/cbaBlast.c
...@@ -42,12 +42,15 @@ ABC_NAMESPACE_IMPL_START ...@@ -42,12 +42,15 @@ ABC_NAMESPACE_IMPL_START
SeeAlso [] 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->vBuf2LeafNtk, iLNtk );
Vec_IntPush( p->vBuf2LeafObj, iLObj ); Vec_IntPush( p->vBuf2LeafObj, iLObj );
Vec_IntPush( p->vBuf2RootNtk, iRNtk ); Vec_IntPush( p->vBuf2RootNtk, iRNtk );
Vec_IntPush( p->vBuf2RootObj, iRObj ); Vec_IntPush( p->vBuf2RootObj, iRObj );
return Gia_ManAppendBuf( pNew, iRes );
} }
int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i ) 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 ) ...@@ -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 ); Cba_Ntk_t * pBox = Cba_ObjBoModel( p, i );
int iObj = Cba_NtkPo( pBox, Cba_ObjCioIndex(p, i) ); int iObj = Cba_NtkPo( pBox, Cba_ObjCioIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pBox, iObj ); iRes = Cba_ManExtract_rec( pNew, pBox, iObj );
iRes = Gia_ManAppendBuf( pNew, iRes ); iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj );
Cba_ManExtractSave( p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj );
} }
else if ( Cba_ObjIsPi(p, i) ) else if ( Cba_ObjIsPi(p, i) )
{ {
Cba_Ntk_t * pHost = Cba_NtkHost( p ); Cba_Ntk_t * pHost = Cba_NtkHostNtk( p );
int iObj = Cba_ObjBoxBi( pHost, p->iBoxObj, Cba_ObjCioIndex(p, i) ); int iObj = Cba_ObjBoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjCioIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pHost, iObj ); iRes = Cba_ManExtract_rec( pNew, pHost, iObj );
iRes = Gia_ManAppendBuf( pNew, iRes ); iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj );
Cba_ManExtractSave( p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj );
} }
else if ( Cba_ObjIsNode(p, i) ) else if ( Cba_ObjIsNode(p, i) )
{ {
int * pFanins = Cba_ObjFaninArray(p, i); int * pFanins = Cba_ObjFaninArray(p, i);
int k, pLits[3], Type = Cba_ObjNodeType(p, i); int k, pLits[3], Type = Cba_ObjNodeType(p, i);
assert( pFanins[0] <= 3 ); assert( pFanins[0] <= 3 );
for ( k = 0; k < pFanins[0]; k++ ) if ( pFanins[0] == 0 )
pLits[k] = Cba_ManExtract_rec( pNew, p, pFanins[k+1] ); {
if ( Type == CBA_NODE_AND ) if ( Type == CBA_NODE_C0 )
iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); iRes = 0;
else if ( Type == CBA_NODE_OR ) else if ( Type == CBA_NODE_C1 )
iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); iRes = 1;
else if ( Type == CBA_NODE_XOR ) else assert( 0 );
iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] ); }
else if ( Type == CBA_NODE_XNOR ) else if ( pFanins[0] == 1 )
iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) ); {
else assert( 0 ), iRes = -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 ); else assert( 0 );
Cba_NtkSetCopy( p, i, iRes ); Cba_NtkSetCopy( p, i, iRes );
return iRes; return iRes;
} }
Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose )
{ {
Cba_Ntk_t * pRoot = Cba_ManRoot(p); Cba_Ntk_t * pRoot = Cba_ManRoot(p);
Gia_Man_t * pNew, * pTemp; Gia_Man_t * pNew, * pTemp;
int i, iObj; 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->vBuf2LeafNtk = Vec_IntAlloc( 1000 );
p->vBuf2LeafObj = Vec_IntAlloc( 1000 ); p->vBuf2LeafObj = Vec_IntAlloc( 1000 );
p->vBuf2RootNtk = Vec_IntAlloc( 1000 ); p->vBuf2RootNtk = Vec_IntAlloc( 1000 );
...@@ -108,12 +131,13 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) ...@@ -108,12 +131,13 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose )
pNew = Gia_ManStart( Cba_ManObjNum(p) ); pNew = Gia_ManStart( Cba_ManObjNum(p) );
pNew->pName = Abc_UtilStrsav(p->pName); pNew->pName = Abc_UtilStrsav(p->pName);
pNew->pSpec = Abc_UtilStrsav(p->pSpec); pNew->pSpec = Abc_UtilStrsav(p->pSpec);
Vec_IntFill( &p->vCopies, Cba_ManObjNum(p), -1 ); Vec_IntFill( &p->vCopies, Cba_ManObjNum(p), -1 );
Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkForEachPi( pRoot, iObj, i )
Cba_NtkSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) ); Cba_NtkSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) );
Gia_ManHashAlloc( pNew );
Cba_NtkForEachPo( pRoot, iObj, i ) Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ManExtract_rec( pNew, pRoot, iObj ); Cba_ManExtract_rec( pNew, pRoot, iObj );
Gia_ManHashStop( pNew );
Cba_NtkForEachPo( pRoot, iObj, i ) Cba_NtkForEachPo( pRoot, iObj, i )
Gia_ManAppendCo( pNew, Cba_NtkCopy(pRoot, iObj) ); Gia_ManAppendCo( pNew, Cba_NtkCopy(pRoot, iObj) );
assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs ); assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs );
...@@ -121,7 +145,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) ...@@ -121,7 +145,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose )
// cleanup // cleanup
pNew = Gia_ManCleanup( pTemp = pNew ); pNew = Gia_ManCleanup( pTemp = pNew );
Gia_ManStop( pTemp ); Gia_ManStop( pTemp );
// Gia_ManPrintStats( pNew, NULL ); Gia_ManPrintStats( pNew, NULL );
// pNew = Gia_ManSweepHierarchy( pTemp = pNew ); // pNew = Gia_ManSweepHierarchy( pTemp = pNew );
// Gia_ManStop( pTemp ); // Gia_ManStop( pTemp );
// Gia_ManPrintStats( pNew, NULL ); // Gia_ManPrintStats( pNew, NULL );
...@@ -130,7 +154,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) ...@@ -130,7 +154,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose )
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis [Returns the number of objects in each network.]
Description [] Description []
...@@ -139,122 +163,179 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose ) ...@@ -139,122 +163,179 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fVerbose )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
// return the array of object counters for each network Vec_Int_t * Cba_ManCountGia( Cba_Man_t * p, Gia_Man_t * pGia, int fAlwaysAdd )
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) ) 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 ( Gia_ObjIsBuf(pObj) )
if ( Abc_ObjIsPi(pFanin) || (Abc_ObjIsNode(pFanin) && Abc_ObjFaninNum(pFanin) > 0) ) {
Vec_IntAddToEntry( vBufDrivers, iNtk, 1 ); if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) )
Cba_ManCountNodes_rec( p, Abc_ObjFanin0(pObj), pObj->iTemp, vObjCounts, vBufDrivers, vObj2Ntk, vObj2Obj ); 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; assert( Gia_ObjFanin0(pObj)->Value == 1 );
Abc_ObjForEachFanin( pObj, pFanin, i ) pObj->Value = Gia_ObjFanin0(pObj)->Value;
Cba_ManCountNodes_rec( p, pFanin, iNtk, vObjCounts, vBufDrivers, vObj2Ntk, vObj2Obj ); if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) )
Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), iNtk ); Vec_IntAddToEntry( vDrivenCos, pObj->Value, 1 );
Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(vObjCounts, iNtk) );
Vec_IntAddToEntry( vObjCounts, iNtk, 1 );
} }
} // for each network, count the total number of COs
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 ) 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 ) 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) Vec_IntFree( vDrivenCos );
*pvObj2Ntk = Vec_IntStartFull( Abc_NtkObjNumMax(pAbcNtk) ); return vNtkSizes;
*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 ) void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p )
{ {
Cba_Man_t * pNew; Cba_Ntk_t * pNtk; int Entry, i;
Cba_Ntk_t * pNtk; assert( p->vBuf2RootNtk != NULL );
Abc_Obj_t * pObj, * pFanin; assert( pNew->vBuf2RootNtk == NULL );
Vec_Int_t * vObj2Ntk, * vObj2Obj; pNew->vBuf2RootNtk = Vec_IntDup( p->vBuf2RootNtk );
Vec_Int_t * vObjCounts = Cba_ManCountNodes( p, pAbcNtk, p->vBuf2RootNtk, &vObj2Ntk, &vObj2Obj ); pNew->vBuf2RootObj = Vec_IntDup( p->vBuf2RootObj );
Vec_Int_t * vFanins; pNew->vBuf2LeafNtk = Vec_IntDup( p->vBuf2LeafNtk );
int i, k, iNtk, iBuf = 0; pNew->vBuf2LeafObj = Vec_IntDup( p->vBuf2LeafObj );
// create initial mapping Vec_IntForEachEntry( p->vBuf2LeafObj, Entry, i )
pNew = Cba_ManDupStart( p, vObjCounts );
// set PIs point to the leaves
Abc_NtkForEachPi( pAbcNtk, pObj, i )
{ {
Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), p->iRoot ); pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2LeafNtk, i) );
Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), i ); Vec_IntWriteEntry( pNew->vBuf2LeafObj, i, Cba_NtkCopy(pNtk, Entry) );
} }
// set buffers to point to the leaves Vec_IntForEachEntry( p->vBuf2RootObj, Entry, i )
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) ); pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, i) );
Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2LeafObj, iBuf) ); Vec_IntWriteEntry( pNew->vBuf2RootObj, i, Cba_NtkCopy(pNtk, Entry) );
iBuf++;
} }
assert( iBuf == pAbcNtk->nBarBufs2 ); }
// copy internal nodes void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * pNtk, int iTerm )
vFanins = Vec_IntAlloc( 100 ); {
Abc_NtkForEachNode( pAbcNtk, pObj, i ) 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) ) Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, Gia_ObjFaninC0(pObj) ? CBA_NODE_INV : CBA_NODE_BUF );
continue; Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleBuffer(pNtk->pDesign, Gia_ObjFanin0(pObj)->Value) );
if ( Abc_ObjFaninNum(pObj) == 0 ) }
continue; Vec_IntWriteEntry( &pNtk->vNameIds, pNtk->nObjs, Cba_ObjNameId(pNtk, iTerm) );
Vec_IntClear( vFanins ); Vec_IntWriteEntry( &pNtk->vFanins, iTerm, pNtk->nObjs++ );
iNtk = Vec_IntEntry(vObj2Ntk, Abc_ObjId(pObj)); }
Abc_ObjForEachFanin( pObj, pFanin, k ) 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 ); Cba_NodeType_t Type;
Vec_IntPush( vFanins, Vec_IntEntry(vObj2Obj, Abc_ObjId(pFanin)) ); 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( Count == Gia_ManBufNum(pGia) );
assert( Vec_IntSize(p->vBuf2RootNtk) == pAbcNtk->nBarBufs2 ); Vec_IntFree( vTemp );
assert( Vec_IntSize(p->vBuf2RootObj) == pAbcNtk->nBarBufs2 );
iBuf = 0; // create constant 0 drivers for COs without barbufs
Abc_NtkForEachBarBuf( pAbcNtk, pObj, i ) Cba_ManForEachNtk( p, pNtk, i )
{ {
Vec_IntWriteEntry( vObj2Ntk, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootNtk, iBuf) ); Cba_NtkForEachBox( pNtk, iBox, k )
Vec_IntWriteEntry( vObj2Obj, Abc_ObjId(pObj), Vec_IntEntry(p->vBuf2RootObj, iBuf) ); Cba_BoxForEachBi( pNtk, iBox, iTerm, j )
iBuf++; 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 ); // create node and connect POs
// connect driven root nodes 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; return pNew;
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaBuild.c
...@@ -26,15 +26,6 @@ ABC_NAMESPACE_IMPL_START ...@@ -26,15 +26,6 @@ ABC_NAMESPACE_IMPL_START
/// DECLARATIONS /// /// 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 /// /// FUNCTION DEFINITIONS ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
...@@ -90,12 +81,45 @@ void Cba_NtkRemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) ...@@ -90,12 +81,45 @@ void Cba_NtkRemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap )
Cba_BoxRemap( pNtk, iBox, vMap ); Cba_BoxRemap( pNtk, iBox, vMap );
} }
// create maps of NameId and boxes // 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 i, iObj, Type, Index, NameId;
int nObjCount = 0; int nObjCount = 0;
// map old name IDs into new object IDs // map old name IDs into new object IDs
Vec_IntClear( vBoxes ); Vec_IntClear( vBoxes );
Cba_NtkForEachPi( pNtk, NameId, i ) Cba_NtkForEachPi( pNtk, NameId, i )
...@@ -109,7 +133,7 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) ...@@ -109,7 +133,7 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes )
if ( Type == CBA_OBJ_NODE ) if ( Type == CBA_OBJ_NODE )
{ {
// consider node output name // consider node output name
vFanins = Cba_ObjFaninVec( pNtk, iObj ); Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
NameId = Vec_IntEntry( vFanins, 0 ); NameId = Vec_IntEntry( vFanins, 0 );
if ( Vec_IntEntry(vMap, NameId) != -1 ) if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Node output name %d is already driven.\n", NameId ); 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 ) ...@@ -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 ) else if ( Type == CBA_OBJ_BOX )
{ {
Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj ); Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj );
nObjCount += Cba_NtkPiNum(pNtkBox); nObjCount += Cba_NtkPiNum(pNtkBox);
Vec_IntPush( vBoxes, nObjCount++ ); Vec_IntPush( vBoxes, nObjCount++ );
vFanins = Cba_ObjFaninVec( pNtk, iObj );
Vec_IntForEachEntry( vFanins, Index, i ) Vec_IntForEachEntry( vFanins, Index, i )
{ {
i++; i++;
...@@ -136,83 +160,11 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes ) ...@@ -136,83 +160,11 @@ int Cba_NtkCreateMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes )
nObjCount += Cba_NtkPoNum(pNtkBox); nObjCount += Cba_NtkPoNum(pNtkBox);
} }
} }
// add outputs Cba_NtkFindNonDriven( pNtk, vMap, nObjCount, vNonDriven );
nObjCount += Cba_NtkPoNum(pNtk); nObjCount += Vec_IntSize(vNonDriven) + Cba_NtkPoNum(pNtk);
return nObjCount; return nObjCount;
} }
void Cba_NtkCleanMap( Cba_Ntk_t * pNtk, Vec_Int_t * vMap ) 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;
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 )
{ {
Vec_Int_t * vFanins; Vec_Int_t * vFanins;
Cba_Ntk_t * pNtkNew, * pNtkBox; 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, ...@@ -220,11 +172,7 @@ Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap,
// start network // start network
pNtkNew = Cba_ManNtk( pNew, Cba_NtkId(pNtk) ); pNtkNew = Cba_ManNtk( pNew, Cba_NtkId(pNtk) );
Cba_ManFetchArray( pNew, &pNtkNew->vTypes, nObjCount ); Cba_NtkResize( pNtkNew, 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 // fill object information
Cba_NtkForEachPi( pNtk, NameId, i ) 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, ...@@ -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->vFuncs, ObjId, i );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
} }
Cba_NtkForEachObjType( pNtk, Type, iObj ) Cba_NtkForEachObjType( pNtk, Type, iObj )
{ {
vFanins = Cba_ObjFaninVec( pNtk, 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, ...@@ -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->vTypes, FaninId, CBA_OBJ_BI );
Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i ); 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 // create box outputs
Cba_BoxForEachBo( pNtkNew, ObjId, FaninId, i ) Cba_BoxForEachBo( pNtkNew, ObjId, FaninId, i )
{ {
Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BO ); Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BO );
Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i ); 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) ); 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 ) Cba_NtkForEachPo( pNtk, NameId, i )
{ {
ObjId = nObjCount - Cba_NtkPoNum(pNtk) + 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, ...@@ -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->vOutputs, i, ObjId );
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_PO ); Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_PO );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, i ); 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 // remove NameId from the driver and assign it to the output
//Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 ); //Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId ); Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
} }
return pNtkNew; 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 ); Vec_Int_t * vFanins;
Cba_Ntk_t * pNtk, * pNtkNew; int i; int i, iObj, Type, NameId;
Cba_ManForEachNtk( p, pNtk, i ) Cba_NtkForEachPi( pNtk, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
Cba_NtkForEachObjType( pNtk, Type, iObj )
{ {
pNtkNew = Cba_NtkAlloc( pNew, Cba_NtkName(pNtk) ); vFanins = Cba_ObjFaninVec( pNtk, iObj );
Cba_ManFetchArray( pNew, &pNtkNew->vInputs, Cba_NtkPiNum(pNtk) ); if ( Type == CBA_OBJ_NODE )
Cba_ManFetchArray( pNew, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) ); {
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) ); Cba_NtkForEachPo( pNtk, NameId, i )
return pNew; Vec_IntWriteEntry( vMap, NameId, -1 );
} }
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ) 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 * 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 ); Vec_Int_t * vTemp = Vec_IntAlloc( 1000 );
Cba_Ntk_t * pNtk; int i, nObjs; Cba_Ntk_t * pNtk; int i, nObjs;
assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 ); assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 );
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
{ {
Cba_NtkRemapBoxes( pNtk, vMap ); Cba_NtkRemapBoxes( pNtk, vMap );
nObjs = Cba_NtkCreateMap( pNtk, vMap, vBoxes ); nObjs = Cba_NtkCreateMap( pNtk, vMap, &Cba_ManNtk(pNew, i)->vBoxes, vNonDr );
Cba_NtkCheckNonDriven( pNtk, vMap, nObjs ); Cba_NtkBuild( pNew, pNtk, vMap, vNonDr, vTemp, nObjs );
Cba_NtkBuild( pNew, pNtk, vMap, vBoxes, vTemp, nObjs );
Cba_NtkCleanMap( pNtk, vMap ); Cba_NtkCleanMap( pNtk, vMap );
} }
Vec_IntFree( vTemp );
Vec_IntFree( vBoxes );
Vec_IntFree( vMap ); Vec_IntFree( vMap );
Vec_IntFree( vNonDr );
Vec_IntFree( vTemp );
return pNew; return pNew;
} }
......
src/base/cba/cbaNtk.c
...@@ -47,7 +47,7 @@ void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p ) ...@@ -47,7 +47,7 @@ void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p )
int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) ); int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) );
Cba_NtkForEachObjType( p, Type, i ) Cba_NtkForEachObjType( p, Type, i )
{ {
if ( Type == CBA_OBJ_NODE ) if ( Type == CBA_OBJ_NODE && Cba_ObjNameId(p, i) == -1 )
{ {
char Buffer[100]; char Buffer[100];
sprintf( Buffer, "%s%0*d", "_n_", nDigits, i ); sprintf( Buffer, "%s%0*d", "_n_", nDigits, i );
...@@ -92,20 +92,6 @@ int Cba_ManObjNum( Cba_Man_t * p ) ...@@ -92,20 +92,6 @@ int Cba_ManObjNum( Cba_Man_t * p )
} }
return Count; 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************************************************************* /**Function*************************************************************
...@@ -118,61 +104,74 @@ void Cba_ManSetNtkBoxes( Cba_Man_t * p ) ...@@ -118,61 +104,74 @@ void Cba_ManSetNtkBoxes( Cba_Man_t * p )
SeeAlso [] 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) ) 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) ) if ( Cba_ObjIsPo(p, iObj) )
Vec_IntWriteEntry( &pNew->vOutputs, Cba_ObjFuncId(pNew, iObj), pNew->nObjs ); Vec_IntWriteEntry( &pNew->vOutputs, Cba_ObjFuncId(p, 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->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) ); 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++ ); Cba_NtkSetCopy( p, iObj, pNew->nObjs++ );
} }
void Cba_NtkDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
// 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; int i, k, iObj, iTerm;
assert( Vec_IntSize(&pNew->vBoxes) == 0 );
pNew->nObjs = 0; pNew->nObjs = 0;
Cba_NtkForEachPi( p, iObj, i ) Cba_NtkForEachPi( p, iObj, i )
Cba_ObjDup( pNew, p, iObj ); Cba_ObjDupStart( pNew, p, iObj );
Cba_NtkForEachPo( p, iObj, i ) Cba_NtkForEachPo( p, iObj, i )
Cba_ObjDup( pNew, p, iObj ); Cba_ObjDupStart( pNew, p, iObj );
Cba_NtkForEachBox( p, iObj, i ) Cba_NtkForEachBox( p, iObj, i )
{ {
Cba_Ntk_t * pBox = Cba_ObjBoxModel( p, iObj ); Cba_Ntk_t * pBox = Cba_ObjBoxModel( p, iObj );
for ( k = 0; k < Cba_NtkPiNum(pBox); k++ ) Cba_BoxForEachBi( p, iObj, iTerm, k )
Cba_ObjDup( pNew, p, Cba_ObjBoxBi(p, iObj, k) ); Cba_ObjDupStart( pNew, p, iTerm );
Cba_ObjDup( pNew, p, iObj ); Cba_ObjDupStart( pNew, p, iObj );
for ( k = 0; k < Cba_NtkPoNum(pBox); k++ ) Cba_BoxForEachBo( p, iObj, iTerm, k )
Cba_ObjDup( pNew, p, Cba_ObjBoxBo(p, iObj, 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 // duplicate internal nodes
void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp ) void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp )
{ {
Vec_Int_t * vFanins; Vec_Int_t * vFanins;
int i, k, Type, iTerm, iObj; int i, k, Type, iTerm, iObj;
// dup nodes
Cba_NtkForEachNode( p, iObj ) Cba_NtkForEachNode( p, iObj )
Cba_ObjDup( pNew, p, iObj ); Cba_ObjDupStart( pNew, p, iObj );
assert( pNew->nObjs == Cba_NtkObjNum(pNew) );
// connect // connect
Cba_NtkForEachObjType( p, Type, i ) Cba_NtkForEachObjType( p, Type, i )
{ {
...@@ -190,33 +189,6 @@ void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp ) ...@@ -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_IntPush( vTemp, Cba_NtkCopy(p, iTerm) );
Vec_IntWriteEntry( &pNew->vFanins, Cba_NtkCopy(p, i), Cba_ManHandleArray(pNew->pDesign, vTemp) ); 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_Man_t * Cba_ManDup( Cba_Man_t * p )
{ {
...@@ -225,13 +197,12 @@ 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_Man_t * pNew = Cba_ManDupStart( p, NULL );
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDupNodes( Cba_ManNtk(pNew, i), pNtk, vTemp ); Cba_NtkDupNodes( Cba_ManNtk(pNew, i), pNtk, vTemp );
Cba_ManForEachNtk( p, pNtk, i ) Vec_IntFree( vTemp );
Cba_NtkDupFinish( Cba_ManNtk(pNew, i) );
Vec_IntClear( vTemp );
return pNew; return pNew;
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaSimple.c
...@@ -36,33 +36,6 @@ node = array containing output name, followed by node type, followed by input ...@@ -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 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 /// /// FUNCTION DEFINITIONS ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
...@@ -78,44 +51,7 @@ typedef enum { ...@@ -78,44 +51,7 @@ typedef enum {
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
char * Ptr_TypeToName( Ptr_ObjType_t Type ) Cba_NodeType_t Ptr_HopToType( Abc_Obj_t * pObj )
{
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 )
{ {
static word uTruth, uTruths6[3] = { static word uTruth, uTruths6[3] = {
ABC_CONST(0xAAAAAAAAAAAAAAAA), ABC_CONST(0xAAAAAAAAAAAAAAAA),
...@@ -124,14 +60,14 @@ Ptr_ObjType_t Ptr_HopToType( Abc_Obj_t * pObj ) ...@@ -124,14 +60,14 @@ Ptr_ObjType_t Ptr_HopToType( Abc_Obj_t * pObj )
}; };
assert( Abc_ObjIsNode(pObj) ); assert( Abc_ObjIsNode(pObj) );
uTruth = Hop_ManComputeTruth6( (Hop_Man_t *)Abc_ObjNtk(pObj)->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(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 CBA_NODE_BUF;
if ( uTruth == ~uTruths6[0] ) return PTR_OBJ_INV; if ( uTruth == ~uTruths6[0] ) return CBA_NODE_INV;
if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return PTR_OBJ_AND; if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return CBA_NODE_AND;
if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return PTR_OBJ_OR; if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return CBA_NODE_OR;
if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return PTR_OBJ_XOR; if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return CBA_NODE_XOR;
if ( uTruth == (uTruths6[0] ^~uTruths6[1]) ) return PTR_OBJ_XNOR; if ( uTruth == (uTruths6[0] ^~uTruths6[1]) ) return CBA_NODE_XNOR;
assert( 0 ); assert( 0 );
return PTR_OBJ_NONE; return CBA_NODE_NONE;
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -315,11 +251,9 @@ void Ptr_ManDumpModuleBlif( FILE * pFile, Vec_Ptr_t * vNtk ) ...@@ -315,11 +251,9 @@ void Ptr_ManDumpModuleBlif( FILE * pFile, Vec_Ptr_t * vNtk )
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
fprintf( pFile, ".outputs" ); fprintf( pFile, ".outputs" );
Ptr_ManDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 ); 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" ); fprintf( pFile, "\n" );
Ptr_ManDumpNodesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) );
Ptr_ManDumpBoxesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) ); Ptr_ManDumpBoxesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
fprintf( pFile, "\n" );
fprintf( pFile, ".end\n\n" ); fprintf( pFile, ".end\n\n" );
} }
void Ptr_ManDumpBlif( char * pFileName, Vec_Ptr_t * vDes ) void Ptr_ManDumpBlif( char * pFileName, Vec_Ptr_t * vDes )
...@@ -352,7 +286,7 @@ 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 ) void Ptr_ManDumpNodeVerilog( FILE * pFile, Vec_Ptr_t * vNode )
{ {
char * pName; int i; 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) ); fprintf( pFile, "( %s", (char *)Vec_PtrEntry(vNode, 0) );
Vec_PtrForEachEntryStart( char *, vNode, pName, i, 2 ) Vec_PtrForEachEntryStart( char *, vNode, pName, i, 2 )
fprintf( pFile, ", %s", pName ); fprintf( pFile, ", %s", pName );
...@@ -651,7 +585,7 @@ void Cba_PrsReadNodes( Cba_Man_t * p, Vec_Ptr_t * vNodes, Vec_Int_t * vTypesCur, ...@@ -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_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
{ {
Vec_IntPush( vTypesCur, CBA_OBJ_NODE ); 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( vInstIdsCur, 0 );
Vec_IntPush( vFaninsCur, Cba_ManHandleArray(p, Cba_PrsReadList(p, vNode, vList, 1, -1)) ); 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 ) ...@@ -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 * vInstIdsCur = Vec_IntAlloc( 1000 );
Vec_Int_t * vFaninsCur = Vec_IntAlloc( 1000 ); Vec_Int_t * vFaninsCur = Vec_IntAlloc( 1000 );
Vec_Int_t * vList = 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_Ntk_t * pNtk = Cba_NtkAlloc( p, (char *)Vec_PtrEntry(vNtk, 0) );
Cba_PrsReadList( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), vInputsCur, -1, -1 ); 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 ) ...@@ -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->vFuncs, vFuncsCur );
Cba_ManSetupArray( p, &pNtk->vInstIds, vInstIdsCur ); Cba_ManSetupArray( p, &pNtk->vInstIds, vInstIdsCur );
Cba_ManSetupArray( p, &pNtk->vFanins, vFaninsCur ); Cba_ManSetupArray( p, &pNtk->vFanins, vFaninsCur );
Cba_ManSetupArray( p, &pNtk->vBoxes, vBoxes );
Vec_IntFree( vInputsCur ); Vec_IntFree( vInputsCur );
Vec_IntFree( vOutputsCur ); Vec_IntFree( vOutputsCur );
...@@ -697,6 +633,7 @@ void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk ) ...@@ -697,6 +633,7 @@ void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk )
Vec_IntFree( vInstIdsCur ); Vec_IntFree( vInstIdsCur );
Vec_IntFree( vFaninsCur ); Vec_IntFree( vFaninsCur );
Vec_IntFree( vList ); Vec_IntFree( vList );
Vec_IntFree( vBoxes );
} }
Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes ) Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes )
{ {
...@@ -721,6 +658,7 @@ 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 ) void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk )
{ {
extern Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p );
abctime clk = Abc_Clock(); abctime clk = Abc_Clock();
Cba_Man_t * p, * pTemp; Cba_Man_t * p, * pTemp;
char * pFileName; char * pFileName;
...@@ -751,9 +689,28 @@ void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk ) ...@@ -751,9 +689,28 @@ void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk )
// dump // dump
pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out3.blif"); pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out3.blif");
Cba_ManWriteBlif( pFileName, p ); Cba_ManWriteBlif( pFileName, p );
Cba_ManFree( p );
printf( "Finished writing output file \"%s\". ", pFileName ); printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); 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 );
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaWriteBlif.c
...@@ -75,7 +75,7 @@ void Cba_PrsWriteBlifLines( FILE * pFile, Cba_Ntk_t * p ) ...@@ -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) else if ( Type == CBA_OBJ_BOX ) // .names/assign/box2 (no formal/actual binding)
{ {
fprintf( pFile, ".subckt" ); 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) ); Cba_PrsWriteBlifArray2( pFile, p, Cba_ObjFaninVec(p, i) );
} }
else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding) else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding)
......
src/base/cba/cbaWriteVer.c
...@@ -26,44 +26,6 @@ ABC_NAMESPACE_IMPL_START ...@@ -26,44 +26,6 @@ ABC_NAMESPACE_IMPL_START
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// DECLARATIONS /// /// 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 /// /// FUNCTION DEFINITIONS ///
...@@ -139,7 +101,7 @@ void Cba_PrsWriteVerilogNodes( FILE * pFile, Cba_Ntk_t * p ) ...@@ -139,7 +101,7 @@ void Cba_PrsWriteVerilogNodes( FILE * pFile, Cba_Ntk_t * p )
Func = Cba_ObjFuncId(p, i); Func = Cba_ObjFuncId(p, i);
if ( Func >= CBA_NODE_BUF && Func <= CBA_NODE_XNOR ) 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) ); Cba_PrsWriteVerilogArray2( pFile, p, Cba_ObjFaninVec(p, i) );
fprintf( pFile, ");\n" ); fprintf( pFile, ");\n" );
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment