Skip to content

A
abc
Commit 77dbe2b6 by Alan Mishchenko
Options

Major rehash of the CBA code.

parent a523ab79
Showing with 3408 additions and 2731 deletions
abclib.dsp
...@@ -783,10 +783,6 @@ SOURCE=.\src\base\cba\cbaBlast.c ...@@ -783,10 +783,6 @@ SOURCE=.\src\base\cba\cbaBlast.c
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=.\src\base\cba\cbaBuild.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaCom.c SOURCE=.\src\base\cba\cbaCom.c
# End Source File # End Source File
# Begin Source File # Begin Source File
...@@ -803,15 +799,27 @@ SOURCE=.\src\base\cba\cbaPrs.h ...@@ -803,15 +799,27 @@ SOURCE=.\src\base\cba\cbaPrs.h
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=.\src\base\cba\cbaReadBlif.c SOURCE=.\src\base\cba\cbaPrsBuild.c
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=.\src\base\cba\cbaReadVer.c SOURCE=.\src\base\cba\cbaPrsTrans.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaPtr.c
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=.\src\base\cba\cbaSimple.c SOURCE=.\src\base\cba\cbaPtrAbc.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaReadBlif.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaReadVer.c
# End Source File # End Source File
# Begin Source File # Begin Source File
......
src/base/cba/cba.h
...@@ -4,7 +4,7 @@ ...@@ -4,7 +4,7 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [External declarations.] Synopsis [External declarations.]
...@@ -28,9 +28,6 @@ ...@@ -28,9 +28,6 @@
#include "aig/gia/gia.h" #include "aig/gia/gia.h"
#include "misc/extra/extra.h" #include "misc/extra/extra.h"
#include "misc/util/utilNam.h" #include "misc/util/utilNam.h"
#include "misc/extra/extra.h"
#include "misc/util/utilTruth.h"
#include "misc/vec/vecSet.h"
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// PARAMETERS /// /// PARAMETERS ///
...@@ -45,212 +42,225 @@ ABC_NAMESPACE_HEADER_START ...@@ -45,212 +42,225 @@ ABC_NAMESPACE_HEADER_START
// network objects // network objects
typedef enum { typedef enum {
CBA_OBJ_NONE = 0, // 0: unused CBA_OBJ_NONE = 0, // 0: unused
CBA_OBJ_BI, // 1: box input CBA_OBJ_PI, // 1: input
CBA_OBJ_BO, // 2: box output CBA_OBJ_PO, // 2: output
CBA_OBJ_PI, // 3: input CBA_OBJ_BI, // 3: box input
CBA_OBJ_PO, // 4: output CBA_OBJ_BO, // 4: box output
CBA_OBJ_NODE, // 5: node CBA_OBJ_BOX, // 5: box
CBA_OBJ_BOX, // 6: box
CBA_OBJ_LATCH, // 7: latch CBA_BOX_C0,
CBA_OBJ_CONCAT, // 8: concatenation CBA_BOX_C1,
CBA_OBJ_UNKNOWN // 9: unknown CBA_BOX_CX,
CBA_BOX_CZ,
CBA_BOX_BUF,
CBA_BOX_INV,
CBA_BOX_AND,
CBA_BOX_NAND,
CBA_BOX_OR,
CBA_BOX_NOR,
CBA_BOX_XOR,
CBA_BOX_XNOR,
CBA_BOX_SHARP,
CBA_BOX_MUX,
CBA_BOX_MAJ,
CBA_BOX_RAND,
CBA_BOX_RNAND,
CBA_BOX_ROR,
CBA_BOX_RNOR,
CBA_BOX_RXOR,
CBA_BOX_RXNOR,
CBA_BOX_SEL,
CBA_BOX_PSEL,
CBA_BOX_ENC,
CBA_BOX_PENC,
CBA_BOX_DEC,
CBA_BOX_ADD,
CBA_BOX_SUB,
CBA_BOX_MUL,
CBA_BOX_DIV,
CBA_BOX_MOD,
CBA_BOX_REM,
CBA_BOX_POW,
CBA_BOX_ABS,
CBA_BOX_LTHAN,
CBA_BOX_LETHAN,
CBA_BOX_METHAN,
CBA_BOX_MTHAN,
CBA_BOX_EQU,
CBA_BOX_NEQU,
CBA_BOX_SHIL,
CBA_BOX_SHIR,
CBA_BOX_ROTL,
CBA_BOX_ROTR,
CBA_BOX_GATE,
CBA_BOX_LUT,
CBA_BOX_ASSIGN,
CBA_BOX_TRI,
CBA_BOX_RAM,
CBA_BOX_RAMR,
CBA_BOX_RAMW,
CBA_BOX_RAMWC,
CBA_BOX_LATCH,
CBA_BOX_LATCHRS,
CBA_BOX_DFF,
CBA_BOX_DFFRS,
CBA_BOX_UNKNOWN // 50
} Cba_ObjType_t; } Cba_ObjType_t;
// Verilog predefined models
typedef enum {
CBA_NODE_NONE = 0, // 0: unused
CBA_NODE_C0, // 1: constant 0
CBA_NODE_C1, // 2: constant 1
CBA_NODE_CX, // 2: constant X
CBA_NODE_CZ, // 2: constant Z
CBA_NODE_BUF, // 3: buffer
CBA_NODE_INV, // 4: inverter
CBA_NODE_AND, // 5: AND
CBA_NODE_NAND, // 6: NAND
CBA_NODE_OR, // 7: OR
CBA_NODE_NOR, // 8: NOR
CBA_NODE_XOR, // 9: XOR
CBA_NODE_XNOR, // 10 XNOR
CBA_NODE_SHARP, // 11: SHARP
CBA_NODE_MUX, // 12: MUX
CBA_NODE_MAJ, // 13: MAJ
CBA_NODE_LUT, // 14: LUT
CBA_NODE_RAND,
CBA_NODE_RNAND,
CBA_NODE_ROR,
CBA_NODE_RNOR,
CBA_NODE_RXOR,
CBA_NODE_RXNOR,
CBA_NODE_SEL,
CBA_NODE_PSEL,
CBA_NODE_ENC,
CBA_NODE_PENC,
CBA_NODE_DEC,
CBA_NODE_ADD,
CBA_NODE_SUB,
CBA_NODE_MUL,
CBA_NODE_DIV,
CBA_NODE_MOD,
CBA_NODE_REM,
CBA_NODE_POW,
CBA_NODE_ABS,
CBA_NODE_LTHEN,
CBA_NODE_MTHEN,
CBA_NODE_EQU,
CBA_NODE_NEQU,
CBA_NODE_SHIL,
CBA_NODE_SHIR,
CBA_NODE_ROTL,
CBA_NODE_ROTR,
CBA_NODE_TRI,
CBA_NODE_RAM,
CBA_NODE_RAMR,
CBA_NODE_RAMW,
CBA_NODE_RAMWC,
CBA_NODE_LATCH,
CBA_NODE_LATCHRS,
CBA_NODE_DFF,
CBA_NODE_DFFRS,
CBA_NODE_UNKNOWN // 50
} Cba_NodeType_t;
typedef struct Cba_Ntk_t_ Cba_Ntk_t;
typedef struct Cba_Man_t_ Cba_Man_t;
// network
struct Cba_Ntk_t_
{
Cba_Man_t * pDesign; // design
int NameId; // name ID
int iCopy; // copy module
int iBoxNtk; // instance network ID
int iBoxObj; // instance object ID
int Count; // object counter
int Mark; // visit mark
// interface
Vec_Int_t vInputs; // inputs
Vec_Int_t vOutputs; // outputs
// object attributes
Vec_Str_t vType; // types
Vec_Int_t vIndex; // index
Vec_Int_t vFanin; // fanin
Vec_Int_t vName; // original NameId or InstId
Vec_Int_t vRange; // range
Vec_Int_t vCopy; // copy
// other
Vec_Int_t vArray;
};
// design // design
typedef struct Cba_Man_t_ Cba_Man_t;
struct Cba_Man_t_ struct Cba_Man_t_
{ {
// design names // design names
char * pName; // design name char * pName; // design name
char * pSpec; // spec file name char * pSpec; // spec file name
Abc_Nam_t * pNames; // name manager Abc_Nam_t * pStrs; // string manager
Abc_Nam_t * pModels; // model name manager Abc_Nam_t * pMods; // module name manager
Abc_Nam_t * pFuncs; // functionality manager
Cba_Man_t * pLib; // library
// internal data // internal data
Vec_Set_t Mem; // memory
Vec_Ptr_t vNtks; // networks
int iRoot; // root network int iRoot; // root network
Vec_Int_t vCopies; // copies int nNtks; // number of current networks
Cba_Ntk_t * pNtks; // networks
// user data
Vec_Int_t * vBuf2RootNtk; Vec_Int_t * vBuf2RootNtk;
Vec_Int_t * vBuf2RootObj; Vec_Int_t * vBuf2RootObj;
Vec_Int_t * vBuf2LeafNtk; Vec_Int_t * vBuf2LeafNtk;
Vec_Int_t * vBuf2LeafObj; Vec_Int_t * vBuf2LeafObj;
void * pMioLib; void * pMioLib;
void ** ppGraphs; void ** ppGraphs;
int ElemGates[4];
}; };
// network
typedef struct Cba_Ntk_t_ Cba_Ntk_t;
struct Cba_Ntk_t_
{
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)
Vec_Int_t vOutputs; // outputs (used by parser to store signals as NameId)
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) (node: function; box: model; CI/CO: index)
Vec_Int_t vFanins; // fanins (used by parser to store fanin/fanout/range as NameId) (node: handle; CO/BI fanin0)
// attributes
Vec_Int_t vInstIds; // instance names (used by parser to store instance name as NameId)
Vec_Int_t vNameIds; // original names as NameId
};
static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; } static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; }
static inline char * Cba_ManSpec( Cba_Man_t * p ) { return p->pSpec; } static inline char * Cba_ManSpec( Cba_Man_t * p ) { return p->pSpec; }
static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return Vec_PtrSize(&p->vNtks) - 1; } static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return p->nNtks; }
static inline int Cba_ManNtkId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pModels, pName); } static inline int Cba_ManNtkIsOk( Cba_Man_t * p, int i ) { return i >= 0 && i < Cba_ManNtkNum(p); }
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_ManNtk( Cba_Man_t * p, int i ) { return Cba_ManNtkIsOk(p, i) ? p->pNtks + i : NULL; }
static inline Cba_Ntk_t * Cba_ManNtkFind( Cba_Man_t * p, char * pName ) { return Cba_ManNtk( p, Cba_ManNtkId(p, pName) ); } static inline int Cba_ManNtkFindId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName) - 1; }
static inline Cba_Ntk_t * Cba_ManNtkFind( Cba_Man_t * p, char * pName ) { return Cba_ManNtk( p, Cba_ManNtkFindId(p, pName) ); }
static inline Cba_Ntk_t * Cba_ManRoot( Cba_Man_t * p ) { return Cba_ManNtk(p, p->iRoot); } 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 char * Cba_ManStr( Cba_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); }
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_ManStrId( Cba_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); }
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 ) { int i = p - p->pDesign->pNtks; assert(Cba_ManNtkIsOk(p->pDesign, i)); return i; }
static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; } static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; }
static inline int Cba_NtkId( Cba_Ntk_t * p ) { return p->Id; } static inline int Cba_NtkNameId( Cba_Ntk_t * p ) { return p->NameId; }
static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return Abc_NamStr(Cba_NtkMan(p)->pModels, Cba_NtkId(p)); } static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return Cba_ManStr(p->pDesign, Cba_NtkNameId(p)); }
static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFanins); } static inline int Cba_NtkCopy( Cba_Ntk_t * p ) { return p->iCopy; }
static inline int Cba_NtkPioNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInouts); } static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i ) { assert(p->iCopy == -1); p->iCopy = i; }
static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_StrSize(&p->vType); }
static inline int Cba_NtkAllocNum( Cba_Ntk_t * p ) { return Vec_StrCap(&p->vType); }
static inline int Cba_NtkPiNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); } 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_NtkPoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); }
static inline int Cba_NtkNodeNum( Cba_Ntk_t * p ) { return Vec_IntCountEntry(&p->vTypes, CBA_OBJ_NODE); } static inline int Cba_NtkPioNum( Cba_Ntk_t * p ) { return Cba_NtkPiNum(p) + Cba_NtkPoNum(p); }
static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Vec_IntCountEntry(&p->vTypes, CBA_OBJ_BOX); } static inline int Cba_NtkPiNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vInputs); }
static inline int Cba_NtkPoNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vOutputs); }
static inline int Cba_NtkBiNum( Cba_Ntk_t * p ) { return Vec_StrCountEntry(&p->vType, (char)CBA_OBJ_BI); }
static inline int Cba_NtkBoNum( Cba_Ntk_t * p ) { return Vec_StrCountEntry(&p->vType, (char)CBA_OBJ_BO); }
static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Cba_NtkObjNum(p) - Vec_StrCountSmaller(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkPrimNum( Cba_Ntk_t * p ) { return Vec_StrCountLarger(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkUserNum( Cba_Ntk_t * p ) { return Vec_StrCountEntry(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkPio( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInouts, i); }
static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); } 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 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_NtkStr( Cba_Ntk_t * p, int i ) { return Cba_ManStr(p->pDesign, i); }
static inline char * Cba_NtkModelStr( Cba_Ntk_t * p, int i ) { return Abc_NamStr(p->pDesign->pModels, i); } static inline Cba_Ntk_t * Cba_NtkHostNtk( Cba_Ntk_t * p ) { return p->iBoxNtk >= 0 ? Cba_ManNtk(p->pDesign, p->iBoxNtk) : NULL; }
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_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 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 ) { assert(p->iBoxNtk == -1); 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_NtkStartNames( Cba_Ntk_t * p ) { assert(Cba_NtkAllocNum(p)); Vec_IntFill(&p->vName, Cba_NtkAllocNum(p), 0); }
static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( Cba_NtkCopies(p), p->iObjStart + i, x ); } static inline void Cba_NtkStartRanges( Cba_Ntk_t * p ) { assert(Cba_NtkAllocNum(p)); Vec_IntFill(&p->vRange, Cba_NtkAllocNum(p), 0); }
static inline void Cba_NtkStartCopies( Cba_Ntk_t * p ) { assert(Cba_NtkAllocNum(p)); Vec_IntFill(&p->vCopy, Cba_NtkAllocNum(p), -1); }
static inline void Cba_NtkFreeNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vName); }
static inline void Cba_NtkFreeRanges( Cba_Ntk_t * p ) { Vec_IntErase(&p->vRange); }
static inline void Cba_NtkFreeCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vCopy); }
static inline int Cba_NtkHasNames( Cba_Ntk_t * p ) { return p->vName.pArray != NULL; }
static inline int Cba_NtkHasRanges( Cba_Ntk_t * p ) { return p->vRange.pArray != NULL; }
static inline int Cba_NtkHasCopies( Cba_Ntk_t * p ) { return p->vCopy.pArray != NULL; }
static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { return (Cba_ObjType_t)Vec_IntEntry(&p->vTypes, i); } static inline int Cba_TypeIsBox( Cba_ObjType_t Type ) { return Type >= CBA_OBJ_BOX && Type < CBA_BOX_UNKNOWN; }
static inline int Cba_ObjFuncId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vFuncs, i); }
static inline int Cba_ObjFaninId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vFanins, i); }
static inline int Cba_ObjInstId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInstIds, i); }
static inline int Cba_ObjNameId( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vNameIds, i); }
static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { return (Cba_ObjType_t)Vec_StrEntry(&p->vType, i); }
static inline int Cba_ObjIsPi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PI; } 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_ObjIsPo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PO; }
static inline int Cba_ObjIsPio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsPo(p, i); }
static inline int Cba_ObjIsBi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BI; } 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_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_ObjIsBio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsBi(p, i) || Cba_ObjIsBo(p, i); }
static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; } static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_TypeIsBox(Cba_ObjType(p, i)); }
static inline int Cba_ObjIsConcat( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_CONCAT; } static inline int Cba_ObjIsBoxUser( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; }
static inline int Cba_ObjIsBoxPrim( Cba_Ntk_t * p, int i ) { return Cba_ObjIsBox(p, i) && !Cba_ObjIsBoxUser(p, i); }
static inline int Cba_ObjIsGate( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_GATE; }
static inline int Cba_ObjIsCi( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsBo(p, i); } 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_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_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_ObjFaninId(p, i); } static inline int Cba_ObjIndex( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vIndex, 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_ObjFanin( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanin, i); }
static inline int Cba_ObjFaninNum( Cba_Ntk_t * p, int i ) { return *Cba_ObjFaninArray(p, i); } static inline int Cba_ObjFaninTwo( Cba_Ntk_t * p, int i ) { return Cba_ObjFanin(p, Cba_ObjFanin(p, i)); }
static inline int * Cba_ObjFanins( Cba_Ntk_t * p, int i ) { return Cba_ObjFaninArray(p, i) + 1; } static inline int Cba_ObjName( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vName, i); }
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 int Cba_ObjRange( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vRange, i); }
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 int Cba_ObjCopy( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCopy, i); }
static inline Cba_NodeType_t Cba_ObjNodeType( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsNode(p, i)); return (Cba_NodeType_t)Cba_ObjFuncId(p, i); } static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjName(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 char * Cba_ObjRangeStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjRange(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 void Cba_ObjSetFanin( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjFanin(p, i) == -1); Vec_IntWriteEntry( &p->vFanin, i, x ); }
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 void Cba_ObjSetName( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjName(p, i) == 0); Vec_IntWriteEntry( &p->vName, i, x ); }
static inline void Cba_ObjSetRange( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjRange(p, i) == 0); Vec_IntWriteEntry( &p->vRange, i, x ); }
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 void Cba_ObjSetCopy( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjCopy(p, i) == -1); Vec_IntWriteEntry( &p->vCopy, i, x ); }
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_BoxBiNum( Cba_Ntk_t * p, int i ) { int s = i-1; assert(Cba_ObjIsBox(p, i)); while (i < Cba_NtkObjNum(p) && Cba_ObjIsBi(p, --i)); return s - i; }
static inline int Cba_ObjBoxBo( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b + 1 + i; } static inline int Cba_BoxBoNum( Cba_Ntk_t * p, int i ) { int s = i+1; assert(Cba_ObjIsBox(p, i)); while (i < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, ++i)); return i - s; }
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_BoxSize( Cba_Ntk_t * p, int i ) { return 1 + Cba_BoxBiNum(p, i) + Cba_BoxBoNum(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 int Cba_BoxBi( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b - 1 - 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 int Cba_BoxBo( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b + 1 + 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_BoxBiBox( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBi(p, i)); return i + 1 + Cba_ObjIndex(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 int Cba_BoxBoBox( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBo(p, i)); return i - 1 - Cba_ObjIndex(p, i); }
static inline int Cba_BoxFanin( Cba_Ntk_t * p, int b, int i ) { return Cba_ObjFanin(p, Cba_BoxBi(p, b, 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 int Cba_BoxNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Cba_ObjIndex(p, i); }
static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { return Cba_NtkStr(p, Cba_ObjNameId(p, i)); } static inline void Cba_BoxSetNtkId( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ManNtkIsOk(p->pDesign, x));Vec_IntWriteEntry(&p->vIndex, i, x); }
static inline int Cba_BoxBiNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBi(p, i)); return Cba_BoxNtkId(p, Cba_BoxBiBox(p, i)); }
static inline int Cba_BoxBoNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBo(p, i)); return Cba_BoxNtkId(p, Cba_BoxBoBox(p, i)); }
static inline Cba_Ntk_t * Cba_BoxNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxNtkId(p, i) ); }
static inline Cba_Ntk_t * Cba_BoxBiNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxBiNtkId(p, i) ); }
static inline Cba_Ntk_t * Cba_BoxBoNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxBoNtkId(p, i) ); }
static inline char * Cba_BoxNtkName( Cba_Ntk_t * p, int i ) { return Abc_NamStr( p->pDesign->pMods, Cba_BoxNtkId(p, i) ); }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
...@@ -262,7 +272,7 @@ static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { r ...@@ -262,7 +272,7 @@ static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { r
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
#define Cba_ManForEachNtk( p, pNtk, i ) \ #define Cba_ManForEachNtk( p, pNtk, i ) \
for ( i = 1; (i <= Cba_ManNtkNum(p)) && (((pNtk) = Cba_ManNtk(p, i)), 1); i++ ) for ( i = 0; (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++ ) for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Vec_IntEntry(&p->vInputs, i)), 1); i++ )
...@@ -273,273 +283,480 @@ static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { r ...@@ -273,273 +283,480 @@ static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { r
for ( i = 0; (i < Cba_NtkObjNum(p)) && (((Type) = Cba_ObjType(p, i)), 1); i++ ) for ( i = 0; (i < Cba_NtkObjNum(p)) && (((Type) = Cba_ObjType(p, i)), 1); i++ )
#define Cba_NtkForEachBox( p, i ) \ #define Cba_NtkForEachBox( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( Cba_ObjType(p, i) != CBA_OBJ_BOX ) {} else for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBox(p, i) ) {} else
#define Cba_NtkForEachNode( p, i ) \ #define Cba_NtkForEachBoxUser( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( Cba_ObjType(p, i) != CBA_OBJ_NODE ) {} else for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBoxUser(p, i) ) {} else
#define Cba_NtkForEachBoxPrim( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBoxPrim(p, i) ) {} else
#define Cba_NtkForEachCi( p, i ) \ #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 for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCi(p, i) ) {} else
#define Cba_NtkForEachCo( p, i ) \ #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 for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCo(p, i) ) {} else
#define Cba_NtkForEachCio( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCio(p, i) ){} else
#define Cba_NtkForEachBi( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBi(p, i) ){} else
#define Cba_NtkForEachBo( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBo(p, i) ){} else
#define Cba_NtkForEachBio( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBio(p, i) ){} else
#define Cba_BoxForEachBi( p, iBox, iTerm, i ) \ #define Cba_BoxForEachBi( p, iBox, iTerm, i ) \
for ( iTerm = iBox - Cba_ObjBoxBiNum(p, iBox), i = 0; iTerm < iBox; iTerm++, i++ ) for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Cba_ObjIsBi(p, iTerm); iTerm--, i++ )
#define Cba_BoxForEachBo( p, iBox, iTerm, i ) \ #define Cba_BoxForEachBo( p, iBox, iTerm, i ) \
for ( iTerm = iBox + 1, i = 0; iTerm < iBox + 1 + Cba_ObjBoxBoNum(p, iBox); iTerm++, i++ ) for ( iTerm = iBox + 1, i = 0; iTerm < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, iTerm); iTerm++, i++ )
#define Cba_BoxForEachBiReverse( p, iBox, iTerm, i ) \
for ( i = Cba_BoxBiNum(p, iBox), iTerm = iBox - i--; Cba_ObjIsBi(p, iTerm); iTerm++, i-- )
#define Cba_BoxForEachFanin( p, iBox, iFanin, i ) \
for ( i = 0; iBox - 1 - i >= 0 && Cba_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Cba_BoxFanin(p, iBox, i)), 1); i++ )
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// FUNCTION DECLARATIONS /// /// FUNCTION DECLARATIONS ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// copy contents to the vector /**Function*************************************************************
static inline int Cba_ManHandleArray( Cba_Man_t * p, Vec_Int_t * vFrom )
Synopsis [Object APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Cba_ObjAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int Index, int Fanin )
{ {
int h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * (Vec_IntSize(vFrom) + 1) ); int iObj = Cba_NtkObjNum(p);
int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h ); assert( iObj == Vec_IntSize(&p->vIndex) );
pArray[0] = Vec_IntSize(vFrom); assert( iObj == Vec_IntSize(&p->vFanin) );
memcpy( pArray+1, Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) ); if ( Type == CBA_OBJ_PI )
Vec_IntClear( vFrom ); {
return h; assert( Index == -1 || Index == Vec_IntSize(&p->vInputs) );
Vec_IntPush( &p->vIndex, Vec_IntSize(&p->vInputs) );
Vec_IntPush( &p->vInputs, iObj );
}
else if ( Type == CBA_OBJ_PO )
{
assert( Index == -1 || Index == Vec_IntSize(&p->vOutputs) );
Vec_IntPush( &p->vIndex, Vec_IntSize(&p->vOutputs) );
Vec_IntPush( &p->vOutputs, iObj );
}
else
{
assert( Type >= CBA_OBJ_BOX || Index >= 0 );
Vec_IntPush( &p->vIndex, Index );
}
Vec_StrPush( &p->vType, (char)Type );
Vec_IntPush( &p->vFanin, Fanin );
return iObj;
} }
static inline int Cba_ManHandleBuffer( Cba_Man_t * p, int iFanin ) static inline int Cba_ObjDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int i )
{ {
int h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * 2 ); int iObj = Cba_ObjAlloc( pNew, Cba_ObjType(p, i), Cba_ObjIndex(p, i), -1 );
int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h ); if ( Cba_ObjIsBox(p, i) && Cba_BoxNtk(p, i) )
pArray[0] = (iFanin >= 0) ? 1 : 0; Cba_BoxSetNtkId( pNew, iObj, Cba_NtkCopy(Cba_BoxNtk(p, i)) );
pArray[1] = iFanin; if ( Cba_NtkHasNames(p) && Cba_NtkHasNames(pNew) )
return h; Cba_ObjSetName( pNew, iObj, Cba_ObjName(p, i) );
if ( Cba_NtkHasRanges(p) && Cba_NtkHasRanges(pNew) )
Cba_ObjSetRange( pNew, iObj, Cba_ObjRange(p, i) );
Cba_ObjSetCopy( p, i, iObj );
return iObj;
} }
static inline void Cba_ManAllocArray( Cba_Man_t * p, Vec_Int_t * vTo, int nSize ) static inline int Cba_BoxAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int nIns, int nOuts, int iNtk )
{ {
if ( nSize == 0 ) int i, iObj;
return; for ( i = nIns - 1; i >= 0; i-- )
vTo->nSize = 0; Cba_ObjAlloc( p, CBA_OBJ_BI, i, -1 );
vTo->nCap = nSize; iObj = Cba_ObjAlloc( p, Type, iNtk, -1 );
vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p), sizeof(int) * nSize ); for ( i = 0; i < nOuts; i++ )
Cba_ObjAlloc( p, CBA_OBJ_BO, i, iObj );
return iObj;
} }
static inline void Cba_ManFetchArray( Cba_Man_t * p, Vec_Int_t * vTo, int nSize ) static inline int Cba_BoxDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int iBox )
{ {
if ( nSize == 0 ) int i, iTerm, iBoxNew;
return; Cba_BoxForEachBiReverse( p, iBox, iTerm, i )
vTo->nSize = vTo->nCap = nSize; Cba_ObjDup( pNew, p, iTerm );
vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p), sizeof(int) * nSize ); iBoxNew = Cba_ObjDup( pNew, p, iBox );
memset( Vec_IntArray(vTo), 0xff, sizeof(int) * nSize ); Cba_BoxForEachBo( p, iBox, iTerm, i )
Cba_ObjDup( pNew, p, iTerm );
return iBoxNew;
} }
static inline void Cba_ManSetupArray( Cba_Man_t * p, Vec_Int_t * vTo, Vec_Int_t * vFrom )
/**Function*************************************************************
Synopsis [Network APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Cba_NtkAlloc( Cba_Ntk_t * pNew, int NameId, int nIns, int nOuts, int nObjs )
{ {
if ( Vec_IntSize(vFrom) == 0 ) int NtkId, fFound;
return; assert( pNew->pDesign != NULL );
vTo->nSize = vTo->nCap = Vec_IntSize(vFrom); assert( Cba_NtkPiNum(pNew) == 0 );
vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p), sizeof(int) * Vec_IntSize(vFrom) ); assert( Cba_NtkPoNum(pNew) == 0 );
memcpy( Vec_IntArray(vTo), Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) ); pNew->NameId = NameId;
Vec_IntClear( vFrom ); pNew->iCopy = -1;
pNew->iBoxNtk = -1;
pNew->iBoxObj = -1;
Vec_IntGrow( &pNew->vInputs, nIns );
Vec_IntGrow( &pNew->vOutputs, nOuts );
Vec_StrGrow( &pNew->vType, nObjs );
Vec_IntGrow( &pNew->vIndex, nObjs );
Vec_IntGrow( &pNew->vFanin, nObjs );
// check if the network is unique
NtkId = Abc_NamStrFindOrAdd( pNew->pDesign->pMods, Cba_NtkStr(pNew, NameId), &fFound );
if ( fFound )
printf( "Network with name %s already exists.\n", Cba_NtkStr(pNew, NameId) );
else
assert( NtkId == Cba_NtkId(pNew) + 1 );
} }
static inline void Cba_NtkDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
// constructors desctructors
static inline int Cba_ObjAdd( Cba_Ntk_t * p, int i, Cba_ObjType_t Type, int Func, int Fanin, int NameId )
{ {
if ( Type == CBA_OBJ_PI ) int i, iObj;
Vec_IntWriteEntry( &p->vInputs, Func, i ); assert( pNew != p );
if ( Type == CBA_OBJ_PO ) Cba_NtkAlloc( pNew, Cba_NtkNameId(p), Cba_NtkPiNum(p), Cba_NtkPoNum(p), Cba_NtkObjNum(p) );
Vec_IntWriteEntry( &p->vOutputs, Func, i ); Cba_NtkStartCopies( p );
if ( Type >= 0 ) if ( Cba_NtkHasNames(p) )
Vec_IntWriteEntry( &p->vTypes, i, Type ); Cba_NtkStartNames( pNew );
if ( Func >= 0 ) Cba_NtkForEachPi( p, iObj, i )
Vec_IntWriteEntry( &p->vFuncs, i, Func ); Cba_ObjDup( pNew, p, iObj );
if ( Fanin >= 0 ) Cba_NtkForEachBox( p, iObj )
Vec_IntWriteEntry( &p->vFanins, i, Fanin ); Cba_BoxDup( pNew, p, iObj );
if ( NameId >= 0 ) Cba_NtkForEachPo( p, iObj, i )
Vec_IntWriteEntry( &p->vNameIds, i, NameId ); Cba_ObjDup( pNew, p, iObj );
return i; Cba_NtkForEachCo( p, iObj )
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iObj), Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
//Cba_NtkFreeCopies( p );
assert( Cba_NtkObjNum(pNew) == Cba_NtkAllocNum(pNew) );
} }
static inline int Cba_BoxAdd( Cba_Ntk_t * p, Cba_Ntk_t * pBox, int NameId ) static inline void Cba_NtkDupUserBoxes( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
{ {
int i, ObjId; int i, iObj;
for ( i = 0; i < Cba_NtkPiNum(pBox); i++ ) assert( pNew != p );
Cba_ObjAdd( p, p->nObjs++, CBA_OBJ_BI, i, -1, -1 ); Cba_NtkAlloc( pNew, Cba_NtkNameId(p), Cba_NtkPiNum(p), Cba_NtkPoNum(p), Cba_NtkObjNum(p) );
ObjId = Cba_ObjAdd( p, p->nObjs++, CBA_OBJ_BOX, Cba_NtkId(pBox), -1, NameId ); Cba_NtkStartCopies( p );
for ( i = 0; i < Cba_NtkPoNum(pBox); i++ ) if ( Cba_NtkHasNames(p) )
Cba_ObjAdd( p, p->nObjs++, CBA_OBJ_BO, i, ObjId, -1 ); Cba_NtkStartNames( pNew );
Cba_NtkSetHost( pBox, Cba_NtkId(p), ObjId ); Cba_NtkForEachPi( p, iObj, i )
return ObjId; Cba_ObjDup( pNew, p, iObj );
Cba_NtkForEachPo( p, iObj, i )
Cba_ObjDup( pNew, p, iObj );
Cba_NtkForEachBoxUser( p, iObj )
Cba_BoxDup( pNew, p, iObj );
} }
static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName ) static inline void Cba_NtkFree( Cba_Ntk_t * p )
{ {
int iModelId = Abc_NamStrFindOrAdd( p->pModels, pName, NULL ); Vec_IntErase( &p->vInputs );
Cba_Ntk_t * pNtk = (Cba_Ntk_t *)Vec_SetFetch( Cba_ManMem(p), sizeof(Cba_Ntk_t) ); Vec_IntErase( &p->vOutputs );
memset( pNtk, 0, sizeof(Cba_Ntk_t) ); Vec_StrErase( &p->vType );
pNtk->pDesign = p; Vec_IntErase( &p->vIndex );
pNtk->Id = Vec_PtrSize(&p->vNtks); Vec_IntErase( &p->vFanin );
Vec_PtrPush( &p->vNtks, pNtk ); Vec_IntErase( &p->vName );
assert( iModelId <= pNtk->Id ); Vec_IntErase( &p->vRange );
if ( iModelId < pNtk->Id ) Vec_IntErase( &p->vCopy );
printf( "Model with name %s already exists.\n", pName ); Vec_IntErase( &p->vArray );
return pNtk;
} }
static inline void Cba_NtkResize( Cba_Ntk_t * p, int nObjs ) static inline int Cba_NtkMemory( Cba_Ntk_t * p )
{ {
assert( Vec_IntSize(&p->vTypes) == 0 ); int nMem = sizeof(Cba_Ntk_t);
Cba_ManFetchArray( p->pDesign, &p->vTypes, nObjs ); nMem += Vec_IntMemory(&p->vInputs);
Cba_ManFetchArray( p->pDesign, &p->vFuncs, nObjs ); nMem += Vec_IntMemory(&p->vOutputs);
Cba_ManFetchArray( p->pDesign, &p->vFanins, nObjs ); nMem += Vec_StrMemory(&p->vType);
Cba_ManFetchArray( p->pDesign, &p->vNameIds, nObjs ); nMem += Vec_IntMemory(&p->vIndex);
nMem += Vec_IntMemory(&p->vFanin);
nMem += Vec_IntMemory(&p->vName);
nMem += Vec_IntMemory(&p->vRange);
nMem += Vec_IntMemory(&p->vCopy);
return nMem;
} }
static inline Cba_Man_t * Cba_ManAlloc( Cba_Man_t * pOld, char * pFileName ) static inline void Cba_NtkPrintStats( Cba_Ntk_t * p )
{ {
Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 ); printf( "pi =%5d ", Cba_NtkPiNum(p) );
p->pName = pOld ? Abc_UtilStrsav( Cba_ManName(pOld) ) : Extra_FileDesignName( pFileName ); printf( "pi =%5d ", Cba_NtkPoNum(p) );
p->pSpec = pOld ? Abc_UtilStrsav( Cba_ManSpec(pOld) ) : Abc_UtilStrsav( pFileName ); printf( "box =%6d ", Cba_NtkBoxNum(p) );
p->pNames = pOld ? Abc_NamRef( pOld->pNames ) : Abc_NamStart( 1000, 24 ); printf( "clp =%7d ", p->Count );
p->pModels = pOld ? Abc_NamRef( pOld->pModels ) : Abc_NamStart( 1000, 24 ); printf( "obj =%7d ", Cba_NtkObjNum(p) );
p->pFuncs = pOld ? Abc_NamRef( pOld->pFuncs ) : Abc_NamStart( 1000, 24 ); printf( "%s ", Cba_NtkName(p) );
p->iRoot = 1; if ( Cba_NtkHostNtk(p) )
Vec_SetAlloc_( &p->Mem, 18 ); printf( "-> %s", Cba_NtkName(Cba_NtkHostNtk(p)) );
Vec_PtrPush( &p->vNtks, NULL ); printf( "\n" );
return p;
} }
static inline Cba_Man_t * Cba_ManClone( Cba_Man_t * pOld )
/**Function*************************************************************
Synopsis [Manager APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline Cba_Man_t * Cba_ManAlloc( char * pFileName, int nNtks )
{ {
Cba_Ntk_t * pNtk, * pNtkNew; int i; Cba_Ntk_t * pNtk; int i;
Cba_Man_t * p = Cba_ManAlloc( pOld, NULL ); Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
Cba_ManForEachNtk( pOld, pNtk, i ) pNew->pName = Extra_FileDesignName( pFileName );
{ pNew->pSpec = Abc_UtilStrsav( pFileName );
pNtkNew = Cba_NtkAlloc( p, Cba_NtkName(pNtk) ); pNew->pStrs = Abc_NamStart( 1000, 24 );
Cba_ManFetchArray( p, &pNtkNew->vInputs, Cba_NtkPiNum(pNtk) ); pNew->pMods = Abc_NamStart( 1000, 24 );
Cba_ManFetchArray( p, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) ); pNew->iRoot = 0;
} pNew->nNtks = nNtks;
assert( Cba_ManNtkNum(p) == Cba_ManNtkNum(pOld) ); pNew->pNtks = ABC_CALLOC( Cba_Ntk_t, pNew->nNtks );
return p; Cba_ManForEachNtk( pNew, pNtk, i )
pNtk->pDesign = pNew;
return pNew;
}
static inline Cba_Man_t * Cba_ManStart( Cba_Man_t * p, int nNtks )
{
Cba_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
pNew->pName = Abc_UtilStrsav( Cba_ManName(p) );
pNew->pSpec = Abc_UtilStrsav( Cba_ManSpec(p) );
pNew->pStrs = Abc_NamRef( p->pStrs );
pNew->pMods = Abc_NamStart( 1000, 24 );
pNew->iRoot = 0;
pNew->nNtks = nNtks;
pNew->pNtks = ABC_CALLOC( Cba_Ntk_t, nNtks );
Cba_ManForEachNtk( pNew, pNtk, i )
pNtk->pDesign = pNew;
return pNew;
}
static inline Cba_Man_t * Cba_ManDup( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = Cba_ManStart( p, Cba_ManNtkNum(p) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkSetCopy( pNtk, i );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDup( Cba_ManNtk(pNew, i), pNtk );
return pNew;
} }
static inline Cba_Man_t * Cba_ManDupUserBoxes( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = Cba_ManStart( p, Cba_ManNtkNum(p) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkSetCopy( pNtk, i );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDupUserBoxes( Cba_ManNtk(pNew, i), pNtk );
return pNew;
}
static inline void Cba_ManFree( Cba_Man_t * p ) static inline void Cba_ManFree( Cba_Man_t * p )
{ {
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkFree( pNtk );
Vec_IntFreeP( &p->vBuf2LeafNtk ); Vec_IntFreeP( &p->vBuf2LeafNtk );
Vec_IntFreeP( &p->vBuf2LeafObj ); Vec_IntFreeP( &p->vBuf2LeafObj );
Vec_IntFreeP( &p->vBuf2RootNtk ); Vec_IntFreeP( &p->vBuf2RootNtk );
Vec_IntFreeP( &p->vBuf2RootObj ); Vec_IntFreeP( &p->vBuf2RootObj );
ABC_FREE( p->vCopies.pArray ); Abc_NamDeref( p->pStrs );
ABC_FREE( p->vNtks.pArray ); Abc_NamDeref( p->pMods );
Vec_SetFree_( &p->Mem );
Abc_NamDeref( p->pNames );
Abc_NamDeref( p->pModels );
Abc_NamDeref( p->pFuncs );
ABC_FREE( p->pName ); ABC_FREE( p->pName );
ABC_FREE( p->pSpec ); ABC_FREE( p->pSpec );
ABC_FREE( p->pNtks );
ABC_FREE( p ); ABC_FREE( p );
} }
static inline int Cba_ManMemory( Cba_Man_t * p ) static inline int Cba_ManMemory( Cba_Man_t * p )
{ {
Cba_Ntk_t * pNtk; int i;
int nMem = sizeof(Cba_Man_t); int nMem = sizeof(Cba_Man_t);
nMem += Abc_NamMemUsed(p->pNames); if ( p->pName )
nMem += Abc_NamMemUsed(p->pModels); nMem += (int)strlen(p->pName);
nMem += Abc_NamMemUsed(p->pFuncs); if ( p->pSpec )
nMem += Vec_SetMemoryAll(&p->Mem); nMem += (int)strlen(p->pSpec);
nMem += (int)Vec_PtrMemory(&p->vNtks); nMem += Abc_NamMemUsed(p->pStrs);
nMem += Abc_NamMemUsed(p->pMods);
Cba_ManForEachNtk( p, pNtk, i )
nMem += Cba_NtkMemory( pNtk );
return nMem; return nMem;
} }
static inline int Cba_ManObjNum( Cba_Man_t * p )
static inline void Cba_NtkPrintStats( Cba_Ntk_t * p )
{ {
printf( "%-32s ", Cba_NtkName(p) ); Cba_Ntk_t * pNtk; int i, Count = 0;
printf( "pi =%5d ", Cba_NtkPiNum(p) ); Cba_ManForEachNtk( p, pNtk, i )
printf( "pi =%5d ", Cba_NtkPoNum(p) ); Count += Cba_NtkObjNum(pNtk);
printf( "box =%6d ", Cba_NtkBoxNum(p) ); return Count;
printf( "node =%6d ", Cba_NtkNodeNum(p) ); }
printf( "obj =%6d ", Cba_NtkObjNum(p) ); static inline int Cba_ManNodeNum( Cba_Man_t * p )
printf( "\n" ); {
Cba_Ntk_t * pNtk; int i, Count = 0;
Cba_ManForEachNtk( p, pNtk, i )
Count += Cba_NtkBoxNum( pNtk );
return Count;
}
static inline int Cba_ManBoxNum_rec( Cba_Ntk_t * p )
{
int iObj, Counter = 0;
if ( p->Count >= 0 )
return p->Count;
Cba_NtkForEachBox( p, iObj )
Counter += Cba_ObjIsBoxUser(p, iObj) ? Cba_ManBoxNum_rec( Cba_BoxNtk(p, iObj) ) : 1;
return (p->Count = Counter);
}
static inline int Cba_ManBoxNum( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
pNtk->Count = -1;
return Cba_ManBoxNum_rec( Cba_ManRoot(p) );
} }
static inline void Cba_ManPrintStats( Cba_Man_t * p, int fVerbose ) static inline void Cba_ManPrintStats( Cba_Man_t * p, int fVerbose )
{ {
Cba_Ntk_t * pNtk; int i; Cba_Ntk_t * pNtk; int i;
Cba_Ntk_t * pRoot = Cba_ManRoot( p );
printf( "%-12s : ", Cba_ManName(p) );
printf( "pi =%5d ", Cba_NtkPiNum(pRoot) );
printf( "pi =%5d ", Cba_NtkPoNum(pRoot) );
printf( "mod =%6d ", Cba_ManNtkNum(p) );
printf( "box =%7d ", Cba_ManNodeNum(p) );
printf( "obj =%7d ", Cba_ManObjNum(p) );
printf( "mem =%6.3f MB", 1.0*Cba_ManMemory(p)/(1<<20) );
printf( "\n" );
Cba_ManBoxNum( p );
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
{ {
printf( "Module %4d : ", i ); printf( "Module %5d : ", i );
Cba_NtkPrintStats( pNtk ); Cba_NtkPrintStats( pNtk );
} }
} }
static inline Cba_NodeType_t Ptr_SopToType( char * pSop )
/**Function*************************************************************
Synopsis [Other APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline Cba_ObjType_t Ptr_SopToType( char * pSop )
{ {
if ( !strcmp(pSop, " 1\n") ) return CBA_NODE_C0; if ( !strcmp(pSop, " 0\n") ) return CBA_BOX_C0;
if ( !strcmp(pSop, " 0\n") ) return CBA_NODE_C1; if ( !strcmp(pSop, " 1\n") ) return CBA_BOX_C1;
if ( !strcmp(pSop, "1 1\n") ) return CBA_NODE_BUF; if ( !strcmp(pSop, "1 1\n") ) return CBA_BOX_BUF;
if ( !strcmp(pSop, "0 1\n") ) return CBA_NODE_INV; if ( !strcmp(pSop, "0 1\n") ) return CBA_BOX_INV;
if ( !strcmp(pSop, "11 1\n") ) return CBA_NODE_AND; if ( !strcmp(pSop, "11 1\n") ) return CBA_BOX_AND;
if ( !strcmp(pSop, "00 1\n") ) return CBA_NODE_NOR; if ( !strcmp(pSop, "00 1\n") ) return CBA_BOX_NOR;
if ( !strcmp(pSop, "00 0\n") ) return CBA_NODE_OR; if ( !strcmp(pSop, "00 0\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_NODE_OR; if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_NODE_OR; if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_NODE_XOR; if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_NODE_XOR; if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_NODE_XNOR; if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_NODE_XNOR; if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "10 1\n") ) return CBA_NODE_SHARP; if ( !strcmp(pSop, "10 1\n") ) return CBA_BOX_SHARP;
assert( 0 ); assert( 0 );
return CBA_NODE_NONE; return CBA_OBJ_NONE;
} }
static inline char * Ptr_TypeToName( Cba_NodeType_t Type ) static inline char * Ptr_SopToTypeName( char * pSop )
{ {
if ( Type == CBA_NODE_C0 ) return "const0"; if ( !strcmp(pSop, " 0\n") ) return "CBA_BOX_C0";
if ( Type == CBA_NODE_C1 ) return "const1"; if ( !strcmp(pSop, " 1\n") ) return "CBA_BOX_C1";
if ( Type == CBA_NODE_BUF ) return "buf"; if ( !strcmp(pSop, "1 1\n") ) return "CBA_BOX_BUF";
if ( Type == CBA_NODE_INV ) return "not"; if ( !strcmp(pSop, "0 1\n") ) return "CBA_BOX_INV";
if ( Type == CBA_NODE_AND ) return "and"; if ( !strcmp(pSop, "11 1\n") ) return "CBA_BOX_AND";
if ( Type == CBA_NODE_NAND ) return "nand"; if ( !strcmp(pSop, "00 1\n") ) return "CBA_BOX_NOR";
if ( Type == CBA_NODE_OR ) return "or"; if ( !strcmp(pSop, "00 0\n") ) return "CBA_BOX_OR";
if ( Type == CBA_NODE_NOR ) return "nor"; if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "CBA_BOX_OR";
if ( Type == CBA_NODE_XOR ) return "xor"; if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "CBA_BOX_OR";
if ( Type == CBA_NODE_XNOR ) return "xnor"; if ( !strcmp(pSop, "01 1\n10 1\n") ) return "CBA_BOX_XOR";
if ( Type == CBA_NODE_MUX ) return "mux"; if ( !strcmp(pSop, "10 1\n01 1\n") ) return "CBA_BOX_XOR";
if ( Type == CBA_NODE_MAJ ) return "maj"; if ( !strcmp(pSop, "11 1\n00 1\n") ) return "CBA_BOX_XNOR";
if ( Type == CBA_NODE_SHARP ) return "sharp"; if ( !strcmp(pSop, "00 1\n11 1\n") ) return "CBA_BOX_XNOR";
if ( !strcmp(pSop, "10 1\n") ) return "CBA_BOX_SHARP";
assert( 0 );
return NULL;
}
static inline char * Ptr_TypeToName( Cba_ObjType_t Type )
{
if ( Type == CBA_BOX_C0 ) return "const0";
if ( Type == CBA_BOX_C1 ) return "const1";
if ( Type == CBA_BOX_BUF ) return "buf";
if ( Type == CBA_BOX_INV ) return "not";
if ( Type == CBA_BOX_AND ) return "and";
if ( Type == CBA_BOX_NAND ) return "nand";
if ( Type == CBA_BOX_OR ) return "or";
if ( Type == CBA_BOX_NOR ) return "nor";
if ( Type == CBA_BOX_XOR ) return "xor";
if ( Type == CBA_BOX_XNOR ) return "xnor";
if ( Type == CBA_BOX_MUX ) return "mux";
if ( Type == CBA_BOX_MAJ ) return "maj";
if ( Type == CBA_BOX_SHARP ) return "sharp";
assert( 0 ); assert( 0 );
return "???"; return "???";
} }
static inline char * Ptr_TypeToSop( Cba_NodeType_t Type ) static inline char * Ptr_TypeToSop( Cba_ObjType_t Type )
{ {
if ( Type == CBA_NODE_C0 ) return " 0\n"; if ( Type == CBA_BOX_C0 ) return " 0\n";
if ( Type == CBA_NODE_C1 ) return " 1\n"; if ( Type == CBA_BOX_C1 ) return " 1\n";
if ( Type == CBA_NODE_BUF ) return "1 1\n"; if ( Type == CBA_BOX_BUF ) return "1 1\n";
if ( Type == CBA_NODE_INV ) return "0 1\n"; if ( Type == CBA_BOX_INV ) return "0 1\n";
if ( Type == CBA_NODE_AND ) return "11 1\n"; if ( Type == CBA_BOX_AND ) return "11 1\n";
if ( Type == CBA_NODE_NAND ) return "11 0\n"; if ( Type == CBA_BOX_NAND ) return "11 0\n";
if ( Type == CBA_NODE_OR ) return "00 0\n"; if ( Type == CBA_BOX_OR ) return "00 0\n";
if ( Type == CBA_NODE_NOR ) return "00 1\n"; if ( Type == CBA_BOX_NOR ) return "00 1\n";
if ( Type == CBA_NODE_XOR ) return "01 1\n10 1\n"; if ( Type == CBA_BOX_XOR ) return "01 1\n10 1\n";
if ( Type == CBA_NODE_XNOR ) return "00 1\n11 1\n"; if ( Type == CBA_BOX_XNOR ) return "00 1\n11 1\n";
if ( Type == CBA_NODE_SHARP ) return "10 1\n"; if ( Type == CBA_BOX_SHARP ) return "10 1\n";
if ( Type == CBA_NODE_MUX ) return "11- 1\n0-1 1\n"; if ( Type == CBA_BOX_MUX ) return "11- 1\n0-1 1\n";
if ( Type == CBA_NODE_MAJ ) return "11- 1\n1-1 1\n-11 1\n"; if ( Type == CBA_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n";
assert( 0 ); assert( 0 );
return "???"; return "???";
} }
/*=== cbaCom.c ===============================================================*/
extern void Abc_FrameImportDes( Vec_Ptr_t * vDes );
extern Vec_Ptr_t * Abc_FrameExportDes();
/*=== cbaBlast.c =========================================================*/ /*=== cbaBlast.c =============================================================*/
extern Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ); extern Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose );
extern Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ); extern Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia );
extern void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc ); extern void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc );
/*=== cbaBuild.c =========================================================*/ /*=== cbaNtk.c ===============================================================*/
extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p ); extern void Cba_ManAssignInternNames( Cba_Man_t * p );
/*=== cbaReadBlif.c =========================================================*/ extern Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p );
extern Cba_Man_t * Cba_PrsReadBlif( char * pFileName ); /*=== cbaPtr.c ===============================================================*/
/*=== cbaReadVer.c ==========================================================*/ extern void Cba_PtrFree( Vec_Ptr_t * vDes );
extern Cba_Man_t * Cba_PrsReadVerilog( char * pFileName, int fBinary ); extern int Cba_PtrMemory( Vec_Ptr_t * vDes );
/*=== cbaWriteBlif.c ========================================================*/ extern void Cba_PtrDumpBlif( char * pFileName, Vec_Ptr_t * vDes );
extern void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * p ); extern Vec_Ptr_t * Cba_PtrTransformTest( Vec_Ptr_t * vDes );
/*=== cbaPtrAbc.c ============================================================*/
extern Cba_Man_t * Cba_PtrTransformToCba( Vec_Ptr_t * vDes );
extern Vec_Ptr_t * Cba_PtrDeriveFromCba( Cba_Man_t * p );
/*=== cbaPrsBuild.c ==========================================================*/
extern void Prs_ManVecFree( Vec_Ptr_t * vPrs );
extern Cba_Man_t * Prs_ManBuildCba( char * pFileName, Vec_Ptr_t * vDes );
/*=== cbaReadBlif.c ==========================================================*/
extern Vec_Ptr_t * Prs_ManReadBlif( char * pFileName );
/*=== cbaReadVer.c ===========================================================*/
extern Vec_Ptr_t * Prs_ManReadVerilog( char * pFileName );
/*=== cbaWriteBlif.c =========================================================*/
extern void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
extern void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p ); extern void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p );
/*=== cbaWriteVer.c =========================================================*/ /*=== cbaWriteVer.c ==========================================================*/
extern void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p ); extern void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
extern void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p ); extern void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p );
/*=== cbaNtk.c =========================================================*/
extern void Cba_ManAssignInternNames( Cba_Man_t * p );
extern int Cba_NtkNodeNum( Cba_Ntk_t * p );
extern int Cba_ManObjNum( Cba_Man_t * p );
extern Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vNtkSizes );
extern Cba_Man_t * Cba_ManDup( Cba_Man_t * p );
/*=== cbaSimple.c =========================================================*/
extern Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes );
extern void Ptr_ManFreeDes( Vec_Ptr_t * vDes );
ABC_NAMESPACE_HEADER_END ABC_NAMESPACE_HEADER_END
......
src/base/cba/cbaBlast.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Bit-blasting of the netlist.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -49,14 +49,13 @@ void Cba_ManPrepareGates( Cba_Man_t * p ) ...@@ -49,14 +49,13 @@ void Cba_ManPrepareGates( Cba_Man_t * p )
Dec_Graph_t ** ppGraphs; int i; Dec_Graph_t ** ppGraphs; int i;
if ( p->pMioLib == NULL ) if ( p->pMioLib == NULL )
return; return;
ppGraphs = ABC_ALLOC( Dec_Graph_t *, Abc_NamObjNumMax(p->pFuncs) ); ppGraphs = ABC_CALLOC( Dec_Graph_t *, Abc_NamObjNumMax(p->pMods) );
ppGraphs[0] = NULL; for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
for ( i = 1; i < Abc_NamObjNumMax(p->pFuncs); i++ )
{ {
char * pGateName = Abc_NamStr( p->pFuncs, i ); char * pGateName = Abc_NamStr( p->pMods, i );
Mio_Gate_t * pGate = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pMioLib, pGateName, NULL ); Mio_Gate_t * pGate = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pMioLib, pGateName, NULL );
char * pSop = Mio_GateReadSop( pGate ); if ( pGate != NULL )
ppGraphs[i] = Dec_Factor( pSop ); ppGraphs[i] = Dec_Factor( Mio_GateReadSop(pGate) );
} }
assert( p->ppGraphs == NULL ); assert( p->ppGraphs == NULL );
p->ppGraphs = (void **)ppGraphs; p->ppGraphs = (void **)ppGraphs;
...@@ -66,7 +65,8 @@ void Cba_ManUndoGates( Cba_Man_t * p ) ...@@ -66,7 +65,8 @@ void Cba_ManUndoGates( Cba_Man_t * p )
int i; int i;
if ( p->pMioLib == NULL ) if ( p->pMioLib == NULL )
return; return;
for ( i = 1; i < Abc_NamObjNumMax(p->pFuncs); i++ ) for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
if ( p->ppGraphs[i] )
Dec_GraphFree( (Dec_Graph_t *)p->ppGraphs[i] ); Dec_GraphFree( (Dec_Graph_t *)p->ppGraphs[i] );
ABC_FREE( p->ppGraphs ); ABC_FREE( p->ppGraphs );
} }
...@@ -106,88 +106,96 @@ int Cba_ManAddBarbuf( Gia_Man_t * pNew, int iRes, Cba_Man_t * p, int iLNtk, int ...@@ -106,88 +106,96 @@ int Cba_ManAddBarbuf( Gia_Man_t * pNew, int iRes, Cba_Man_t * p, int iLNtk, int
} }
int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i, int fBuffers, Vec_Int_t * vMap ) int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i, int fBuffers, Vec_Int_t * vMap )
{ {
int iRes = Cba_NtkCopy( p, i ); int iRes = Cba_ObjCopy( p, i );
if ( iRes >= 0 ) if ( iRes >= 0 )
return iRes; return iRes;
if ( Cba_ObjIsCo(p, i) ) if ( Cba_ObjIsCo(p, i) )
iRes = Cba_ManExtract_rec( pNew, p, Cba_ObjFanin0(p, i), fBuffers, vMap ); iRes = Cba_ManExtract_rec( pNew, p, Cba_ObjFanin(p, i), fBuffers, vMap );
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, fBuffers, vMap );
if ( fBuffers )
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj, vMap );
}
else if ( Cba_ObjIsPi(p, i) ) else if ( Cba_ObjIsPi(p, i) )
{ {
Cba_Ntk_t * pHost = Cba_NtkHostNtk( p ); Cba_Ntk_t * pHost = Cba_NtkHostNtk( p );
int iObj = Cba_ObjBoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjCioIndex(p, i) ); int iObj = Cba_BoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pHost, iObj, fBuffers, vMap ); iRes = Cba_ManExtract_rec( pNew, pHost, iObj, fBuffers, vMap );
if ( fBuffers ) if ( fBuffers )
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj, vMap ); iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj, vMap );
} }
else if ( Cba_ObjIsNode(p, i) && p->pDesign->ppGraphs ) else if ( Cba_ObjIsBo(p, i) )
{
int iBox = Cba_BoxBoBox(p, i);
if ( Cba_ObjIsBoxUser(p, iBox) ) // user box
{
Cba_Ntk_t * pBox = Cba_BoxBoNtk( p, i );
int iObj = Cba_NtkPo( pBox, Cba_ObjIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pBox, iObj, fBuffers, vMap );
if ( fBuffers )
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj, vMap );
}
else // primitive
{
int iFanin, nLits, pLits[16];
assert( Cba_ObjIsBoxPrim(p, iBox) );
Cba_BoxForEachFanin( p, iBox, iFanin, nLits )
pLits[nLits] = Cba_ManExtract_rec( pNew, p, iFanin, fBuffers, vMap );
assert( nLits <= 16 );
if ( p->pDesign->ppGraphs ) // mapped gate
{ {
extern int Gia_ManFactorGraph( Gia_Man_t * p, Dec_Graph_t * pFForm, Vec_Int_t * vLeaves ); extern int Gia_ManFactorGraph( Gia_Man_t * p, Dec_Graph_t * pFForm, Vec_Int_t * vLeaves );
Dec_Graph_t * pGraph = (Dec_Graph_t *)p->pDesign->ppGraphs[Cba_ObjFuncId(p, i)]; Dec_Graph_t * pGraph = (Dec_Graph_t *)p->pDesign->ppGraphs[Cba_BoxNtkId(p, iBox)];
int k, pLits[32], * pFanins = Cba_ObjFaninArray(p, i); Vec_Int_t Leaves = { nLits, nLits, pLits };
Vec_Int_t Leaves = { pFanins[0], pFanins[0], pLits }; assert( pGraph != NULL );
assert( pFanins[0] < 32 );
for ( k = 0; k < pFanins[0]; k++ )
pLits[k] = Cba_ManExtract_rec( pNew, p, pFanins[k+1], fBuffers, vMap );
return Gia_ManFactorGraph( pNew, pGraph, &Leaves ); return Gia_ManFactorGraph( pNew, pGraph, &Leaves );
} }
else if ( Cba_ObjIsNode(p, i) ) else
{ {
int * pFanins = Cba_ObjFaninArray(p, i); Cba_ObjType_t Type = Cba_ObjType(p, iBox);
int k, pLits[3], Type = Cba_ObjNodeType(p, i); if ( nLits == 0 )
assert( pFanins[0] <= 3 );
if ( pFanins[0] == 0 )
{ {
if ( Type == CBA_NODE_C0 ) if ( Type == CBA_BOX_C0 )
iRes = 0; iRes = 0;
else if ( Type == CBA_NODE_C1 ) else if ( Type == CBA_BOX_C1 )
iRes = 1; iRes = 1;
else assert( 0 ); else assert( 0 );
} }
else if ( pFanins[0] == 1 ) else if ( nLits == 1 )
{ {
if ( Type == CBA_NODE_BUF ) if ( Type == CBA_BOX_BUF )
iRes = Cba_ManExtract_rec( pNew, p, pFanins[1], fBuffers, vMap ); iRes = pLits[0];
else if ( Type == CBA_NODE_INV ) else if ( Type == CBA_BOX_INV )
iRes = Abc_LitNot( Cba_ManExtract_rec( pNew, p, pFanins[1], fBuffers, vMap ) ); iRes = Abc_LitNot( pLits[0] );
else assert( 0 ); else assert( 0 );
} }
else else
{ {
for ( k = 0; k < pFanins[0]; k++ ) assert( nLits == 2 );
pLits[k] = Cba_ManExtract_rec( pNew, p, pFanins[k+1], fBuffers, vMap ); if ( Type == CBA_BOX_AND )
if ( Type == CBA_NODE_AND )
iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] ); iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_NODE_OR ) else if ( Type == CBA_BOX_OR )
iRes = Gia_ManHashOr( pNew, pLits[0], pLits[1] ); iRes = Gia_ManHashOr( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_NODE_NOR ) else if ( Type == CBA_BOX_NOR )
iRes = Abc_LitNot( Gia_ManHashOr( pNew, pLits[0], pLits[1] ) ); iRes = Abc_LitNot( Gia_ManHashOr( pNew, pLits[0], pLits[1] ) );
else if ( Type == CBA_NODE_XOR ) else if ( Type == CBA_BOX_XOR )
iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] ); iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_NODE_XNOR ) else if ( Type == CBA_BOX_XNOR )
iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) ); iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) );
else if ( Type == CBA_NODE_SHARP ) else if ( Type == CBA_BOX_SHARP )
iRes = Gia_ManHashAnd( pNew, pLits[0], Abc_LitNot(pLits[1]) ); iRes = Gia_ManHashAnd( pNew, pLits[0], Abc_LitNot(pLits[1]) );
else assert( 0 ); else assert( 0 );
} }
//printf("%d input\n", nLits );
}
}
} }
else assert( 0 ); else assert( 0 );
Cba_NtkSetCopy( p, i, iRes ); Cba_ObjSetCopy( p, i, iRes );
return iRes; return iRes;
} }
Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ) Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
{ {
Cba_Ntk_t * pRoot = Cba_ManRoot(p); Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot(p);
Gia_Man_t * pNew, * pTemp; Gia_Man_t * pNew, * pTemp;
Vec_Int_t * vMap = NULL; Vec_Int_t * vMap = NULL;
int i, iObj; int i, iObj;
Vec_IntFreeP( &p->vBuf2LeafNtk ); Vec_IntFreeP( &p->vBuf2LeafNtk );
Vec_IntFreeP( &p->vBuf2LeafObj ); Vec_IntFreeP( &p->vBuf2LeafObj );
Vec_IntFreeP( &p->vBuf2RootNtk ); Vec_IntFreeP( &p->vBuf2RootNtk );
...@@ -197,15 +205,17 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ) ...@@ -197,15 +205,17 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
p->vBuf2RootNtk = Vec_IntAlloc( 1000 ); p->vBuf2RootNtk = Vec_IntAlloc( 1000 );
p->vBuf2RootObj = Vec_IntAlloc( 1000 ); p->vBuf2RootObj = Vec_IntAlloc( 1000 );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkStartCopies(pNtk);
// start the manager // start the manager
pNew = Gia_ManStart( Cba_ManObjNum(p) ); pNew = Gia_ManStart( Cba_ManNodeNum(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 );
// primary inputs // primary inputs
Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkForEachPi( pRoot, iObj, i )
Cba_NtkSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) ); Cba_ObjSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) );
// internal nodes // internal nodes
Gia_ManHashAlloc( pNew ); Gia_ManHashAlloc( pNew );
...@@ -220,7 +230,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ) ...@@ -220,7 +230,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
// primary outputs // primary outputs
Cba_NtkForEachPo( pRoot, iObj, i ) Cba_NtkForEachPo( pRoot, iObj, i )
Gia_ManAppendCo( pNew, Cba_NtkCopy(pRoot, iObj) ); Gia_ManAppendCo( pNew, Cba_ObjCopy(pRoot, iObj) );
assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs ); assert( Vec_IntSize(p->vBuf2LeafNtk) == pNew->nBufs );
// cleanup // cleanup
...@@ -232,7 +242,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ) ...@@ -232,7 +242,7 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
/**Function************************************************************* /**Function*************************************************************
Synopsis [Returns the number of objects in each network.] Synopsis [Mark each GIA node with the network it belongs to.]
Description [] Description []
...@@ -241,51 +251,29 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose ) ...@@ -241,51 +251,29 @@ Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
Vec_Int_t * Cba_ManCountGia( Cba_Man_t * p, Gia_Man_t * pGia, int fAlwaysAdd ) void Cba_ManMarkNodesGia( Cba_Man_t * p, Gia_Man_t * pGia )
{ {
Cba_Ntk_t * pNtk; Gia_Obj_t * pObj; int i, Count = 0;
Gia_Obj_t * pObj;
int i, 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) ); 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 = 0;
Gia_ManConst0(pGia)->Value = 1;
Gia_ManForEachPi( pGia, pObj, i ) Gia_ManForEachPi( pGia, pObj, i )
pObj->Value = 1; pObj->Value = 0;
Gia_ManForEachAnd( pGia, pObj, i ) Gia_ManForEachAnd( pGia, pObj, i )
{ {
if ( Gia_ObjIsBuf(pObj) ) if ( Gia_ObjIsBuf(pObj) )
{
if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) )
Vec_IntAddToEntry( vDrivenCos, Gia_ObjFanin0(pObj)->Value, 1 );
pObj->Value = Vec_IntEntry( p->vBuf2LeafNtk, Count++ ); pObj->Value = Vec_IntEntry( p->vBuf2LeafNtk, Count++ );
}
else else
{ {
pObj->Value = Gia_ObjFanin0(pObj)->Value; pObj->Value = Gia_ObjFanin0(pObj)->Value;
assert( pObj->Value == Gia_ObjFanin1(pObj)->Value ); assert( pObj->Value == Gia_ObjFanin1(pObj)->Value );
Vec_IntAddToEntry( vNtkSizes, pObj->Value, 1 );
} }
} }
assert( Count == Gia_ManBufNum(pGia) ); assert( Count == Gia_ManBufNum(pGia) );
Gia_ManForEachPo( pGia, pObj, i ) Gia_ManForEachPo( pGia, pObj, i )
{ {
assert( Gia_ObjFanin0(pObj)->Value == 1 ); assert( Gia_ObjFanin0(pObj)->Value == 0 );
pObj->Value = Gia_ObjFanin0(pObj)->Value; pObj->Value = 0;
if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) )
Vec_IntAddToEntry( vDrivenCos, pObj->Value, 1 );
}
// for each network, count the total number of COs
Cba_ManForEachNtk( p, pNtk, i )
{
Count = Cba_NtkPiNum(pNtk) + 2 * Cba_NtkPoNum(pNtk) - (fAlwaysAdd ? 0 : Vec_IntEntry(vDrivenCos, i));
Cba_NtkForEachBox( pNtk, iBox )
Count += Cba_ObjBoxSize(pNtk, iBox) + Cba_ObjBoxBiNum(pNtk, iBox);
Vec_IntAddToEntry( vNtkSizes, i, Count );
} }
Vec_IntFree( vDrivenCos );
return vNtkSizes;
} }
void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p ) void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p )
{ {
...@@ -299,34 +287,41 @@ void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p ) ...@@ -299,34 +287,41 @@ void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p )
Vec_IntForEachEntry( p->vBuf2LeafObj, Entry, i ) Vec_IntForEachEntry( p->vBuf2LeafObj, Entry, i )
{ {
pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2LeafNtk, i) ); pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2LeafNtk, i) );
Vec_IntWriteEntry( pNew->vBuf2LeafObj, i, Cba_NtkCopy(pNtk, Entry) ); Vec_IntWriteEntry( pNew->vBuf2LeafObj, i, Cba_ObjCopy(pNtk, Entry) );
} }
Vec_IntForEachEntry( p->vBuf2RootObj, Entry, i ) Vec_IntForEachEntry( p->vBuf2RootObj, Entry, i )
{ {
pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, i) ); pNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, i) );
Vec_IntWriteEntry( pNew->vBuf2RootObj, i, Cba_NtkCopy(pNtk, Entry) ); Vec_IntWriteEntry( pNew->vBuf2RootObj, i, Cba_ObjCopy(pNtk, Entry) );
} }
} }
void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * p, int iTerm ) void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * p, int iTerm )
{ {
Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE ); int iObj;
// Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE );
if ( pGia && Gia_ObjFaninId0p(pGia, pObj) > 0 ) if ( pGia && Gia_ObjFaninId0p(pGia, pObj) > 0 )
{ {
Vec_IntWriteEntry( &p->vFuncs, p->nObjs, Gia_ObjFaninC0(pObj) ? CBA_NODE_INV : CBA_NODE_BUF ); // Vec_IntWriteEntry( &p->vFuncs, p->nObjs, Gia_ObjFaninC0(pObj) ? CBA_BOX_INV : CBA_BOX_BUF );
Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, Gia_ObjFanin0(pObj)->Value) ); // Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, Gia_ObjFanin0(pObj)->Value) );
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, 0, Gia_ObjFanin0(pObj)->Value );
Cba_ObjSetName( p, iObj, Cba_ObjName(p, Gia_ObjFanin0(pObj)->Value) );
Cba_ObjAlloc( p, Gia_ObjFaninC0(pObj) ? CBA_BOX_INV : CBA_BOX_BUF, -1, -1 );
} }
else else
{ {
Vec_IntWriteEntry( &p->vFuncs, p->nObjs, pGia && Gia_ObjFaninC0(pObj) ? CBA_NODE_C1 : CBA_NODE_C0 ); // Vec_IntWriteEntry( &p->vFuncs, p->nObjs, pGia && Gia_ObjFaninC0(pObj) ? CBA_BOX_C1 : CBA_BOX_C0 );
Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, -1) ); // Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, -1) );
Cba_ObjAlloc( p, pGia && Gia_ObjFaninC0(pObj) ? CBA_BOX_C1 : CBA_BOX_C0, -1, -1 );
} }
Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) ); // Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) );
Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ ); // Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ );
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, 0, -1 );
Cba_ObjSetName( p, iObj, Cba_ObjName(p, iTerm) );
Cba_ObjSetFanin( p, iTerm, iObj );
} }
void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ) void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
{ {
Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot( p ); Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot( p );
Vec_Int_t * vTemp = Vec_IntAlloc( 100 );
int i, j, k, iBox, iTerm, Count = 0; int i, j, k, iBox, iTerm, Count = 0;
Gia_Obj_t * pObj; Gia_Obj_t * pObj;
...@@ -348,53 +343,58 @@ void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ) ...@@ -348,53 +343,58 @@ void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
{ {
int iLit0 = Gia_ObjFanin0(pObj)->Value; int iLit0 = Gia_ObjFanin0(pObj)->Value;
int iLit1 = Gia_ObjFanin1(pObj)->Value; int iLit1 = Gia_ObjFanin1(pObj)->Value;
Cba_NodeType_t Type; Cba_ObjType_t Type;
pNtk = Cba_ManNtk( p, pObj->Value ); pNtk = Cba_ManNtk( p, pObj->Value );
if ( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) ) if ( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) )
Type = CBA_NODE_NOR; Type = CBA_BOX_NOR;
else if ( Gia_ObjFaninC1(pObj) ) else if ( Gia_ObjFaninC1(pObj) )
Type = CBA_NODE_SHARP; Type = CBA_BOX_SHARP;
else if ( Gia_ObjFaninC0(pObj) ) else if ( Gia_ObjFaninC0(pObj) )
{ {
Type = CBA_NODE_SHARP; Type = CBA_BOX_SHARP;
ABC_SWAP( int, iLit0, iLit1 ); ABC_SWAP( int, iLit0, iLit1 );
} }
else else
Type = CBA_NODE_AND; Type = CBA_BOX_AND;
// create box
/*
Vec_IntFillTwo( vTemp, 2, iLit0, iLit1 ); Vec_IntFillTwo( vTemp, 2, iLit0, iLit1 );
Vec_IntWriteEntry( &pNtk->vTypes, pNtk->nObjs, CBA_OBJ_NODE ); Vec_IntWriteEntry( &pNtk->vTypes, pNtk->nObjs, CBA_OBJ_NODE );
Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, Type ); Vec_IntWriteEntry( &pNtk->vFuncs, pNtk->nObjs, Type );
Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleArray(p, vTemp) ); Vec_IntWriteEntry( &pNtk->vFanins, pNtk->nObjs, Cba_ManHandleArray(p, vTemp) );
pObj->Value = pNtk->nObjs++; pNtk->nObjs++;
*/
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, 1, iLit1 );
Cba_ObjSetName( pNtk, iTerm, Cba_ObjName(pNtk, iLit1) );
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, 0, iLit0 );
Cba_ObjSetName( pNtk, iTerm, Cba_ObjName(pNtk, iLit0) );
Cba_ObjAlloc( pNtk, Type, -1, -1 );
pObj->Value = Cba_ObjAlloc( pNtk, CBA_OBJ_BO, 0, -1 );
} }
} }
assert( Count == Gia_ManBufNum(pGia) ); assert( Count == Gia_ManBufNum(pGia) );
Vec_IntFree( vTemp );
// create constant 0 drivers for COs without barbufs // create constant 0 drivers for COs without barbufs
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
{ {
Cba_NtkForEachBox( pNtk, iBox ) Cba_NtkForEachBox( pNtk, iBox )
Cba_BoxForEachBi( pNtk, iBox, iTerm, j ) Cba_BoxForEachBi( pNtk, iBox, iTerm, j )
if ( Cba_ObjFanin0(pNtk, iTerm) == -1 ) if ( Cba_ObjFanin(pNtk, iTerm) == -1 )
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm ); Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
Cba_NtkForEachPo( pNtk, iTerm, k ) Cba_NtkForEachPo( pNtk, iTerm, k )
if ( pNtk != pRoot && Cba_ObjFanin0(pNtk, iTerm) == -1 ) if ( pNtk != pRoot && Cba_ObjFanin(pNtk, iTerm) == -1 )
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm ); Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
} }
// create node and connect POs // create node and connect POs
Gia_ManForEachPo( pGia, pObj, i ) Gia_ManForEachPo( pGia, pObj, i )
Cba_NtkCreateAndConnectBuffer( pGia, pObj, pRoot, Cba_NtkPo(pRoot, i) ); Cba_NtkCreateAndConnectBuffer( pGia, pObj, pRoot, Cba_NtkPo(pRoot, i) );
Cba_ManForEachNtk( p, pNtk, i )
assert( Cba_NtkObjNum(pNtk) == pNtk->nObjs );
} }
Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia ) 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_ManDupUserBoxes( p );
Cba_Man_t * pNew = Cba_ManDupStart( p, vNtkSizes ); Cba_ManMarkNodesGia( p, pGia );
Cba_ManRemapBarbufs( pNew, p ); Cba_ManRemapBarbufs( pNew, p );
Cba_NtkInsertGia( pNew, pGia ); Cba_NtkInsertGia( pNew, pGia );
Vec_IntFree( vNtkSizes );
return pNew; return pNew;
} }
...@@ -414,14 +414,12 @@ Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p ) ...@@ -414,14 +414,12 @@ Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p )
Gia_Man_t * pGia = Cba_ManExtract( p, 1, 0 ); Gia_Man_t * pGia = Cba_ManExtract( p, 1, 0 );
Cba_Man_t * pNew = Cba_ManInsertGia( p, pGia ); Cba_Man_t * pNew = Cba_ManInsertGia( p, pGia );
Gia_ManStop( pGia ); Gia_ManStop( pGia );
Cba_ManAssignInternNames( pNew );
return pNew; return pNew;
} }
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis [Mark each GIA node with the network it belongs to.]
Description [] Description []
...@@ -432,79 +430,68 @@ Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p ) ...@@ -432,79 +430,68 @@ Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p )
***********************************************************************/ ***********************************************************************/
static inline int Abc_NodeIsSeriousGate( Abc_Obj_t * p ) static inline int Abc_NodeIsSeriousGate( Abc_Obj_t * p )
{ {
return (Abc_ObjIsNode(p) && (Abc_ObjFaninNum(p) > 0) && !Abc_ObjIsBarBuf(p));// || Abc_ObjIsPi(p); return Abc_ObjIsNode(p) && Abc_ObjFaninNum(p) > 0 && !Abc_ObjIsBarBuf(p);
} }
Vec_Int_t * Cba_ManCountAbc( Cba_Man_t * p, Abc_Ntk_t * pNtk, int fAlwaysAdd ) void Cba_ManMarkNodesAbc( Cba_Man_t * p, Abc_Ntk_t * pNtk )
{ {
Cba_Ntk_t * pCbaNtk; Abc_Obj_t * pObj, * pFanin; int i, k, Count = 0;
Abc_Obj_t * pObj, * pFanin;
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) == pNtk->nBarBufs2 ); assert( Vec_IntSize(p->vBuf2LeafNtk) == pNtk->nBarBufs2 );
// assing for each GIA node, the network it belongs to and count nodes for all networks
Abc_NtkForEachPi( pNtk, pObj, i ) Abc_NtkForEachPi( pNtk, pObj, i )
pObj->iTemp = 1; pObj->iTemp = 0;
Abc_NtkForEachNode( pNtk, pObj, i ) Abc_NtkForEachNode( pNtk, pObj, i )
{ {
if ( Abc_ObjIsBarBuf(pObj) ) if ( Abc_ObjIsBarBuf(pObj) )
{
if ( Abc_NodeIsSeriousGate(Abc_ObjFanin0(pObj)) )
Vec_IntAddToEntry( vDrivenCos, Abc_ObjFanin0(pObj)->iTemp, 1 );
pObj->iTemp = Vec_IntEntry( p->vBuf2LeafNtk, Count++ ); pObj->iTemp = Vec_IntEntry( p->vBuf2LeafNtk, Count++ );
}
else if ( Abc_NodeIsSeriousGate(pObj) ) else if ( Abc_NodeIsSeriousGate(pObj) )
{ {
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp; pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
Abc_ObjForEachFanin( pObj, pFanin, k ) Abc_ObjForEachFanin( pObj, pFanin, k )
assert( pObj->iTemp == pFanin->iTemp ); assert( pObj->iTemp == pFanin->iTemp );
Vec_IntAddToEntry( vNtkSizes, pObj->iTemp, 1 );
} }
} }
assert( Count == pNtk->nBarBufs2 );
Abc_NtkForEachPo( pNtk, pObj, i ) Abc_NtkForEachPo( pNtk, pObj, i )
{ {
if ( !Abc_NodeIsSeriousGate(Abc_ObjFanin0(pObj)) ) if ( !Abc_NodeIsSeriousGate(Abc_ObjFanin0(pObj)) )
continue; continue;
assert( Abc_ObjFanin0(pObj)->iTemp == 1 ); assert( Abc_ObjFanin0(pObj)->iTemp == 0 );
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp; pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
Vec_IntAddToEntry( vDrivenCos, pObj->iTemp, 1 );
} }
// for each network, count the total number of COs assert( Count == pNtk->nBarBufs2 );
Cba_ManForEachNtk( p, pCbaNtk, i )
{
Count = Cba_NtkPiNum(pCbaNtk) + 2 * Cba_NtkPoNum(pCbaNtk) - (fAlwaysAdd ? 0 : Vec_IntEntry(vDrivenCos, i));
Cba_NtkForEachBox( pCbaNtk, iBox )
Count += Cba_ObjBoxSize(pCbaNtk, iBox) + Cba_ObjBoxBiNum(pCbaNtk, iBox);
Vec_IntAddToEntry( vNtkSizes, i, Count );
}
Vec_IntFree( vDrivenCos );
return vNtkSizes;
} }
void Cba_NtkCreateOrConnectFanin( Abc_Ntk_t * pNtk, Abc_Obj_t * pFanin, Cba_Ntk_t * p, int iTerm ) void Cba_NtkCreateOrConnectFanin( Abc_Obj_t * pFanin, Cba_Ntk_t * p, int iTerm )
{ {
if ( pNtk && Abc_NodeIsSeriousGate(pFanin) ) int iObj;
if ( pFanin && Abc_NodeIsSeriousGate(pFanin) )
{ {
Vec_IntWriteEntry( &p->vNameIds, pFanin->iTemp, Cba_ObjNameId(p, iTerm) ); // Vec_IntWriteEntry( &p->vNameIds, pFanin->iTemp, Cba_ObjNameId(p, iTerm) );
Vec_IntWriteEntry( &p->vFanins, iTerm, pFanin->iTemp ); // Vec_IntWriteEntry( &p->vFanins, iTerm, pFanin->iTemp );
iObj = pFanin->iTemp;
} }
else if ( pNtk && (Abc_ObjIsPi(pFanin) || Abc_ObjIsBarBuf(pFanin)) ) else if ( pFanin && (Abc_ObjIsPi(pFanin) || Abc_ObjIsBarBuf(pFanin)) )
{ {
Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE ); // Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE );
Vec_IntWriteEntry( &p->vFuncs, p->nObjs, 3 ); // assuming elem gates are added first // Vec_IntWriteEntry( &p->vFuncs, p->nObjs, 3 ); // assuming elem gates are added first
Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, pFanin->iTemp) ); // Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, pFanin->iTemp) );
Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) ); // Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) );
Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ ); // Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ );
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, 0, pFanin->iTemp );
Cba_ObjSetName( p, iObj, Cba_ObjName(p, pFanin->iTemp) );
Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[2], -1 );
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, 0, -1 );
} }
else else
{ {
assert( !pFanin || Abc_NodeIsConst0(pFanin) || Abc_NodeIsConst1(pFanin) ); assert( !pFanin || Abc_NodeIsConst0(pFanin) || Abc_NodeIsConst1(pFanin) );
Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE ); // Vec_IntWriteEntry( &p->vTypes, p->nObjs, CBA_OBJ_NODE );
Vec_IntWriteEntry( &p->vFuncs, p->nObjs, pNtk && Abc_NodeIsConst1(pFanin) ? 2 : 1 ); // assuming elem gates are added first // Vec_IntWriteEntry( &p->vFuncs, p->nObjs, pFanin && Abc_NodeIsConst1(pFanin) ? 2 : 1 ); // assuming elem gates are added first
Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, -1) ); // Vec_IntWriteEntry( &p->vFanins, p->nObjs, Cba_ManHandleBuffer(p->pDesign, -1) );
Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) ); // Vec_IntWriteEntry( &p->vNameIds, p->nObjs, Cba_ObjNameId(p, iTerm) );
Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ ); // Vec_IntWriteEntry( &p->vFanins, iTerm, p->nObjs++ );
} Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[(pFanin && Abc_NodeIsConst1(pFanin))], -1 );
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, 0, -1 );
}
Cba_ObjSetName( p, iObj, Cba_ObjName(p, iTerm) );
Cba_ObjSetFanin( p, iTerm, iObj );
} }
void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib ) void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib )
{ {
...@@ -517,22 +504,19 @@ void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib ) ...@@ -517,22 +504,19 @@ void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib )
printf( "The library does not have one of the elementary gates.\n" ); printf( "The library does not have one of the elementary gates.\n" );
return; return;
} }
assert( Abc_NamObjNumMax(p->pFuncs) == 1 ); p->ElemGates[0] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate0), NULL );
Abc_NamStrFindOrAdd( p->pFuncs, Mio_GateReadName(pGate0), NULL ); p->ElemGates[1] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate1), NULL );
Abc_NamStrFindOrAdd( p->pFuncs, Mio_GateReadName(pGate1), NULL ); p->ElemGates[2] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate2), NULL );
Abc_NamStrFindOrAdd( p->pFuncs, Mio_GateReadName(pGate2), NULL );
assert( Abc_NamObjNumMax(p->pFuncs) == 4 );
Mio_LibraryForEachGate( pLib, pGate ) Mio_LibraryForEachGate( pLib, pGate )
if ( pGate != pGate0 && pGate != pGate1 && pGate != pGate2 ) if ( pGate != pGate0 && pGate != pGate1 && pGate != pGate2 )
Abc_NamStrFindOrAdd( p->pFuncs, Mio_GateReadName(pGate), NULL ); Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate), NULL );
assert( Abc_NamObjNumMax(p->pFuncs) > 1 ); assert( Abc_NamObjNumMax(p->pMods) > 1 );
} }
void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk ) void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk )
{ {
Cba_Ntk_t * pCbaNtk, * pRoot = Cba_ManRoot( p ); Cba_Ntk_t * pCbaNtk, * pRoot = Cba_ManRoot( p );
Vec_Int_t * vTemp = Vec_IntAlloc( 100 );
int i, j, k, iBox, iTerm, Count = 0; int i, j, k, iBox, iTerm, Count = 0;
Abc_Obj_t * pObj, * pFanin; Abc_Obj_t * pObj;
assert( Abc_NtkHasMapping(pNtk) ); assert( Abc_NtkHasMapping(pNtk) );
Cba_NtkPrepareLibrary( p, (Mio_Library_t *)pNtk->pManFunc ); Cba_NtkPrepareLibrary( p, (Mio_Library_t *)pNtk->pManFunc );
p->pMioLib = pNtk->pManFunc; p->pMioLib = pNtk->pManFunc;
...@@ -546,55 +530,59 @@ void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk ) ...@@ -546,55 +530,59 @@ void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk )
pCbaNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, Count) ); pCbaNtk = Cba_ManNtk( p, Vec_IntEntry(p->vBuf2RootNtk, Count) );
iTerm = Vec_IntEntry( p->vBuf2RootObj, Count ); iTerm = Vec_IntEntry( p->vBuf2RootObj, Count );
assert( Cba_ObjIsCo(pCbaNtk, iTerm) ); assert( Cba_ObjIsCo(pCbaNtk, iTerm) );
Cba_NtkCreateOrConnectFanin( pNtk, Abc_ObjFanin0(pObj), pCbaNtk, iTerm ); Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pCbaNtk, iTerm );
// prepare leaf // prepare leaf
pObj->iTemp = Vec_IntEntry( p->vBuf2LeafObj, Count++ ); pObj->iTemp = Vec_IntEntry( p->vBuf2LeafObj, Count++ );
} }
else if ( Abc_NodeIsSeriousGate(pObj) ) else if ( Abc_NodeIsSeriousGate(pObj) )
{ {
/*
Vec_IntClear( vTemp ); Vec_IntClear( vTemp );
Abc_ObjForEachFanin( pObj, pFanin, k ) Abc_ObjForEachFanin( pObj, pFanin, k )
Vec_IntPush( vTemp, pFanin->iTemp ); Vec_IntPush( vTemp, pFanin->iTemp );
pCbaNtk = Cba_ManNtk( p, pObj->iTemp ); pCbaNtk = Cba_ManNtk( p, pObj->iTemp );
Vec_IntWriteEntry( &pCbaNtk->vTypes, pCbaNtk->nObjs, CBA_OBJ_NODE ); Vec_IntWriteEntry( &pCbaNtk->vTypes, pCbaNtk->nObjs, CBA_OBJ_NODE );
Vec_IntWriteEntry( &pCbaNtk->vFuncs, pCbaNtk->nObjs, Abc_NamStrFind(p->pFuncs, Mio_GateReadName((Mio_Gate_t *)pObj->pData)) ); Vec_IntWriteEntry( &pCbaNtk->vFuncs, pCbaNtk->nObjs, Abc_NamStrFind(p->pMods, Mio_GateReadName((Mio_Gate_t *)pObj->pData)) );
Vec_IntWriteEntry( &pCbaNtk->vFanins, pCbaNtk->nObjs, Cba_ManHandleArray(p, vTemp) ); Vec_IntWriteEntry( &pCbaNtk->vFanins, pCbaNtk->nObjs, Cba_ManHandleArray(p, vTemp) );
pObj->iTemp = pCbaNtk->nObjs++; pObj->iTemp = pCbaNtk->nObjs++;
*/
pCbaNtk = Cba_ManNtk( p, pObj->iTemp );
for ( k = Abc_ObjFaninNum(pObj)-1; k >= 0; k-- )
{
iTerm = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BI, k, Abc_ObjFanin(pObj, k)->iTemp );
Cba_ObjSetName( pCbaNtk, iTerm, Cba_ObjName(pCbaNtk, Abc_ObjFanin(pObj, k)->iTemp) );
}
Cba_ObjAlloc( pCbaNtk, CBA_BOX_GATE, Abc_NamStrFind(p->pMods, Mio_GateReadName((Mio_Gate_t *)pObj->pData)), -1 );
pObj->iTemp = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BO, 0, -1 );
} }
} }
assert( Count == pNtk->nBarBufs2 ); assert( Count == pNtk->nBarBufs2 );
Vec_IntFree( vTemp );
// create constant 0 drivers for COs without barbufs // create constant 0 drivers for COs without barbufs
Cba_ManForEachNtk( p, pCbaNtk, i ) Cba_ManForEachNtk( p, pCbaNtk, i )
{ {
Cba_NtkForEachBox( pCbaNtk, iBox ) Cba_NtkForEachBox( pCbaNtk, iBox )
Cba_BoxForEachBi( pCbaNtk, iBox, iTerm, j ) Cba_BoxForEachBi( pCbaNtk, iBox, iTerm, j )
if ( Cba_ObjFanin0(pCbaNtk, iTerm) == -1 ) if ( Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
Cba_NtkCreateOrConnectFanin( NULL, NULL, pCbaNtk, iTerm ); Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
Cba_NtkForEachPo( pCbaNtk, iTerm, k ) Cba_NtkForEachPo( pCbaNtk, iTerm, k )
if ( pCbaNtk != pRoot && Cba_ObjFanin0(pCbaNtk, iTerm) == -1 ) if ( pCbaNtk != pRoot && Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
Cba_NtkCreateOrConnectFanin( NULL, NULL, pCbaNtk, iTerm ); Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
} }
// create node and connect POs // create node and connect POs
Abc_NtkForEachPo( pNtk, pObj, i ) Abc_NtkForEachPo( pNtk, pObj, i )
Cba_NtkCreateOrConnectFanin( pNtk, Abc_ObjFanin0(pObj), pRoot, Cba_NtkPo(pRoot, i) ); Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pRoot, Cba_NtkPo(pRoot, i) );
Cba_ManForEachNtk( p, pCbaNtk, i )
assert( Cba_NtkObjNum(pCbaNtk) == pCbaNtk->nObjs );
} }
void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc ) void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc )
{ {
Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc; Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc;
Vec_Int_t * vNtkSizes = Cba_ManCountAbc( p, pNtk, 0 ); Cba_Man_t * pNew = Cba_ManDupUserBoxes( p );
Cba_Man_t * pNew = Cba_ManDupStart( p, vNtkSizes ); Cba_ManMarkNodesAbc( p, pNtk );
Cba_ManRemapBarbufs( pNew, p ); Cba_ManRemapBarbufs( pNew, p );
Cba_NtkInsertNtk( pNew, pNtk ); Cba_NtkInsertNtk( pNew, pNtk );
Vec_IntFree( vNtkSizes );
return pNew; return pNew;
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaBuild.c deleted 100644 → 0
/**CFile****************************************************************
FileName [cbaBuild.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.]
Synopsis [Parses several flavors of word-level Verilog.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaBuild.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
// replaces NameIds of formal names by their index in the box model
void Cba_BoxRemap( Cba_Ntk_t * pNtk, int iBox, Vec_Int_t * vMap )
{
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
Cba_NtkForEachPi( pBoxModel, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) == -1 );
Vec_IntWriteEntry( vMap, NameId, i );
}
Cba_NtkForEachPo( pBoxModel, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) == -1 );
Vec_IntWriteEntry( vMap, NameId, Cba_NtkPiNum(pBoxModel) + i );
}
// remap box
assert( Vec_IntSize(vFanins) % 2 == 0 );
Vec_IntForEachEntry( vFanins, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) != -1 );
Vec_IntWriteEntry( vFanins, i++, Vec_IntEntry(vMap, NameId) );
}
// unmap formal inputs
Cba_NtkForEachPi( pBoxModel, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
Cba_NtkForEachPo( pBoxModel, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
}
void Cba_NtkRemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap )
{
int iBox;
Cba_NtkForEachBox( pNtk, iBox )
Cba_BoxRemap( pNtk, iBox, vMap );
}
// create maps of NameId and boxes
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 )
{
int i, iObj, Type, Index, NameId;
int nObjCount = 0;
// map old name IDs into new object IDs
Vec_IntClear( vBoxes );
Cba_NtkForEachPi( pNtk, NameId, i )
{
if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Primary inputs %d and %d have the same name.\n", Vec_IntEntry(vMap, NameId), i );
Vec_IntWriteEntry( vMap, NameId, nObjCount++ );
}
Cba_NtkForEachObjType( pNtk, Type, iObj )
{
if ( Type == CBA_OBJ_NODE )
{
// consider node output name
Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
NameId = Vec_IntEntry( vFanins, 0 );
if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Node output name %d is already driven.\n", NameId );
Vec_IntWriteEntry( vMap, NameId, nObjCount++ );
}
else if ( Type == CBA_OBJ_BOX )
{
Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
Cba_Ntk_t * pNtkBox = Cba_ObjBoxModel( pNtk, iObj );
nObjCount += Cba_NtkPiNum(pNtkBox);
Vec_IntPush( vBoxes, nObjCount++ );
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 )
printf( "Box output name %d is already driven.\n", NameId );
Vec_IntWriteEntry( vMap, NameId, nObjCount + Index - Cba_NtkPiNum(pNtkBox) );
}
nObjCount += Cba_NtkPoNum(pNtkBox);
}
}
Cba_NtkFindNonDriven( pNtk, vMap, nObjCount, vNonDriven );
nObjCount += Vec_IntSize(vNonDriven) + Cba_NtkPoNum(pNtk);
return nObjCount;
}
Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes, Vec_Int_t * vNonDriven, 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_ManNtk( pNew, Cba_NtkId(pNtk) );
Cba_NtkResize( pNtkNew, nObjCount );
// fill object information
Cba_NtkForEachPi( pNtk, NameId, i )
{
ObjId = Vec_IntEntry( vMap, NameId );
Vec_IntWriteEntry( &pNtkNew->vInputs, i, ObjId );
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_PI );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, i );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
}
Cba_NtkForEachObjType( pNtk, Type, iObj )
{
vFanins = Cba_ObjFaninVec( pNtk, iObj );
if ( Type == CBA_OBJ_NODE )
{
ObjId = Vec_IntEntry( vMap, Vec_IntEntry(vFanins, 0) );
Vec_IntClear( vTemp );
Vec_IntForEachEntryStart( vFanins, NameId, i, 1 )
{
assert( Vec_IntEntry(vMap, NameId) != -1 );
Vec_IntPush( vTemp, Vec_IntEntry(vMap, NameId) );
}
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_NODE );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, Cba_ObjFuncId(pNtk, iObj) );
Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, Cba_ManHandleArray(pNew, vTemp) );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, Vec_IntEntry(vFanins, 0) );
}
else if ( Type == CBA_OBJ_BOX )
{
ObjId = Vec_IntEntry( vBoxes, nBoxes++ );
pNtkBox = Cba_ObjBoxModel( pNtk, iObj );
// collect fanins
Vec_IntFill( vTemp, Cba_NtkPiNum(pNtkBox), -1 );
Vec_IntForEachEntry( vFanins, Index, i )
{
i++; NameId = Vec_IntEntry( vFanins, i );
assert( Vec_IntEntry(vMap, NameId) != -1 );
if ( Index < Cba_NtkPiNum(pNtkBox) )
{
Vec_IntWriteEntry( vTemp, Index, Vec_IntEntry(vMap, NameId) );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId - Cba_NtkPiNum(pNtkBox) + Index, NameId );
}
else
{
assert( Vec_IntEntry(vMap, NameId) == ObjId + 1 + Index - Cba_NtkPiNum(pNtkBox) );
Vec_IntWriteEntry( &pNtkNew->vNameIds, Vec_IntEntry(vMap, NameId), NameId );
}
}
Vec_IntForEachEntry( vTemp, Index, i )
assert( Index >= 0 );
// create box
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_BOX );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, Cba_ManNtkId(pNew, Cba_NtkName(pNtkBox)) );
Cba_NtkSetHost( Cba_ObjBoxModel(pNtkNew, ObjId), Cba_NtkId(pNtkNew), ObjId );
// create box inputs
Cba_BoxForEachBi( pNtkNew, ObjId, FaninId, i )
{
Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BI );
Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i );
Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, Vec_IntEntry(vTemp, i) );
}
// create box outputs
Cba_BoxForEachBo( pNtkNew, ObjId, FaninId, i )
{
Vec_IntWriteEntry( &pNtkNew->vTypes, FaninId, CBA_OBJ_BO );
Vec_IntWriteEntry( &pNtkNew->vFuncs, FaninId, i );
Vec_IntWriteEntry( &pNtkNew->vFanins, FaninId, ObjId );
}
}
}
assert( nBoxes == Vec_IntSize(vBoxes) );
// add constants for nondriven nodes
Vec_IntForEachEntry( vNonDriven, NameId, i )
{
ObjId = Vec_IntEntry( vMap, NameId );
Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId );
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_NODE );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, CBA_NODE_C0 );
Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, Cba_ManHandleBuffer(pNew, -1) );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
}
// add PO nodes
Cba_NtkForEachPo( pNtk, NameId, i )
{
ObjId = nObjCount - Cba_NtkPoNum(pNtk) + i;
FaninId = Vec_IntEntry( vMap, NameId );
assert( FaninId != -1 );
Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId );
Vec_IntWriteEntry( &pNtkNew->vTypes, ObjId, CBA_OBJ_PO );
Vec_IntWriteEntry( &pNtkNew->vFuncs, ObjId, i );
Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, FaninId );
// remove NameId from the driver and assign it to the output
//Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 );
Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
}
return pNtkNew;
}
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 );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_Man_t * Cba_ManBuild( Cba_Man_t * p )
{
Cba_Man_t * pNew = Cba_ManClone( p );
Vec_Int_t * vMap = Vec_IntStartFull( Abc_NamObjNumMax(p->pNames) + 1 );
Vec_Int_t * vBoxes = Vec_IntAlloc( 1000 );
Vec_Int_t * vNonDr = Vec_IntAlloc( 1000 );
Vec_Int_t * vTemp = Vec_IntAlloc( 1000 );
Cba_Ntk_t * pNtk;
int i, nObjs;
assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 );
Cba_ManForEachNtk( p, pNtk, i )
{
Cba_NtkRemapBoxes( pNtk, vMap );
nObjs = Cba_NtkCreateMap( pNtk, vMap, vBoxes, vNonDr );
Cba_NtkBuild( pNew, pNtk, vMap, vBoxes, vNonDr, vTemp, nObjs );
Cba_NtkCleanMap( pNtk, vMap );
}
assert( Vec_IntCountEntry(vMap, -1) == Vec_IntSize(vMap) );
Vec_IntFree( vMap );
Vec_IntFree( vBoxes );
Vec_IntFree( vNonDr );
Vec_IntFree( vTemp );
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaCom.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Command handlers.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -33,6 +33,7 @@ static int Cba_CommandWrite ( Abc_Frame_t * pAbc, int argc, char ** argv ); ...@@ -33,6 +33,7 @@ static int Cba_CommandWrite ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandPs ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Cba_CommandPs ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandPut ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Cba_CommandPut ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandGet ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Cba_CommandGet ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandClp ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandCec ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Cba_CommandCec ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Cba_CommandTest ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Cba_CommandTest ( Abc_Frame_t * pAbc, int argc, char ** argv );
...@@ -46,6 +47,48 @@ static inline void Cba_AbcUpdateMan( Abc_Frame_t * pAbc, Cba_Man_t * p ) ...@@ -46,6 +47,48 @@ static inline void Cba_AbcUpdateMan( Abc_Frame_t * pAbc, Cba_Man_t * p )
/**Function******************************************************************** /**Function********************************************************************
Synopsis [Accessing current Cba_Ntk_t.]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
void Abc_FrameImportDes( Vec_Ptr_t * vDes )
{
Cba_Man_t * p;
if ( Abc_FrameGetGlobalFrame() == NULL )
{
printf( "ABC framework is not started.\n" );
return;
}
p = Cba_PtrTransformToCba( vDes );
if ( p == NULL )
printf( "Converting from Ptr failed.\n" );
Cba_AbcUpdateMan( Abc_FrameGetGlobalFrame(), p );
}
Vec_Ptr_t * Abc_FrameExportDes()
{
Vec_Ptr_t * vDes;
Cba_Man_t * p;
if ( Abc_FrameGetGlobalFrame() == NULL )
{
printf( "ABC framework is not started.\n" );
return NULL;
}
p = Cba_AbcGetMan( Abc_FrameGetGlobalFrame() );
if ( p == NULL )
printf( "There is no CBA design present.\n" );
vDes = Cba_PtrDeriveFromCba( p );
if ( vDes == NULL )
printf( "Converting to Ptr has failed.\n" );
return vDes;
}
/**Function********************************************************************
Synopsis [] Synopsis []
Description [] Description []
...@@ -62,6 +105,7 @@ void Cba_Init( Abc_Frame_t * pAbc ) ...@@ -62,6 +105,7 @@ void Cba_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "New word level", "@ps", Cba_CommandPs, 0 ); Cmd_CommandAdd( pAbc, "New word level", "@ps", Cba_CommandPs, 0 );
Cmd_CommandAdd( pAbc, "New word level", "@put", Cba_CommandPut, 0 ); Cmd_CommandAdd( pAbc, "New word level", "@put", Cba_CommandPut, 0 );
Cmd_CommandAdd( pAbc, "New word level", "@get", Cba_CommandGet, 0 ); Cmd_CommandAdd( pAbc, "New word level", "@get", Cba_CommandGet, 0 );
Cmd_CommandAdd( pAbc, "New word level", "@clp", Cba_CommandClp, 0 );
Cmd_CommandAdd( pAbc, "New word level", "@cec", Cba_CommandCec, 0 ); Cmd_CommandAdd( pAbc, "New word level", "@cec", Cba_CommandCec, 0 );
Cmd_CommandAdd( pAbc, "New word level", "@test", Cba_CommandTest, 0 ); Cmd_CommandAdd( pAbc, "New word level", "@test", Cba_CommandTest, 0 );
} }
...@@ -97,7 +141,8 @@ void Cba_End( Abc_Frame_t * pAbc ) ...@@ -97,7 +141,8 @@ void Cba_End( Abc_Frame_t * pAbc )
int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv ) int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
{ {
FILE * pFile; FILE * pFile;
Cba_Man_t * p = NULL, * pTemp; Cba_Man_t * p = NULL;
Vec_Ptr_t * vDes = NULL;
char * pFileName = NULL; char * pFileName = NULL;
int c, fUseAbc = 0, fVerbose = 0; int c, fUseAbc = 0, fVerbose = 0;
Extra_UtilGetoptReset(); Extra_UtilGetoptReset();
...@@ -133,26 +178,34 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv ) ...@@ -133,26 +178,34 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0; return 0;
} }
fclose( pFile ); fclose( pFile );
// perform reading // perform reading
if ( fUseAbc ) if ( fUseAbc )
{ {
extern Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk ); extern Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk );
Abc_Ntk_t * pAbcNtk = Io_ReadNetlist( pFileName, Io_ReadFileType(pFileName), 0 ); Abc_Ntk_t * pAbcNtk = Io_ReadNetlist( pFileName, Io_ReadFileType(pFileName), 0 );
Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pAbcNtk ); Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pAbcNtk );
p = Cba_PrsReadPtr( vDes ); p = Cba_PtrTransformToCba( vDes );
Cba_PtrFree( vDes ); // points to names in pAbcNtk
if ( p )
{
ABC_FREE( p->pSpec ); ABC_FREE( p->pSpec );
p->pSpec = Abc_UtilStrsav( pAbcNtk->pSpec ); p->pSpec = Abc_UtilStrsav( pAbcNtk->pSpec );
}
Abc_NtkDelete( pAbcNtk ); Abc_NtkDelete( pAbcNtk );
Ptr_ManFreeDes( vDes ); // points to names in pAbcNtk
} }
else if ( !strcmp( Extra_FileNameExtension(pFileName), "blif" ) ) else if ( !strcmp( Extra_FileNameExtension(pFileName), "blif" ) )
p = Cba_PrsReadBlif( pFileName ); {
vDes = Prs_ManReadBlif( pFileName );
p = Prs_ManBuildCba( pFileName, vDes );
Prs_ManVecFree( vDes );
}
else if ( !strcmp( Extra_FileNameExtension(pFileName), "v" ) ) else if ( !strcmp( Extra_FileNameExtension(pFileName), "v" ) )
p = Cba_PrsReadVerilog( pFileName, 1 ); {
vDes = Prs_ManReadVerilog( pFileName );
p = Prs_ManBuildCba( pFileName, vDes );
Prs_ManVecFree( vDes );
}
else assert( 0 ); else assert( 0 );
p = Cba_ManBuild( pTemp = p );
Cba_ManFree( pTemp );
Cba_AbcUpdateMan( pAbc, p ); Cba_AbcUpdateMan( pAbc, p );
return 0; return 0;
usage: usage:
...@@ -336,7 +389,7 @@ usage: ...@@ -336,7 +389,7 @@ usage:
******************************************************************************/ ******************************************************************************/
int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv ) int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv )
{ {
Cba_Man_t * pNew, * p = Cba_AbcGetMan(pAbc); Cba_Man_t * pNew = NULL, * p = Cba_AbcGetMan(pAbc);
int c, fMapped = 0, fVerbose = 0; int c, fMapped = 0, fVerbose = 0;
Extra_UtilGetoptReset(); Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "mvh" ) ) != EOF ) while ( ( c = Extra_UtilGetopt( argc, argv, "mvh" ) ) != EOF )
...@@ -400,11 +453,57 @@ usage: ...@@ -400,11 +453,57 @@ usage:
SeeAlso [] SeeAlso []
******************************************************************************/ ******************************************************************************/
int Cba_CommandClp( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Cba_Man_t * pNew = NULL, * p = Cba_AbcGetMan(pAbc);
int c, fVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
{
switch ( c )
{
case 'v':
fVerbose ^= 1;
break;
case 'h':
goto usage;
default:
goto usage;
}
}
if ( p == NULL )
{
Abc_Print( 1, "Cba_CommandGet(): There is no current design.\n" );
return 0;
}
pNew = Cba_ManDup( p );
Cba_AbcUpdateMan( pAbc, pNew );
return 0;
usage:
Abc_Print( -2, "usage: @clp [-vh]\n" );
Abc_Print( -2, "\t collapses the current hierarchical design\n" );
Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n");
return 1;
}
/**Function********************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
******************************************************************************/
int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv ) int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
{ {
Cba_Man_t * pTemp, * p = Cba_AbcGetMan(pAbc); Cba_Man_t * p = Cba_AbcGetMan(pAbc);
Cec_ParCec_t ParsCec, * pPars = &ParsCec;
Gia_Man_t * pFirst, * pSecond, * pMiter; Gia_Man_t * pFirst, * pSecond, * pMiter;
Cec_ParCec_t ParsCec, * pPars = &ParsCec;
Vec_Ptr_t * vDes;
char * FileName, * pStr, ** pArgvNew; char * FileName, * pStr, ** pArgvNew;
int c, nArgcNew, fDumpMiter = 0, fVerbose = 0; int c, nArgcNew, fDumpMiter = 0, fVerbose = 0;
FILE * pFile; FILE * pFile;
...@@ -454,6 +553,7 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv ) ...@@ -454,6 +553,7 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
return 1; return 1;
} }
fclose( pFile ); fclose( pFile );
// extract AIG from the current design // extract AIG from the current design
pFirst = Cba_ManExtract( p, 0, 0 ); pFirst = Cba_ManExtract( p, 0, 0 );
if ( pFirst == NULL ) if ( pFirst == NULL )
...@@ -463,12 +563,12 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv ) ...@@ -463,12 +563,12 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
} }
// extract AIG from the second design // extract AIG from the second design
if ( !strcmp( Extra_FileNameExtension(FileName), "blif" ) ) if ( !strcmp( Extra_FileNameExtension(FileName), "blif" ) )
p = Cba_PrsReadBlif( FileName ); vDes = Prs_ManReadBlif( FileName );
else if ( !strcmp( Extra_FileNameExtension(FileName), "v" ) ) else if ( !strcmp( Extra_FileNameExtension(FileName), "v" ) )
p = Cba_PrsReadVerilog( FileName, 1 ); vDes = Prs_ManReadVerilog( FileName );
else assert( 0 ); else assert( 0 );
p = Cba_ManBuild( pTemp = p ); p = Prs_ManBuildCba( FileName, vDes );
Cba_ManFree( pTemp ); Prs_ManVecFree( vDes );
pSecond = Cba_ManExtract( p, 0, 0 ); pSecond = Cba_ManExtract( p, 0, 0 );
Cba_ManFree( p ); Cba_ManFree( p );
if ( pSecond == NULL ) if ( pSecond == NULL )
...@@ -495,7 +595,7 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv ) ...@@ -495,7 +595,7 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0; return 0;
usage: usage:
Abc_Print( -2, "usage: @cec [-vh]\n" ); Abc_Print( -2, "usage: @cec [-vh]\n" );
Abc_Print( -2, "\t combinational equivalence checking for the hierarchical design\n" ); Abc_Print( -2, "\t combinational equivalence checking\n" );
Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" ); Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n"); Abc_Print( -2, "\t-h : print the command usage\n");
return 1; return 1;
...@@ -514,7 +614,9 @@ usage: ...@@ -514,7 +614,9 @@ usage:
******************************************************************************/ ******************************************************************************/
int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv ) int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
{ {
extern void Cba_PrsReadVerilogTest( char * pFileName ); extern void Prs_ManReadBlifTest();
extern void Prs_ManReadVerilogTest();
Cba_Man_t * p = Cba_AbcGetMan(pAbc);
int c, fVerbose = 0; int c, fVerbose = 0;
Extra_UtilGetoptReset(); Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF ) while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
...@@ -531,13 +633,14 @@ int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv ) ...@@ -531,13 +633,14 @@ int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
} }
} }
/* /*
if ( pNtk == NULL ) if ( p == NULL )
{ {
Abc_Print( 1, "Cba_CommandTest(): There is no current design.\n" ); Abc_Print( 1, "Cba_CommandTest(): There is no current design.\n" );
return 0; return 0;
} }
*/ */
Cba_PrsReadVerilogTest( NULL ); //Cba_PtrTransformTestTest();
Prs_ManReadVerilogTest();
return 0; return 0;
usage: usage:
Abc_Print( -2, "usage: @test [-vh]\n" ); Abc_Print( -2, "usage: @test [-vh]\n" );
......
src/base/cba/cbaLib.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Library procedures.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
......
src/base/cba/cbaNtk.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Netlist manipulation.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -43,17 +43,51 @@ ABC_NAMESPACE_IMPL_START ...@@ -43,17 +43,51 @@ ABC_NAMESPACE_IMPL_START
***********************************************************************/ ***********************************************************************/
void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p ) void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p )
{ {
int i, NameId; char Buffer[100];
int i, iObj, iTerm, NameId, fFound, nNameLess = 0;
int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) ); int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) );
Cba_NtkForEachNode( p, i ) // PI/PO should have NameId
Cba_NtkForEachPi( p, iObj, i )
assert( Cba_ObjName(p, iObj) );
Cba_NtkForEachPo( p, iObj, i )
assert( Cba_ObjName(p, iObj) );
// user BI/BO should have NameId
Cba_NtkForEachBoxUser( p, iObj )
{ {
if ( Cba_ObjNameId(p, i) == -1 ) Cba_BoxForEachBi( p, iObj, iTerm, i )
assert( Cba_ObjName(p, iTerm) );
Cba_BoxForEachBo( p, iObj, iTerm, i )
assert( Cba_ObjName(p, iTerm) );
}
// check missing IDs
Cba_NtkForEachBoxPrim( p, iObj )
{ {
char Buffer[100]; Cba_BoxForEachBi( p, iObj, iTerm, i )
sprintf( Buffer, "%s%0*d", "_n_", nDigits, i ); nNameLess += !Cba_ObjName(p, iTerm);
NameId = Abc_NamStrFindOrAdd( p->pDesign->pNames, Buffer, NULL ); Cba_BoxForEachBo( p, iObj, iTerm, i )
Vec_IntWriteEntry( &p->vNameIds, i, NameId ); nNameLess += !Cba_ObjName(p, iTerm);
}
if ( !nNameLess )
return;
// create names for prim BO
Cba_NtkForEachBoxPrim( p, iObj )
Cba_BoxForEachBo( p, iObj, iTerm, i )
{
if ( Cba_ObjName(p, iTerm) )
continue;
sprintf( Buffer, "%s%0*d", "_n_", nDigits, iTerm );
NameId = Abc_NamStrFindOrAdd( p->pDesign->pStrs, Buffer, &fFound );
assert( !fFound );
Cba_ObjSetName( p, iTerm, NameId );
} }
// transfer names for prim BI
Cba_NtkForEachBoxPrim( p, iObj )
Cba_BoxForEachBi( p, iObj, iTerm, i )
{
if ( Cba_ObjName(p, iTerm) )
continue;
assert( Cba_ObjName(p, Cba_ObjFanin(p, iTerm)) );
Cba_ObjSetName( p, iTerm, Cba_ObjName(p, Cba_ObjFanin(p, iTerm)) );
} }
} }
void Cba_ManAssignInternNames( Cba_Man_t * p ) void Cba_ManAssignInternNames( Cba_Man_t * p )
...@@ -63,32 +97,10 @@ void Cba_ManAssignInternNames( Cba_Man_t * p ) ...@@ -63,32 +97,10 @@ void Cba_ManAssignInternNames( Cba_Man_t * p )
Cba_ManAssignInternNamesNtk( pNtk ); Cba_ManAssignInternNamesNtk( pNtk );
} }
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
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;
}
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis [Count number of objects after collapsing.]
Description [] Description []
...@@ -97,56 +109,26 @@ int Cba_ManObjNum( Cba_Man_t * p ) ...@@ -97,56 +109,26 @@ int Cba_ManObjNum( Cba_Man_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
// duplicate PI/PO/boxes int Cba_ManClpObjNum_rec( Cba_Ntk_t * p )
void Cba_ObjDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int iObj )
{ {
if ( Cba_ObjIsPi(p, iObj) ) int i, Counter = 0;
Vec_IntWriteEntry( &pNew->vInputs, Cba_ObjFuncId(p, iObj), pNew->nObjs ); if ( p->Count >= 0 )
if ( Cba_ObjIsPo(p, iObj) ) return p->Count;
Vec_IntWriteEntry( &pNew->vOutputs, Cba_ObjFuncId(p, iObj), pNew->nObjs ); Cba_NtkForEachBox( p, i )
Vec_IntWriteEntry( &pNew->vTypes, pNew->nObjs, Cba_ObjType(p, iObj) ); Counter += Cba_ObjIsBoxUser(p, i) ? Cba_ManClpObjNum_rec( Cba_BoxNtk(p, i) ) : Cba_BoxSize(p, i);
Vec_IntWriteEntry( &pNew->vFuncs, pNew->nObjs, Cba_ObjFuncId(p, iObj) ); return (p->Count = Counter);
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 );
Cba_NtkSetCopy( p, iObj, pNew->nObjs++ );
} }
void Cba_NtkDupStart( Cba_Ntk_t * pNew, Cba_Ntk_t * p ) int Cba_ManClpObjNum( Cba_Man_t * p )
{
int i, iObj, iTerm;
pNew->nObjs = 0;
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjDupStart( pNew, p, iObj );
Cba_NtkForEachPo( p, iObj, i )
Cba_ObjDupStart( pNew, p, iObj );
Cba_NtkForEachBox( p, iObj )
{
Cba_BoxForEachBi( p, iObj, iTerm, i )
Cba_ObjDupStart( pNew, p, iTerm );
Cba_ObjDupStart( pNew, p, iObj );
Cba_BoxForEachBo( p, iObj, iTerm, i )
Cba_ObjDupStart( pNew, p, iTerm );
// connect box outputs to boxes
Cba_BoxForEachBo( p, iObj, iTerm, i )
Vec_IntWriteEntry( &pNew->vFanins, Cba_NtkCopy(p, iTerm), Cba_NtkCopy(p, Cba_ObjFanin0(p, iTerm)) );
}
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_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = Cba_ManClone( p );
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkResize( Cba_ManNtk(pNew, i), vNtkSizes ? Vec_IntEntry(vNtkSizes, i) : Cba_NtkObjNum(pNtk) ); pNtk->Count = -1;
Vec_IntFill( &p->vCopies, Cba_ManObjNum(p), -1 ); return Cba_NtkPioNum( Cba_ManRoot(p) ) + Cba_ManClpObjNum_rec( Cba_ManRoot(p) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDupStart( Cba_ManNtk(pNew, i), pNtk );
return pNew;
} }
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis [Collects boxes in the DFS order.]
Description [] Description []
...@@ -155,52 +137,37 @@ Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vNtkSizes ) ...@@ -155,52 +137,37 @@ Cba_Man_t * Cba_ManDupStart( Cba_Man_t * p, Vec_Int_t * vNtkSizes )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
// duplicate internal nodes void Cba_NtkDfs_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
void Cba_NtkDupNodes( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vTemp )
{ {
Vec_Int_t * vFanins; int k, iFanin;
int i, k, Type, iTerm, iObj; if ( Cba_ObjIsBo(p, iObj) == 1 )
// dup nodes
Cba_NtkForEachNode( p, iObj )
Cba_ObjDupStart( pNew, p, iObj );
assert( pNew->nObjs == Cba_NtkObjNum(pNew) );
// connect
Cba_NtkForEachObjType( p, Type, i )
{
if ( Type == CBA_OBJ_PI || Type == CBA_OBJ_BOX || Type == CBA_OBJ_BO )
continue;
if ( Type == CBA_OBJ_PO || Type == CBA_OBJ_BI )
{ {
assert( Vec_IntEntry(&pNew->vFanins, Cba_NtkCopy(p, i)) == -1 ); Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
Vec_IntWriteEntry( &pNew->vFanins, Cba_NtkCopy(p, i), Cba_NtkCopy(p, Cba_ObjFanin0(p, i)) ); return;
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) );
} }
assert( Cba_ObjIsPi(p, iObj) || Cba_ObjIsBox(p, iObj) );
if ( Cba_ObjCopy(p, iObj) > 0 ) // visited
return;
Cba_ObjSetCopy( p, iObj, 1 );
Cba_BoxForEachFanin( p, iObj, iFanin, k )
Cba_NtkDfs_rec( p, iFanin, vBoxes );
Vec_IntPush( vBoxes, iObj );
} }
Cba_Man_t * Cba_ManDup( Cba_Man_t * p ) Vec_Int_t * Cba_NtkDfs( Cba_Ntk_t * p )
{ {
Cba_Ntk_t * pNtk; int i; int i, iObj;
Vec_Int_t * vTemp = Vec_IntAlloc( 100 ); Vec_Int_t * vBoxes = Vec_IntAlloc( Cba_NtkBoxNum(p) );
Cba_Man_t * pNew = Cba_ManDupStart( p, NULL ); Cba_NtkStartCopies( p ); // -1 = not visited; 1 = finished
Cba_ManForEachNtk( p, pNtk, i ) Cba_NtkForEachPi( p, iObj, i )
Cba_NtkDupNodes( Cba_ManNtk(pNew, i), pNtk, vTemp ); Cba_ObjSetCopy( p, iObj, 1 );
Vec_IntFree( vTemp ); Cba_NtkForEachPo( p, iObj, i )
return pNew; Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
return vBoxes;
} }
#if 0
/**Function************************************************************* /**Function*************************************************************
Synopsis [Count the number of objects.] Synopsis [Collects user boxes in the DFS order.]
Description [] Description []
...@@ -209,24 +176,37 @@ Cba_Man_t * Cba_ManDup( Cba_Man_t * p ) ...@@ -209,24 +176,37 @@ Cba_Man_t * Cba_ManDup( Cba_Man_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
int Cba_NtkCountObj_rec( Cba_Ntk_t * p ) int Cba_NtkDfsUserBoxes_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
{ {
int iObj, Count = 0; int k, iFanin;
if ( p->nObjsRec >= 0 ) assert( Cba_ObjIsBoxUser(p, iObj) );
return p->nObjsRec; if ( Cba_ObjCopy(p, iObj) == 1 ) // visited
Cba_NtkForEachBox( p, iObj ) return 1;
Count += Cba_BoxIsPrim(p, iObj) ? 1 : Cba_NtkCountObj_rec( Cba_ObjBoxModel(p, iObj) ); if ( Cba_ObjCopy(p, iObj) == 0 ) // loop
return Count; return 0;
Cba_ObjSetCopy( p, iObj, 0 );
Cba_BoxForEachFanin( p, iObj, iFanin, k )
if ( Cba_ObjIsBo(p, iFanin) && Cba_ObjIsBoxUser(p, Cba_ObjFanin(p, iFanin)) )
if ( !Cba_NtkDfsUserBoxes_rec( p, Cba_ObjFanin(p, iFanin), vBoxes ) )
return 0;
Vec_IntPush( vBoxes, iObj );
Cba_ObjSetCopy( p, iObj, 1 );
return 1;
} }
int Cba_ManCountObj( Cba_Man_t * p ) int Cba_NtkDfsUserBoxes( Cba_Ntk_t * p )
{ {
Cba_Ntk_t * pNtk; int i; int iObj;
Cba_ManForEachNtk( p, pNtk, i ) Cba_NtkStartCopies( p ); // -1 = not visited; 0 = on the path; 1 = finished
pNtk->nObjsRec = -1; Vec_IntClear( &p->vArray );
return Cba_NtkCountObj_rec( Cba_ManRoot(p) ); Cba_NtkForEachBoxUser( p, iObj )
if ( !Cba_NtkDfsUserBoxes_rec( p, iObj, &p->vArray ) )
{
printf( "Cyclic dependency of user boxes is detected.\n" );
return 0;
}
return 1;
} }
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis []
...@@ -241,53 +221,67 @@ int Cba_ManCountObj( Cba_Man_t * p ) ...@@ -241,53 +221,67 @@ int Cba_ManCountObj( Cba_Man_t * p )
void Cba_NtkCollapse_rec( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vSigs ) void Cba_NtkCollapse_rec( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vSigs )
{ {
int i, k, iObj, iTerm; int i, k, iObj, iTerm;
Cba_NtkStartCopies( p );
// set PI copies // set PI copies
Cba_NtkCleanCopies( p );
assert( Vec_IntSize(vSigs) == Cba_NtkPiNum(p) ); assert( Vec_IntSize(vSigs) == Cba_NtkPiNum(p) );
Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkForEachPi( p, iObj, i )
Cba_ObjSetCopy( pRoot, iObj, Vec_IntEntry(vSigs, i) ); Cba_ObjSetCopy( p, iObj, Vec_IntEntry(vSigs, i) );
// duplicate internal objects // duplicate internal objects
Cba_ManForEachBox( p, iObj ) Cba_NtkForEachBox( p, iObj )
if ( Cba_BoxIsPrim(p, iObj) ) if ( Cba_ObjIsBoxPrim(p, iObj) )
Cba_BoxDup( pNew, p, iObj ); Cba_BoxDup( pNew, p, iObj );
// duplicate other modules // duplicate user moduled in DFS order
Cba_ManForEachBox( p, iObj ) Vec_IntForEachEntry( &p->vArray, iObj, i )
if ( !Cba_BoxIsPrim(p, iObj) )
{ {
assert( Cba_ObjIsBoxUser(p, iObj) );
Vec_IntClear( vSigs ); Vec_IntClear( vSigs );
Cba_BoxForEachBi( iObj, iTerm, k ) Cba_BoxForEachBi( p, iObj, iTerm, k )
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) ); Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) );
Cba_NtkCollapse_rec( pNew, Cba_ObjBoxModel(p, iObj), vSigs ); Cba_NtkCollapse_rec( pNew, Cba_BoxNtk(p, iObj), vSigs );
Cba_BoxForEachBo( iObj, iTerm, k ) assert( Vec_IntSize(vSigs) == Cba_BoxBoNum(p, iObj) );
Cba_ObjAddFanin( pNew, Cba_ObjCopy(p, iObj), Vec_IntEntry(vSigs, k) ); Cba_BoxForEachBo( p, iObj, iTerm, k )
Cba_ObjSetCopy( p, iTerm, Vec_IntEntry(vSigs, k) );
} }
// connect objects // connect objects
Cba_ManForEachObj( p, iObj ) Cba_NtkForEachBi( p, iObj )
if ( Cba_ObjType(p, iObj) == CBA_OBJ_BI || Cba_ObjType(p, iObj) == CBA_OBJ_BO ) Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iObj), Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
Cba_ObjAddFanin( pNew, Cba_ObjCopy(p, iObj), Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
// collect POs // collect POs
Vec_IntClear( vSigs ); Vec_IntClear( vSigs );
Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkForEachPo( p, iObj, i )
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) ); Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
} }
Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p ) Cba_Man_t * Cba_ManCollapseInt( Cba_Man_t * p )
{ {
Cba_Man_t * pNew = Cba_ManAlloc( NULL, Cba_ManName(p) );
Cba_Ntk_t * pRootNew = Cba_NtkAlloc( pNew, Cba_NtkName(pRoot) );
int i, iObj; int i, iObj;
Vec_Int_t * vSigs = Vec_IntAlloc( 1000 ); Vec_Int_t * vSigs = Vec_IntAlloc( 1000 );
Cba_Man_t * pNew = Cba_ManStart( p, 1 );
Cba_Ntk_t * pRoot = Cba_ManRoot( p ); Cba_Ntk_t * pRoot = Cba_ManRoot( p );
Cba_Ntk_t * pRootNew = Cba_ManRoot( pNew );
Cba_NtkAlloc( pRootNew, Cba_NtkNameId(pRoot), Cba_NtkPiNum(pRoot), Cba_NtkPoNum(pRoot), Cba_ManClpObjNum(p) );
Cba_NtkForEachPi( pRoot, iObj, i ) Cba_NtkForEachPi( pRoot, iObj, i )
Vec_IntPush( vSigns, Cba_ObjDup(pRootNew, pRoot, iObj) ); Vec_IntPush( vSigs, Cba_ObjAlloc(pRootNew, CBA_OBJ_PI, i, -1) );
Cba_NtkCollapse_rec( pRootNew, pRoot, vSigns ); Cba_NtkCollapse_rec( pRootNew, pRoot, vSigs );
assert( Vec_IntSize(vSigns) == Cba_NtkPoNum(pRoot) ); assert( Vec_IntSize(vSigs) == Cba_NtkPoNum(pRoot) );
Cba_NtkForEachPo( pRoot, iObj, i ) Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ObjAddFanin( pRootNew, Cba_ObjDup(pRootNew, pRoot, iObj), Vec_IntEntry(vSigns, i) ); Cba_ObjAlloc( pRootNew, CBA_OBJ_PO, i, Vec_IntEntry(vSigs, i) );
assert( Cba_NtkObjNum(pRootNew) == Cba_NtkAllocNum(pRootNew) );
Vec_IntFree( vSigs ); Vec_IntFree( vSigs );
// transfer PI/PO names
Cba_NtkStartNames( pRootNew );
Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ObjSetName( pRootNew, Cba_NtkPo(pRootNew, i), Cba_ObjName(pRoot, iObj) );
Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ObjSetName( pRootNew, Cba_NtkPo(pRootNew, i), Cba_ObjName(pRoot, iObj) );
return pNew; return pNew;
} }
Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p )
#endif {
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
if ( !Cba_NtkDfsUserBoxes(pNtk) )
return NULL;
return Cba_ManCollapseInt( p );
}
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
......
src/base/cba/cbaPrs.h
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [External declarations.] Synopsis [Parser declarations.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -26,35 +26,38 @@ ...@@ -26,35 +26,38 @@
/// INCLUDES /// /// INCLUDES ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
#include "aig/gia/gia.h"
#include "misc/util/utilNam.h"
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// PARAMETERS /// /// PARAMETERS ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_HEADER_START ABC_NAMESPACE_HEADER_START
/* // parser name types
// parser objects (object types after parsing)
typedef enum { typedef enum {
CBA_PRS_NONE = 0, // 0: unused CBA_PRS_NAME = 0, // 0: name/variable
CBA_PRS_NODE, // 1: .names/assign/box2 (box without formal/actual binding) CBA_PRS_SLICE, // 1: slice
CBA_PRS_BOX, // 2: .subckt/.gate/box (box with formal/actual binding) CBA_PRS_CONST, // 2: constant
CBA_PRS_LATCH, // 3: .latch CBA_PRS_CONCAT, // 3: concatentation
CBA_PRS_CONCAT, // 4: concatenation } Prs_ManType_t;
CBA_PRS_UNKNOWN // 5: unknown
} Cba_PrsType_t;
*/
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// BASIC TYPES /// /// BASIC TYPES ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// network // network
typedef struct Cba_Prn_t_ Cba_Prn_t; typedef struct Prs_Ntk_t_ Prs_Ntk_t;
struct Cba_Prn_t_ struct Prs_Ntk_t_
{ {
// general info
int iModuleName; int iModuleName;
unsigned fMapped : 1;
unsigned fSlices : 1;
Abc_Nam_t * pStrs;
// interface // interface
Vec_Int_t vOrder; Vec_Int_t vOrder; // order of signals
// signal names // signal names
Vec_Int_t vInouts; // inouts Vec_Int_t vInouts; // inouts
Vec_Int_t vInputs; // inputs Vec_Int_t vInputs; // inputs
...@@ -65,37 +68,25 @@ struct Cba_Prn_t_ ...@@ -65,37 +68,25 @@ struct Cba_Prn_t_
Vec_Int_t vInputsR; // inputs Vec_Int_t vInputsR; // inputs
Vec_Int_t vOutputsR; // outputs Vec_Int_t vOutputsR; // outputs
Vec_Int_t vWiresR; // wires Vec_Int_t vWiresR; // wires
// objects // slices/concatenations/objects
Vec_Int_t vObjBegs; // object beginnings Vec_Int_t vSlices; // NameId + RangeId
Vec_Int_t vObjects; // object data (ModuleId; InstId; FormNameId/ActNameId/ActRange) Vec_Int_t vConcats; // array of NameId/SliceId/ConstId
// concatenations Vec_Int_t vBoxes; // ModuleId + InstId + array of pairs {FormNameId, ActSignalId(NameId/SliceId/ConstId/ConcatId)}
Vec_Int_t vConBegs; // concatenation beginnings Vec_Int_t vObjs; // box handles
Vec_Int_t vConcats; // concatenation data
}; };
// parser // parser
typedef struct Cba_Prs_t_ Cba_Prs_t; typedef struct Prs_Man_t_ Prs_Man_t;
struct Cba_Prs_t_ struct Prs_Man_t_
{ {
// input data // input data
char * pName; // file name char * pName; // file name
char * pBuffer; // file contents char * pBuffer; // file contents
char * pLimit; // end of file char * pLimit; // end of file
char * pCur; // current position char * pCur; // current position
// construction Abc_Nam_t * pStrs; // string manager
Cba_Man_t * pLibrary; Prs_Ntk_t * pNtk; // current network
Cba_Man_t * pDesign; Vec_Ptr_t * vNtks; // input networks
// interface collected by the parser
int iModuleName; // name Id
Vec_Int_t vInoutsCur; // inouts
Vec_Int_t vInputsCur; // inputs
Vec_Int_t vOutputsCur; // outputs
Vec_Int_t vWiresCur; // wires
// objects collected by the parser
Vec_Int_t vTypesCur; // Cba_PrsType_t
Vec_Int_t vFuncsCur; // functions (node->func; box->module; gate->cell; latch->init; concat->unused)
Vec_Int_t vFaninsCur; // instances
Vec_Int_t vInstIdsCur; // instance names
// temporary data // temporary data
Vec_Str_t vCover; // one SOP cover Vec_Str_t vCover; // one SOP cover
Vec_Int_t vTemp; // array of tokens Vec_Int_t vTemp; // array of tokens
...@@ -105,30 +96,70 @@ struct Cba_Prs_t_ ...@@ -105,30 +96,70 @@ struct Cba_Prs_t_
Vec_Int_t vFailed; Vec_Int_t vFailed;
Vec_Int_t vSucceeded; Vec_Int_t vSucceeded;
// error handling // error handling
int fUsingTemp2; // vTemp2 is in use
char ErrorStr[1000]; // error char ErrorStr[1000]; // error
}; };
#define Cba_PrsForEachModelVec( vVec, p, pName, i ) \ static inline Prs_Ntk_t * Prs_ManNtk( Vec_Ptr_t * vPrs, int i ) { return (Prs_Ntk_t *)Vec_PtrEntry(vPrs, i); }
for ( i = 0; (i < Vec_IntSize(vVec)) && ((pName) = Abc_NamStr(p->pDesign->pNames, Vec_IntEntry(vVec,i))); i++ ) static inline Prs_Ntk_t * Prs_ManRoot( Vec_Ptr_t * vPrs ) { return Prs_ManNtk(vPrs, 0); }
static inline int Prs_NtkId( Prs_Ntk_t * p ) { return p->iModuleName; }
static inline int Prs_NtkPioNum( Prs_Ntk_t * p ) { return Vec_IntSize(&p->vInouts); }
static inline int Prs_NtkPiNum( Prs_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); }
static inline int Prs_NtkPoNum( Prs_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); }
static inline int Prs_NtkBoxNum( Prs_Ntk_t * p ) { return Vec_IntSize(&p->vObjs); }
static inline int Prs_NtkObjNum( Prs_Ntk_t * p ) { return Prs_NtkPioNum(p) + Prs_NtkPiNum(p) + Prs_NtkPoNum(p) + Prs_NtkBoxNum(p); }
static inline char * Prs_NtkStr( Prs_Ntk_t * p, int h ) { return Abc_NamStr(p->pStrs, h); }
static inline char * Prs_NtkName( Prs_Ntk_t * p ) { return Prs_NtkStr(p, Prs_NtkId(p)); }
static inline int Prs_NtkSigName( Prs_Ntk_t * p, int i ) { if (!p->fSlices) return i; assert(Abc_Lit2Att2(i) == CBA_PRS_NAME); return Abc_Lit2Var2(i); }
static inline int Prs_SliceName( Prs_Ntk_t * p, int h ) { return Vec_IntEntry(&p->vSlices, h); }
static inline int Prs_SliceRange( Prs_Ntk_t * p, int h ) { return Vec_IntEntry(&p->vSlices, h+1); }
static inline int Prs_CatSize( Prs_Ntk_t * p, int h ) { return Vec_IntEntry(&p->vConcats, h); }
static inline int * Prs_CatArray( Prs_Ntk_t * p, int h ) { return Vec_IntEntryP(&p->vConcats, h+1); }
static inline Vec_Int_t * Prs_CatSignals( Prs_Ntk_t * p, int h ) { static Vec_Int_t V; V.nSize = V.nCap = Prs_CatSize(p, h); V.pArray = Prs_CatArray(p, h); return &V; }
static inline int Prs_BoxHand( Prs_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vObjs, i); }
static inline int Prs_BoxSize( Prs_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vBoxes, Prs_BoxHand(p, i))-2; }
static inline int Prs_BoxIONum( Prs_Ntk_t * p, int i ) { return Prs_BoxSize(p, i) / 2; }
static inline int Prs_BoxNtk( Prs_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vBoxes, Prs_BoxHand(p, i)+1); }
static inline void Prs_BoxSetNtk( Prs_Ntk_t * p, int i, int m ) { Vec_IntWriteEntry(&p->vBoxes, Prs_BoxHand(p, i)+1, m); }
static inline int Prs_BoxName( Prs_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vBoxes, Prs_BoxHand(p, i)+2); }
static inline int Prs_BoxIsNode( Prs_Ntk_t * p, int i ) { return!Vec_IntEntry(&p->vBoxes, Prs_BoxHand(p, i)+3); } // no formal names
static inline int * Prs_BoxArray( Prs_Ntk_t * p, int i ) { return Vec_IntEntryP(&p->vBoxes, Prs_BoxHand(p, i)+3); }
static inline Vec_Int_t * Prs_BoxSignals( Prs_Ntk_t * p, int i ) { static Vec_Int_t V; V.nSize = V.nCap = Prs_BoxSize(p, i); V.pArray = Prs_BoxArray(p, i); return &V; }
#define Prs_ManForEachNameVec( vVec, p, pName, i ) \
for ( i = 0; (i < Vec_IntSize(vVec)) && ((pName) = Abc_NamStr(p->pStrs, Vec_IntEntry(vVec,i))); i++ )
#define Prs_NtkForEachPio( p, NameId, i ) \
for ( i = 0; i < Prs_NtkPioNum(p) && ((NameId) = Vec_IntEntry(&p->vInouts, i)); i++ )
#define Prs_NtkForEachPi( p, NameId, i ) \
for ( i = 0; i < Prs_NtkPiNum(p) && ((NameId) = Vec_IntEntry(&p->vInputs, i)); i++ )
#define Prs_NtkForEachPo( p, NameId, i ) \
for ( i = 0; i < Prs_NtkPoNum(p) && ((NameId) = Vec_IntEntry(&p->vOutputs, i)); i++ )
#define Prs_NtkForEachBox( p, vVec, i ) \
for ( i = 0; i < Prs_NtkBoxNum(p) && ((vVec) = Prs_BoxSignals(p, i)); i++ )
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// MACRO DEFINITIONS /// /// MACRO DEFINITIONS ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// create error message // create error message
static inline int Cba_PrsErrorSet( Cba_Prs_t * p, char * pError, int Value ) static inline int Prs_ManErrorSet( Prs_Man_t * p, char * pError, int Value )
{ {
assert( !p->ErrorStr[0] ); assert( !p->ErrorStr[0] );
sprintf( p->ErrorStr, "%s", pError ); sprintf( p->ErrorStr, "%s", pError );
return Value; return Value;
} }
// clear error message // clear error message
static inline void Cba_PrsErrorClear( Cba_Prs_t * p ) static inline void Prs_ManErrorClear( Prs_Man_t * p )
{ {
p->ErrorStr[0] = '\0'; p->ErrorStr[0] = '\0';
} }
// print error message // print error message
static inline int Cba_PrsErrorPrint( Cba_Prs_t * p ) static inline int Prs_ManErrorPrint( Prs_Man_t * p )
{ {
char * pThis; int iLine = 0; char * pThis; int iLine = 0;
if ( !p->ErrorStr[0] ) return 1; if ( !p->ErrorStr[0] ) return 1;
...@@ -138,25 +169,58 @@ static inline int Cba_PrsErrorPrint( Cba_Prs_t * p ) ...@@ -138,25 +169,58 @@ static inline int Cba_PrsErrorPrint( Cba_Prs_t * p )
return 0; return 0;
} }
// create network // parsing network
static inline Cba_Ntk_t * Cba_PrsAddCurrentModel( Cba_Prs_t * p, int iNameId ) static inline void Prs_ManInitializeNtk( Prs_Man_t * p, int iName, int fSlices )
{
assert( p->pNtk == NULL );
p->pNtk = ABC_CALLOC( Prs_Ntk_t, 1 );
p->pNtk->iModuleName = iName;
p->pNtk->fSlices = fSlices;
p->pNtk->pStrs = Abc_NamRef( p->pStrs );
Vec_PtrPush( p->vNtks, p->pNtk );
}
static inline void Prs_ManFinalizeNtk( Prs_Man_t * p )
{ {
Cba_Ntk_t * pNtk = Cba_NtkAlloc( p->pDesign, Abc_NamStr(p->pDesign->pNames, iNameId) ); assert( p->pNtk != NULL );
assert( Vec_IntSize(&p->vInputsCur) != 0 || Vec_IntSize(&p->vOutputsCur) != 0 ); p->pNtk = NULL;
Cba_ManSetupArray( p->pDesign, &pNtk->vInouts, &p->vInoutsCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vInputs, &p->vInputsCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vOutputs, &p->vOutputsCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vWires, &p->vWiresCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vTypes, &p->vTypesCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vFuncs, &p->vFuncsCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vFanins, &p->vFaninsCur );
Cba_ManSetupArray( p->pDesign, &pNtk->vInstIds, &p->vInstIdsCur );
return pNtk;
} }
// parsing slice/concatentation/box
static inline int Prs_NtkAddSlice( Prs_Ntk_t * p, int Name, int Range )
{
int Value = Vec_IntSize(&p->vSlices);
Vec_IntPushTwo( &p->vSlices, Name, Range );
return Value;
}
static inline int Prs_NtkAddConcat( Prs_Ntk_t * p, Vec_Int_t * vTemp )
{
int Value;
if ( !(Vec_IntSize(&p->vConcats) & 1) )
Vec_IntPush(&p->vConcats, -1);
Value = Vec_IntSize(&p->vConcats);
assert( Value & 1 );
Vec_IntPush( &p->vConcats, Vec_IntSize(vTemp) );
Vec_IntAppend( &p->vConcats, vTemp );
return Value;
}
static inline void Prs_NtkAddBox( Prs_Ntk_t * p, int ModName, int InstName, Vec_Int_t * vTemp )
{
int Value;
assert( Vec_IntSize(vTemp) % 2 == 0 );
if ( !(Vec_IntSize(&p->vBoxes) & 1) )
Vec_IntPush(&p->vBoxes, -1);
Value = Vec_IntSize(&p->vBoxes);
assert( Value & 1 );
Vec_IntPush( &p->vObjs, Value );
// create entry
Vec_IntPush( &p->vBoxes, Vec_IntSize(vTemp)+2 );
Vec_IntPush( &p->vBoxes, ModName );
Vec_IntPush( &p->vBoxes, InstName );
Vec_IntAppend( &p->vBoxes, vTemp );
}
static inline char * Cba_PrsLoadFile( char * pFileName, char ** ppLimit ) static inline char * Prs_ManLoadFile( char * pFileName, char ** ppLimit )
{ {
char * pBuffer; char * pBuffer;
int nFileSize, RetValue; int nFileSize, RetValue;
...@@ -181,57 +245,153 @@ static inline char * Cba_PrsLoadFile( char * pFileName, char ** ppLimit ) ...@@ -181,57 +245,153 @@ static inline char * Cba_PrsLoadFile( char * pFileName, char ** ppLimit )
*ppLimit = pBuffer + nFileSize + 2; *ppLimit = pBuffer + nFileSize + 2;
return pBuffer; return pBuffer;
} }
static inline Cba_Prs_t * Cba_PrsAlloc( char * pFileName ) static inline Prs_Man_t * Prs_ManAlloc( char * pFileName )
{ {
Cba_Prs_t * p; Prs_Man_t * p;
char * pBuffer, * pLimit; char * pBuffer, * pLimit;
pBuffer = Cba_PrsLoadFile( pFileName, &pLimit ); pBuffer = Prs_ManLoadFile( pFileName, &pLimit );
if ( pBuffer == NULL ) if ( pBuffer == NULL )
return NULL; return NULL;
p = ABC_CALLOC( Cba_Prs_t, 1 ); p = ABC_CALLOC( Prs_Man_t, 1 );
p->pName = pFileName; p->pName = pFileName;
p->pBuffer = pBuffer; p->pBuffer = pBuffer;
p->pLimit = pLimit; p->pLimit = pLimit;
p->pCur = pBuffer; p->pCur = pBuffer;
p->pDesign = Cba_ManAlloc( NULL, pFileName ); p->pStrs = Abc_NamStart( 1000, 24 );
p->vNtks = Vec_PtrAlloc( 100 );
return p; return p;
} }
static inline void Cba_PrsFree( Cba_Prs_t * p )
static inline void Prs_NtkFree( Prs_Ntk_t * p )
{ {
if ( p->pDesign ) if ( p->pStrs )
Cba_ManFree( p->pDesign ); Abc_NamDeref( p->pStrs );
Vec_IntErase( &p->vInoutsCur ); Vec_IntErase( &p->vOrder );
Vec_IntErase( &p->vInputsCur ); Vec_IntErase( &p->vInouts );
Vec_IntErase( &p->vOutputsCur ); Vec_IntErase( &p->vInputs );
Vec_IntErase( &p->vWiresCur ); Vec_IntErase( &p->vOutputs );
Vec_IntErase( &p->vWires );
Vec_IntErase( &p->vInoutsR );
Vec_IntErase( &p->vInputsR );
Vec_IntErase( &p->vOutputsR );
Vec_IntErase( &p->vWiresR );
Vec_IntErase( &p->vSlices );
Vec_IntErase( &p->vConcats );
Vec_IntErase( &p->vBoxes );
Vec_IntErase( &p->vObjs );
ABC_FREE( p );
}
Vec_IntErase( &p->vTypesCur ); static inline void Prs_ManFree( Prs_Man_t * p )
Vec_IntErase( &p->vFuncsCur ); {
Vec_IntErase( &p->vFaninsCur ); extern void Prs_ManVecFree( Vec_Ptr_t * vPrs );
Vec_IntErase( &p->vInstIdsCur ); if ( p->pStrs )
Abc_NamDeref( p->pStrs );
if ( p->vNtks )
Prs_ManVecFree( p->vNtks );
// temporary // temporary
Vec_StrErase( &p->vCover ); Vec_StrErase( &p->vCover );
Vec_IntErase( &p->vTemp ); Vec_IntErase( &p->vTemp );
Vec_IntErase( &p->vTemp2 ); Vec_IntErase( &p->vTemp2 );
Vec_IntErase( &p->vKnown ); Vec_IntErase( &p->vKnown );
Vec_IntErase( &p->vFailed ); Vec_IntErase( &p->vFailed );
Vec_IntErase( &p->vSucceeded ); Vec_IntErase( &p->vSucceeded );
ABC_FREE( p->pBuffer ); ABC_FREE( p->pBuffer );
ABC_FREE( p ); ABC_FREE( p );
} }
static inline void Cba_PrsRemapBoxModels( Cba_Man_t * p )
static inline int Prs_NtkMemory( Prs_Ntk_t * p )
{ {
Cba_Ntk_t * pNtk; int i, iBox; int nMem = sizeof(Prs_Ntk_t);
Cba_ManForEachNtk( p, pNtk, i ) nMem += Vec_IntMemory( &p->vOrder );
Cba_NtkForEachBox( pNtk, iBox ) nMem += Vec_IntMemory( &p->vInouts );
{ nMem += Vec_IntMemory( &p->vInputs );
char * pName = Abc_NamStr( p->pNames, Cba_ObjFuncId(pNtk, iBox) ); nMem += Vec_IntMemory( &p->vOutputs );
int iModelId = Abc_NamStrFind( p->pModels, pName ); nMem += Vec_IntMemory( &p->vWires );
assert( iModelId > 0 ); nMem += Vec_IntMemory( &p->vInoutsR );
Vec_IntWriteEntry( &pNtk->vFuncs, iBox, iModelId ); nMem += Vec_IntMemory( &p->vInputsR );
} nMem += Vec_IntMemory( &p->vOutputsR );
nMem += Vec_IntMemory( &p->vWiresR );
nMem += Vec_IntMemory( &p->vSlices );
nMem += Vec_IntMemory( &p->vBoxes );
nMem += Vec_IntMemory( &p->vConcats );
return nMem;
}
static inline int Prs_ManMemory( Vec_Ptr_t * vPrs )
{
Prs_Ntk_t * pNtk; int i;
int nMem = Vec_PtrMemory(vPrs);
Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
nMem += Prs_NtkMemory( pNtk );
nMem += Abc_NamMemUsed(pNtk->pStrs);
return nMem;
}
/**Function*************************************************************
Synopsis [Count range size.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Prs_ManRangeSizeName( Prs_Ntk_t * p, int Name )
{
return 1;
}
static inline int Prs_ManRangeSizeRange( Prs_Ntk_t * p, int Range )
{
char * pStr;
int Left, Right;
if ( Range == 0 )
return 1;
pStr = Prs_NtkStr( p, Range );
assert( pStr[0] == '[' );
Left = Right = atoi( pStr + 1 );
pStr = strstr( pStr, "=" );
if ( pStr )
Right = atoi( pStr + 1 );
return 1 + (Left > Right ? Left - Right : Right - Left);
} }
static inline int Prs_ManRangeSizeConst( Prs_Ntk_t * p, int Const )
{
return atoi( Prs_NtkStr(p, Const) );
}
static inline int Prs_ManRangeSizeConcat( Prs_Ntk_t * p, int Con )
{
extern int Prs_ManRangeSizeArray( Prs_Ntk_t * p, Vec_Int_t * vSlices, int Start, int Stop );
Vec_Int_t * vSigs = Prs_CatSignals(p, Con);
return Prs_ManRangeSizeArray( p, vSigs, 0, Vec_IntSize(vSigs) );
}
static inline int Prs_ManRangeSizeSignal( Prs_Ntk_t * p, int Sig )
{
int Value = Abc_Lit2Var2( Sig );
Prs_ManType_t Type = Abc_Lit2Att2( Sig );
if ( Type == CBA_PRS_NAME )
return Prs_ManRangeSizeName( p, Value );
if ( Type == CBA_PRS_SLICE )
return Prs_ManRangeSizeRange( p, Prs_SliceRange(p, Value) );
if ( Type == CBA_PRS_CONST )
return Prs_ManRangeSizeConst( p, Value );
if ( Type == CBA_PRS_CONCAT )
return Prs_ManRangeSizeConcat( p, Value );
assert( 0 );
return 0;
}
static inline int Prs_ManRangeSizeArray( Prs_Ntk_t * p, Vec_Int_t * vSlices, int Start, int Stop )
{
int i, Sig, Count = 0;
assert( Vec_IntSize(vSlices) > 0 );
Vec_IntForEachEntryStartStop( vSlices, Sig, i, Start, Stop )
Count += Prs_ManRangeSizeSignal( p, Sig );
return Count;
}
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// ITERATORS /// /// ITERATORS ///
......
src/base/cba/cbaPrsBuild.c 0 → 100644
/**CFile****************************************************************
FileName [cbaPrsBuild.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
Synopsis [Parse tree to netlist transformation.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaPrsBuild.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
#include "cbaPrs.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Prs_ManVecFree( Vec_Ptr_t * vPrs )
{
Prs_Ntk_t * pNtk; int i;
Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
Prs_NtkFree( pNtk );
Vec_PtrFree( vPrs );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Prs_NtkCountObjects( Prs_Ntk_t * pNtk )
{
Vec_Int_t * vFanins;
int i, Count = Prs_NtkObjNum(pNtk);
Prs_NtkForEachBox( pNtk, vFanins, i )
Count += Prs_BoxIONum(pNtk, i);
return Count;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
// replaces NameIds of formal names by their index in the box model
void Prs_ManRemapOne( Vec_Int_t * vSigs, Prs_Ntk_t * pNtkBox, Vec_Int_t * vMap )
{
int i, NameId;
// map formal names into I/O indexes
Prs_NtkForEachPi( pNtkBox, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) == -1 );
Vec_IntWriteEntry( vMap, NameId, i + 1 ); // +1 to keep 1st form input non-zero
}
Prs_NtkForEachPo( pNtkBox, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) == -1 );
Vec_IntWriteEntry( vMap, NameId, Prs_NtkPiNum(pNtkBox) + i + 1 ); // +1 to keep 1st form input non-zero
}
// remap box
assert( Vec_IntSize(vSigs) % 2 == 0 );
Vec_IntForEachEntry( vSigs, NameId, i )
{
assert( Vec_IntEntry(vMap, NameId) != -1 );
Vec_IntWriteEntry( vSigs, i++, Vec_IntEntry(vMap, NameId) );
}
// unmap formal inputs
Prs_NtkForEachPi( pNtkBox, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
Prs_NtkForEachPo( pNtkBox, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
}
void Prs_ManRemapBoxes( Cba_Man_t * pNew, Vec_Ptr_t * vDes, Prs_Ntk_t * pNtk, Vec_Int_t * vMap )
{
Vec_Int_t * vSigs; int iBox;
Prs_NtkForEachBox( pNtk, vSigs, iBox )
if ( !Prs_BoxIsNode(pNtk, iBox) )
{
int NtkId = Prs_BoxNtk( pNtk, iBox );
int NtkIdNew = Cba_ManNtkFindId( pNew, Prs_NtkStr(pNtk, NtkId) );
Prs_BoxSetNtk( pNtk, iBox, NtkIdNew );
Prs_ManRemapOne( vSigs, Prs_ManNtk(vDes, NtkIdNew), vMap );
}
}
void Prs_ManCleanMap( Prs_Ntk_t * pNtk, Vec_Int_t * vMap )
{
Vec_Int_t * vSigs;
int i, k, NameId, Sig;
Prs_NtkForEachPi( pNtk, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
Prs_NtkForEachBox( pNtk, vSigs, i )
Vec_IntForEachEntryDouble( vSigs, NameId, Sig, k )
Vec_IntWriteEntry( vMap, Prs_NtkSigName(pNtk, Sig), -1 );
Prs_NtkForEachPo( pNtk, NameId, i )
Vec_IntWriteEntry( vMap, NameId, -1 );
}
// create maps of NameId and boxes
void Prs_ManBuildNtk( Cba_Ntk_t * pNew, Vec_Ptr_t * vDes, Prs_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes )
{
Prs_Ntk_t * pNtkBox; Vec_Int_t * vSigs; int iBox;
int i, Index, NameId, iObj, iConst0, iTerm;
int iNonDriven = -1, nNonDriven = 0;
assert( Prs_NtkPioNum(pNtk) == 0 );
Prs_ManRemapBoxes( pNew->pDesign, vDes, pNtk, vMap );
Cba_NtkStartNames( pNew );
// create primary inputs
Prs_NtkForEachPi( pNtk, NameId, i )
{
if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Primary inputs %d and %d have the same name.\n", Vec_IntEntry(vMap, NameId), i );
iObj = Cba_ObjAlloc( pNew, CBA_OBJ_PI, -1, -1 );
Cba_ObjSetName( pNew, iObj, NameId );
Vec_IntWriteEntry( vMap, NameId, iObj );
}
// create box outputs
Vec_IntClear( vBoxes );
Prs_NtkForEachBox( pNtk, vSigs, iBox )
if ( !Prs_BoxIsNode(pNtk, iBox) )
{
pNtkBox = Prs_ManNtk( vDes, Prs_BoxNtk(pNtk, iBox) );
iObj = Cba_BoxAlloc( pNew, CBA_OBJ_BOX, Prs_NtkPiNum(pNtkBox), Prs_NtkPoNum(pNtkBox), Prs_BoxNtk(pNtk, iBox) );
Cba_ObjSetName( pNew, iObj, Prs_BoxName(pNtk, iBox) );
Vec_IntForEachEntry( vSigs, Index, i )
{
i++;
if ( --Index < Prs_NtkPiNum(pNtkBox) )
continue;
assert( Index - Prs_NtkPiNum(pNtkBox) < Prs_NtkPoNum(pNtkBox) );
// consider box output
NameId = Vec_IntEntry( vSigs, i );
NameId = Prs_NtkSigName( pNtk, NameId );
if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Box output name %d is already driven.\n", NameId );
iTerm = Cba_BoxBo( pNew, iObj, Index - Prs_NtkPiNum(pNtkBox) );
Cba_ObjSetName( pNew, iTerm, NameId );
Vec_IntWriteEntry( vMap, NameId, iTerm );
}
// remember box
Vec_IntPush( vBoxes, iObj );
}
else
{
iObj = Cba_BoxAlloc( pNew, Prs_BoxNtk(pNtk, iBox), Prs_BoxIONum(pNtk, iBox)-1, 1, -1 );
// consider box output
NameId = Vec_IntEntryLast( vSigs );
NameId = Prs_NtkSigName( pNtk, NameId );
if ( Vec_IntEntry(vMap, NameId) != -1 )
printf( "Node output name %d is already driven.\n", NameId );
iTerm = Cba_BoxBo( pNew, iObj, 0 );
Cba_ObjSetName( pNew, iTerm, NameId );
Vec_IntWriteEntry( vMap, NameId, iTerm );
// remember box
Vec_IntPush( vBoxes, iObj );
}
// add fanins for box inputs
Prs_NtkForEachBox( pNtk, vSigs, iBox )
if ( !Prs_BoxIsNode(pNtk, iBox) )
{
pNtkBox = Prs_ManNtk( vDes, Prs_BoxNtk(pNtk, iBox) );
iObj = Vec_IntEntry( vBoxes, iBox );
Vec_IntForEachEntry( vSigs, Index, i )
{
i++;
if ( --Index >= Prs_NtkPiNum(pNtkBox) )
continue;
NameId = Vec_IntEntry( vSigs, i );
NameId = Prs_NtkSigName( pNtk, NameId );
iTerm = Cba_BoxBi( pNew, iObj, Index );
if ( Vec_IntEntry(vMap, NameId) == -1 )
{
iConst0 = Cba_BoxAlloc( pNew, CBA_BOX_C0, 0, 1, -1 );
Vec_IntWriteEntry( vMap, NameId, iConst0+1 );
if ( iNonDriven == -1 )
iNonDriven = NameId;
nNonDriven++;
}
Cba_ObjSetFanin( pNew, iTerm, Vec_IntEntry(vMap, NameId) );
Cba_ObjSetName( pNew, iTerm, NameId );
}
}
else
{
iObj = Vec_IntEntry( vBoxes, iBox );
Vec_IntForEachEntryStop( vSigs, Index, i, Vec_IntSize(vSigs)-2 )
{
NameId = Vec_IntEntry( vSigs, ++i );
NameId = Prs_NtkSigName( pNtk, NameId );
iTerm = Cba_BoxBi( pNew, iObj, i/2 );
if ( Vec_IntEntry(vMap, NameId) == -1 )
{
iConst0 = Cba_BoxAlloc( pNew, CBA_BOX_C0, 0, 1, -1 );
Vec_IntWriteEntry( vMap, NameId, iConst0+1 );
if ( iNonDriven == -1 )
iNonDriven = NameId;
nNonDriven++;
}
Cba_ObjSetFanin( pNew, iTerm, Vec_IntEntry(vMap, NameId) );
Cba_ObjSetName( pNew, iTerm, NameId );
}
}
// add fanins for primary outputs
Prs_NtkForEachPo( pNtk, NameId, i )
if ( Vec_IntEntry(vMap, NameId) == -1 )
{
iConst0 = Cba_BoxAlloc( pNew, CBA_BOX_C0, 0, 1, -1 );
Vec_IntWriteEntry( vMap, NameId, iConst0+1 );
if ( iNonDriven == -1 )
iNonDriven = NameId;
nNonDriven++;
}
Prs_NtkForEachPo( pNtk, NameId, i )
{
iObj = Cba_ObjAlloc( pNew, CBA_OBJ_PO, -1, Vec_IntEntry(vMap, NameId) );
Cba_ObjSetName( pNew, iObj, NameId );
}
if ( nNonDriven )
printf( "Module %s has %d non-driven nets (for example, %s).\n", Prs_NtkName(pNtk), nNonDriven, Prs_NtkStr(pNtk, iNonDriven) );
Prs_ManCleanMap( pNtk, vMap );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_Man_t * Prs_ManBuildCba( char * pFileName, Vec_Ptr_t * vDes )
{
Prs_Ntk_t * pNtk = Prs_ManRoot( vDes ); int i;
Cba_Man_t * pNew = Cba_ManAlloc( pFileName, Vec_PtrSize(vDes) );
Vec_Int_t * vMap = Vec_IntStartFull( Abc_NamObjNumMax(pNtk->pStrs) + 1 );
Vec_Int_t * vTmp = Vec_IntAlloc( Prs_NtkBoxNum(pNtk) );
Abc_NamDeref( pNew->pStrs );
pNew->pStrs = Abc_NamRef( pNtk->pStrs );
Vec_PtrForEachEntry( Prs_Ntk_t *, vDes, pNtk, i )
Cba_NtkAlloc( Cba_ManNtk(pNew, i), Prs_NtkId(pNtk), Prs_NtkPiNum(pNtk), Prs_NtkPoNum(pNtk), Prs_NtkCountObjects(pNtk) );
Vec_PtrForEachEntry( Prs_Ntk_t *, vDes, pNtk, i )
Prs_ManBuildNtk( Cba_ManNtk(pNew, i), vDes, pNtk, vMap, vTmp );
assert( Vec_IntCountEntry(vMap, -1) == Vec_IntSize(vMap) );
Vec_IntFree( vMap );
Vec_IntFree( vTmp );
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaPrsTrans.c 0 → 100644
/**CFile****************************************************************
FileName [cbaPrsTrans.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
Synopsis [Parse tree to netlist transformation.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaPrsTrans.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
#include "cbaPrs.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaPtr.c 0 → 100644
/**CFile****************************************************************
FileName [cbaPtr.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
Synopsis [Simple interface with external tools.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaPtr.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "base/abc/abc.h"
#include "base/main/mainInt.h"
#include "map/mio/mio.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
/*
design = array containing design name (as the first entry in the array) followed by pointers to modules
module = array containing module name (as the first entry in the array) followed by pointers to 6 arrays:
{array of input names; array of output names; array of nodes; array of boxes,
array of floating-point input-arrival times; array of floating-point output-required times}
node = array containing output name, followed by node type, followed by input names
box = array containing model name, instance name, followed by pairs of formal/actual names for each port
Comments:
- in describing boxes
- input formal/actual name pairs should be listed before output name pairs
- the order of formal names should be the same as the order of inputs/outputs in the module description
- all formal names present in the module description should be listed
- if an input pin is not driven or an output pin has no fanout, the actual pin name is NULL
- word-level formal name "a" is written as bit-level names (a[0]. a[1], etc) ordered LSB to MSB
- primitive names should be given as char*-strings in description of nodes and boxes
- primitive modules should not be written, but the list of primitives and formal names should be provided
- constant 0/1 nets can be specified as char*-strings "NetConst0" and "NetConst1".
- arrays of input-arrival/output-required times in the module description are optional
*/
// elementary gates
typedef enum {
PTR_GATE_NONE = 0,
PTR_GATE_C0, // Const0T
PTR_GATE_C1, // Const1T
PTR_GATE_BUF, // BufT
PTR_GATE_INV, // InvT
PTR_GATE_AND, // AndT
PTR_GATE_NAND, // NandT
PTR_GATE_OR, // OrT
PTR_GATE_NOR, // NorT
PTR_GATE_XOR, // XorT
PTR_GATE_XNOR, // XnorT
PTR_GATE_UNKNOWN
} Ptr_ObjType_t;
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Free Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_PtrFreeNtk( Vec_Ptr_t * vNtk )
{
Vec_PtrFree( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1) );
Vec_PtrFree( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2) );
Vec_VecFree( (Vec_Vec_t *)Vec_PtrEntry(vNtk, 3) );
Vec_VecFree( (Vec_Vec_t *)Vec_PtrEntry(vNtk, 4) );
if ( Vec_PtrSize(vNtk) > 5 )
Vec_FltFree( (Vec_Flt_t *)Vec_PtrEntry(vNtk, 5) );
if ( Vec_PtrSize(vNtk) > 6 )
Vec_FltFree( (Vec_Flt_t *)Vec_PtrEntry(vNtk, 6) );
Vec_PtrFree( vNtk );
}
void Cba_PtrFree( Vec_Ptr_t * vDes )
{
Vec_Ptr_t * vNtk; int i;
if ( !vDes ) return;
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Cba_PtrFreeNtk( vNtk );
Vec_PtrFree( vDes );
}
/**Function*************************************************************
Synopsis [Count memory used by Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Cba_PtrMemoryArray( Vec_Ptr_t * vArray )
{
return (int)Vec_PtrMemory(vArray);
}
int Cba_PtrMemoryArrayArray( Vec_Ptr_t * vArrayArray )
{
Vec_Ptr_t * vArray; int i, nBytes = 0;
Vec_PtrForEachEntry( Vec_Ptr_t *, vArrayArray, vArray, i )
nBytes += Cba_PtrMemoryArray(vArray);
return nBytes;
}
int Cba_PtrMemoryNtk( Vec_Ptr_t * vNtk )
{
int nBytes = (int)Vec_PtrMemory(vNtk);
nBytes += Cba_PtrMemoryArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1) );
nBytes += Cba_PtrMemoryArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2) );
nBytes += Cba_PtrMemoryArrayArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) );
nBytes += Cba_PtrMemoryArrayArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
return nBytes;
}
int Cba_PtrMemory( Vec_Ptr_t * vDes )
{
Vec_Ptr_t * vNtk; int i, nBytes = (int)Vec_PtrMemory(vDes);
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
nBytes += Cba_PtrMemoryNtk(vNtk);
return nBytes;
}
/**Function*************************************************************
Synopsis [Dumping Ptr into a BLIF file.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_PtrDumpSignalsBlif( FILE * pFile, Vec_Ptr_t * vSigs, int fSkipLastComma )
{
char * pSig; int i;
Vec_PtrForEachEntry( char *, vSigs, pSig, i )
fprintf( pFile, " %s", pSig );
}
void Cba_PtrDumpBoxBlif( FILE * pFile, Vec_Ptr_t * vBox )
{
char * pName; int i;
fprintf( pFile, ".subckt" );
fprintf( pFile, " %s", (char *)Vec_PtrEntry(vBox, 0) );
//fprintf( pFile, " %s", (char *)Vec_PtrEntry(vBox, 1) ); // do not write intance name in BLIF
Vec_PtrForEachEntryStart( char *, vBox, pName, i, 2 )
fprintf( pFile, " %s=%s", pName, (char *)Vec_PtrEntry(vBox, i+1) ), i++;
fprintf( pFile, "\n" );
}
void Cba_PtrDumpBoxesBlif( FILE * pFile, Vec_Ptr_t * vBoxes )
{
Vec_Ptr_t * vBox; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
Cba_PtrDumpBoxBlif( pFile, vBox );
}
void Cba_PtrDumpModuleBlif( FILE * pFile, Vec_Ptr_t * vNtk )
{
fprintf( pFile, ".model %s\n", (char *)Vec_PtrEntry(vNtk, 0) );
fprintf( pFile, ".inputs" );
Cba_PtrDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), 0 );
fprintf( pFile, "\n" );
fprintf( pFile, ".outputs" );
Cba_PtrDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 );
fprintf( pFile, "\n" );
assert( Vec_PtrSize((Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3)) == 0 ); // no nodes; only boxes
Cba_PtrDumpBoxesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
fprintf( pFile, ".end\n\n" );
}
void Cba_PtrDumpBlif( char * pFileName, Vec_Ptr_t * vDes )
{
FILE * pFile;
Vec_Ptr_t * vNtk; int i;
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL )
{
printf( "Cannot open output file \"%s\".\n", pFileName );
return;
}
fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", (char *)Vec_PtrEntry(vDes, 0), Extra_TimeStamp() );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Cba_PtrDumpModuleBlif( pFile, vNtk );
fclose( pFile );
}
/**Function*************************************************************
Synopsis [Collect elementary gates from the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_ManCollectGateNameOne( Mio_Library_t * pLib, Ptr_ObjType_t Type, word Truth, Vec_Ptr_t * vGateNames )
{
Mio_Gate_t * pGate = Mio_LibraryReadGateByTruth( pLib, Truth );
if ( pGate != NULL )
Vec_PtrWriteEntry( vGateNames, Type, Mio_GateReadName(pGate) );
}
Vec_Ptr_t * Cba_ManCollectGateNamesByTruth( Mio_Library_t * pLib )
{
static word uTruth, uTruths6[3] = {
ABC_CONST(0xAAAAAAAAAAAAAAAA),
ABC_CONST(0xCCCCCCCCCCCCCCCC),
ABC_CONST(0xF0F0F0F0F0F0F0F0),
};
Vec_Ptr_t * vGateNames = Vec_PtrStart( PTR_GATE_UNKNOWN );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_C0, 0, vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_C1, ~(word)0, vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_BUF, uTruths6[0], vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_INV, ~uTruths6[0], vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_AND, (uTruths6[0] & uTruths6[1]), vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_NAND, ~(uTruths6[0] & uTruths6[1]), vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_OR, (uTruths6[0] | uTruths6[1]), vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_NOR, ~(uTruths6[0] | uTruths6[1]), vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_XOR, (uTruths6[0] ^ uTruths6[1]), vGateNames );
Cba_ManCollectGateNameOne( pLib, PTR_GATE_XNOR, ~(uTruths6[0] ^ uTruths6[1]), vGateNames );
return vGateNames;
}
/**Function*************************************************************
Synopsis [This procedure transforms tech-ind Ptr into mapped Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_PtrUpdateBox( Vec_Ptr_t * vBox, Vec_Ptr_t * vGatesNames )
{
Mio_Gate_t * pGate; Mio_Pin_t * pPin; int i = 1;
Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen( Abc_FrameGetGlobalFrame() );
// update gate name
char * pNameNew, * pName = (char *)Vec_PtrEntry(vBox, 0);
if ( !strcmp(pName, "Const0T") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_C0);
else if ( !strcmp(pName, "Const1T") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_C1);
else if ( !strcmp(pName, "BufT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_BUF);
else if ( !strcmp(pName, "InvT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_INV);
else if ( !strcmp(pName, "AndT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_AND);
else if ( !strcmp(pName, "NandT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_NAND);
else if ( !strcmp(pName, "OrT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_OR);
else if ( !strcmp(pName, "NorT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_NOR);
else if ( !strcmp(pName, "XorT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_XOR);
else if ( !strcmp(pName, "XnorT") )
pNameNew = (char *)Vec_PtrEntry(vGatesNames, PTR_GATE_XNOR);
else // user hierarchy
return;
ABC_FREE( pName );
Vec_PtrWriteEntry( vBox, 0, Abc_UtilStrsav(pNameNew) );
// remove instance name
pName = (char *)Vec_PtrEntry(vBox, 1);
ABC_FREE( pName );
Vec_PtrWriteEntry( vBox, 1, NULL );
// update formal input names
pGate = Mio_LibraryReadGateByName( pLib, pNameNew, NULL );
Mio_GateForEachPin( pGate, pPin )
{
pName = (char *)Vec_PtrEntry( vBox, 2 * i );
ABC_FREE( pName );
pNameNew = Mio_PinReadName(pPin);
Vec_PtrWriteEntry( vBox, 2 * i++, Abc_UtilStrsav(pNameNew) );
}
// update output name
pName = (char *)Vec_PtrEntry( vBox, 2 * i );
pNameNew = Mio_GateReadOutName(pGate);
Vec_PtrWriteEntry( vBox, 2 * i++, Abc_UtilStrsav(pNameNew) );
assert( 2 * i == Vec_PtrSize(vBox) );
}
Vec_Ptr_t * Cba_PtrTransformSigs( Vec_Ptr_t * vSig )
{
char * pName; int i;
Vec_Ptr_t * vNew = Vec_PtrAllocExact( Vec_PtrSize(vSig) );
Vec_PtrForEachEntry( char *, vSig, pName, i )
Vec_PtrPush( vNew, Abc_UtilStrsav(pName) );
return vNew;
}
Vec_Ptr_t * Cba_PtrTransformBox( Vec_Ptr_t * vBox, Vec_Ptr_t * vGatesNames )
{
char * pName; int i;
Vec_Ptr_t * vNew = Vec_PtrAllocExact( Vec_PtrSize(vBox) );
Vec_PtrForEachEntry( char *, vBox, pName, i )
Vec_PtrPush( vNew, Abc_UtilStrsav(pName) );
if ( vGatesNames )
Cba_PtrUpdateBox( vNew, vGatesNames );
return vNew;
}
Vec_Ptr_t * Cba_PtrTransformBoxes( Vec_Ptr_t * vBoxes, Vec_Ptr_t * vGatesNames )
{
Vec_Ptr_t * vBox; int i;
Vec_Ptr_t * vNew = Vec_PtrAllocExact( Vec_PtrSize(vBoxes) );
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
Vec_PtrPush( vNew, Cba_PtrTransformBox(vBox, vGatesNames) );
return vNew;
}
Vec_Ptr_t * Cba_PtrTransformNtk( Vec_Ptr_t * vNtk, Vec_Ptr_t * vGatesNames )
{
char * pName = (char *)Vec_PtrEntry(vNtk, 0);
Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
Vec_Ptr_t * vNew = Vec_PtrAllocExact( Vec_PtrSize(vNtk) );
Vec_PtrPush( vNew, Abc_UtilStrsav(pName) );
Vec_PtrPush( vNew, Cba_PtrTransformSigs(vInputs) );
Vec_PtrPush( vNew, Cba_PtrTransformSigs(vOutputs) );
Vec_PtrPush( vNew, Vec_PtrAllocExact(0) );
Vec_PtrPush( vNew, Cba_PtrTransformBoxes(vBoxes, vGatesNames) );
return vNew;
}
Vec_Ptr_t * Cba_PtrTransformTest( Vec_Ptr_t * vDes )
{
Mio_Library_t * pLib;
Vec_Ptr_t * vGatesNames;
Vec_Ptr_t * vNtk, * vNew; int i;
// dump BLIF before transformation
Cba_PtrDumpBlif( "test1.blif", vDes );
if ( Abc_FrameGetGlobalFrame() == NULL )
{
printf( "ABC framework is not started.\n" );
return NULL;
}
pLib = (Mio_Library_t *)Abc_FrameReadLibGen( Abc_FrameGetGlobalFrame() );
if ( pLib == NULL )
{
printf( "Standard cell library is not entered.\n" );
return NULL;
}
vGatesNames = Cba_ManCollectGateNamesByTruth( pLib );
// transform
vNew = Vec_PtrAllocExact( Vec_PtrSize(vDes) );
Vec_PtrPush( vNew, Abc_UtilStrsav((char *)Vec_PtrEntry(vDes, 0)) );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Vec_PtrPush( vNew, Cba_PtrTransformNtk(vNtk, vGatesNames) );
// dump BLIF after transformation
Cba_PtrDumpBlif( "test2.blif", vNew );
Vec_PtrFree( vGatesNames );
return vNew;
}
/**Function*************************************************************
Synopsis [Test the testing procedure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_PtrTransformTestTest()
{
char * pFileName = "c/hie/dump/1/netlist_1.v";
Abc_Ntk_t * pNtk = Io_ReadNetlist( pFileName, Io_ReadFileType(pFileName), 0 );
extern Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk );
Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
Vec_Ptr_t * vNew = Cba_PtrTransformTest( vDes );
Cba_PtrFree( vDes );
Cba_PtrFree( vNew );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaPtrAbc.c 0 → 100644
/**CFile****************************************************************
FileName [cbaPtrAbc.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
Synopsis [Simple interface with external tools.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaPtrAbc.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
#include "base/abc/abc.h"
#include "map/mio/mio.h"
#include "base/main/mainInt.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Node type conversions.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Ptr_HopToType( Abc_Obj_t * pObj )
{
static word uTruth, uTruths6[3] = {
ABC_CONST(0xAAAAAAAAAAAAAAAA),
ABC_CONST(0xCCCCCCCCCCCCCCCC),
ABC_CONST(0xF0F0F0F0F0F0F0F0),
};
assert( Abc_ObjIsNode(pObj) );
uTruth = Hop_ManComputeTruth6( (Hop_Man_t *)Abc_ObjNtk(pObj)->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj) );
/*
if ( uTruth == 0 ) return "CBA_BOX_C0";
if ( uTruth == ~(word)0 ) return "CBA_BOX_C1";
if ( uTruth == uTruths6[0] ) return "CBA_BOX_BUF";
if ( uTruth == ~uTruths6[0] ) return "CBA_BOX_INV";
if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return "CBA_BOX_AND";
if ( uTruth ==~(uTruths6[0] & uTruths6[1]) ) return "CBA_BOX_NAND";
if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return "CBA_BOX_OR";
if ( uTruth ==~(uTruths6[0] | uTruths6[1]) ) return "CBA_BOX_NOR";
if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return "CBA_BOX_XOR";
if ( uTruth ==~(uTruths6[0] ^ uTruths6[1]) ) return "CBA_BOX_XNOR";
*/
if ( uTruth == 0 ) return "Const0T";
if ( uTruth == ~(word)0 ) return "Const1T";
if ( uTruth == uTruths6[0] ) return "BufT";
if ( uTruth == ~uTruths6[0] ) return "InvT";
if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return "AndT";
if ( uTruth ==~(uTruths6[0] & uTruths6[1]) ) return "NandT";
if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return "OrT";
if ( uTruth ==~(uTruths6[0] | uTruths6[1]) ) return "NorT";
if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return "XorT";
if ( uTruth ==~(uTruths6[0] ^ uTruths6[1]) ) return "XnorT";
assert( 0 );
return NULL;
}
/**Function*************************************************************
Synopsis [Create Ptr from Abc_Ntk_t.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Ptr_AbcObjName( Abc_Obj_t * pObj )
{
if ( Abc_ObjIsNet(pObj) || Abc_ObjIsBox(pObj) )
return Abc_ObjName(pObj);
if ( Abc_ObjIsCi(pObj) || Abc_ObjIsNode(pObj) )
return Ptr_AbcObjName(Abc_ObjFanout0(pObj));
if ( Abc_ObjIsCo(pObj) )
return Ptr_AbcObjName(Abc_ObjFanin0(pObj));
assert( 0 );
return NULL;
}
static int Ptr_CheckArray( Vec_Ptr_t * vArray )
{
assert( Vec_PtrSize(vArray) == Vec_PtrCap(vArray) );
return 1;
}
Vec_Ptr_t * Ptr_AbcDeriveNode( Abc_Obj_t * pObj )
{
Abc_Obj_t * pFanin; int i;
Vec_Ptr_t * vNode = Vec_PtrAllocExact( 2 + 2 * (1 + Abc_ObjFaninNum(pObj)) );
assert( Abc_ObjIsNode(pObj) );
if ( Abc_NtkHasAig(pObj->pNtk) )
Vec_PtrPush( vNode, Ptr_HopToType(pObj) );
else if ( Abc_NtkHasSop(pObj->pNtk) )
Vec_PtrPush( vNode, Ptr_SopToTypeName((char *)pObj->pData) );
else assert( 0 );
Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
assert( Abc_ObjFaninNum(pObj) <= 2 );
Abc_ObjForEachFanin( pObj, pFanin, i )
{
Vec_PtrPush( vNode, i ? "r" : "l" );
Vec_PtrPush( vNode, Ptr_AbcObjName(pFanin) );
}
Vec_PtrPush( vNode, "o" );
Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
assert( Ptr_CheckArray(vNode) );
return vNode;
}
Vec_Ptr_t * Ptr_AbcDeriveBox( Abc_Obj_t * pObj )
{
Abc_Obj_t * pNext; int i;
Abc_Ntk_t * pNtk = Abc_ObjModel(pObj);
Vec_Ptr_t * vBox = Vec_PtrAllocExact( 2 + 2 * Abc_ObjFaninNum(pObj) + 2 * Abc_ObjFanoutNum(pObj) );
assert( Abc_ObjIsBox(pObj) );
Vec_PtrPush( vBox, Abc_NtkName(pNtk) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pObj) );
Abc_ObjForEachFanin( pObj, pNext, i )
{
Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPi(pNtk, i)) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
}
Abc_ObjForEachFanout( pObj, pNext, i )
{
Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPo(pNtk, i)) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
}
assert( Ptr_CheckArray(vBox) );
return vBox;
}
Vec_Ptr_t * Ptr_AbcDeriveBoxes( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vBoxes = Vec_PtrAllocExact( Abc_NtkBoxNum(pNtk) + Abc_NtkNodeNum(pNtk) );
Abc_NtkForEachBox( pNtk, pObj, i )
Vec_PtrPush( vBoxes, Ptr_AbcDeriveBox(pObj) );
Abc_NtkForEachNode( pNtk, pObj, i )
Vec_PtrPush( vBoxes, Ptr_AbcDeriveNode(pObj) );
assert( Ptr_CheckArray(vBoxes) );
return vBoxes;
}
Vec_Ptr_t * Ptr_AbcDeriveInputs( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Abc_NtkPiNum(pNtk) );
Abc_NtkForEachPi( pNtk, pObj, i )
Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_AbcDeriveOutputs( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Abc_NtkPoNum(pNtk) );
Abc_NtkForEachPo( pNtk, pObj, i )
Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_AbcDeriveNtk( Abc_Ntk_t * pNtk )
{
Vec_Ptr_t * vNtk = Vec_PtrAllocExact( 5 );
Vec_PtrPush( vNtk, Abc_NtkName(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveInputs(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveOutputs(pNtk) );
Vec_PtrPush( vNtk, Vec_PtrAllocExact(0) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveBoxes(pNtk) );
assert( Ptr_CheckArray(vNtk) );
return vNtk;
}
Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk )
{
Vec_Ptr_t * vDes;
Abc_Ntk_t * pTemp; int i;
vDes = Vec_PtrAllocExact( 1 + Vec_PtrSize(pNtk->pDesign->vModules) );
Vec_PtrPush( vDes, pNtk->pDesign->pName );
Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
Vec_PtrPush( vDes, Ptr_AbcDeriveNtk(pTemp) );
assert( Ptr_CheckArray(vDes) );
return vDes;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ptr_ManExperiment( Abc_Ntk_t * pNtk )
{
abctime clk = Abc_Clock();
char * pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out.blif");
Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
printf( "Converting to Ptr: Memory = %6.3f MB ", 1.0*Cba_PtrMemory(vDes)/(1<<20) );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
Cba_PtrDumpBlif( pFileName, vDes );
printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
Cba_PtrFree( vDes );
}
/**Function*************************************************************
Synopsis [Create Cba_Man_t from tech-ind Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Ptr_NameToType( char * pSop )
{
if ( !strcmp(pSop, "Const0T") ) return CBA_BOX_C0;
if ( !strcmp(pSop, "Const1T") ) return CBA_BOX_C1;
if ( !strcmp(pSop, "BufT") ) return CBA_BOX_BUF;
if ( !strcmp(pSop, "InvT") ) return CBA_BOX_INV;
if ( !strcmp(pSop, "AndT") ) return CBA_BOX_AND;
if ( !strcmp(pSop, "NandT") ) return CBA_BOX_NAND;
if ( !strcmp(pSop, "OrT") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "NorT") ) return CBA_BOX_NOR;
if ( !strcmp(pSop, "XorT") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "XnorT") ) return CBA_BOX_XNOR;
return CBA_OBJ_BOX;
}
int Ptr_ManCountNtk( Vec_Ptr_t * vNtk )
{
Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
Vec_Ptr_t * vNodes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3);
Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
Vec_Ptr_t * vBox; int i, Counter = 0;
assert( Vec_PtrSize(vNodes) == 0 );
Counter += Vec_PtrSize(vInputs);
Counter += Vec_PtrSize(vOutputs);
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
Counter += Vec_PtrSize(vBox)/2;
return Counter;
}
int Cba_BoxCountOutputs( Cba_Ntk_t * pNtk, char * pBoxNtk )
{
int ModuleId = Cba_ManNtkFindId( pNtk->pDesign, pBoxNtk );
if ( ModuleId == -1 )
return 1;
return Cba_NtkPoNumAlloc( Cba_ManNtk(pNtk->pDesign, ModuleId) );
}
int Cba_NtkDeriveFromPtr( Cba_Ntk_t * pNtk, Vec_Ptr_t * vNtk, Vec_Int_t * vMap, Vec_Int_t * vBox2Id )
{
char * pName, * pModuleName = (char *)Vec_PtrEntry(vNtk, 0);
Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4), * vBox;
int i, k, iObj, iTerm, NameId;
// start network with the given name
NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pModuleName, NULL );
assert( Cba_NtkNameId(pNtk) == NameId );
// map driven NameIds into their ObjIds for PIs
Vec_PtrForEachEntry( char *, vInputs, pName, i )
{
NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
if ( Vec_IntGetEntryFull(vMap, NameId) != -1 )
{ printf( "PI with name \"%s\" is not unique module \"%s\".\n", pName, pModuleName ); return 0; }
iObj = Cba_ObjAlloc( pNtk, CBA_OBJ_PI, -1, -1 );
Cba_ObjSetName( pNtk, iObj, NameId );
Vec_IntSetEntryFull( vMap, NameId, iObj );
}
// map driven NameIds into their ObjIds for BOs
Vec_IntClear( vBox2Id );
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
{
char * pBoxNtk = (char *)Vec_PtrEntry(vBox, 0);
char * pBoxName = (char *)Vec_PtrEntry(vBox, 1);
int nOutputs = Cba_BoxCountOutputs( pNtk, pBoxNtk );
int nInputs = Vec_PtrSize(vBox)/2 - nOutputs - 1;
int NtkId = Cba_ManNtkFindId( pNtk->pDesign, pBoxNtk );
assert( Vec_PtrSize(vBox) % 2 == 0 );
assert( nOutputs > 0 && 2*(nOutputs + 1) <= Vec_PtrSize(vBox) );
iObj = Cba_BoxAlloc( pNtk, Ptr_NameToType(pBoxNtk), nInputs, nOutputs, NtkId );
if ( NtkId >= 0 )
Cba_NtkSetHost( Cba_ManNtk(pNtk->pDesign, NtkId), Cba_NtkId(pNtk), iObj );
Cba_ObjSetName( pNtk, iObj, Abc_NamStrFindOrAdd(pNtk->pDesign->pStrs, pBoxName, NULL) );
Cba_BoxForEachBo( pNtk, iObj, iTerm, k )
{
pName = (char *)Vec_PtrEntry( vBox, Vec_PtrSize(vBox) - 2*(nOutputs - k) + 1 );
NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
if ( Vec_IntGetEntryFull(vMap, NameId) != -1 )
{ printf( "Signal \"%s\" has multiple drivers in module \"%s\".\n", pName, pModuleName ); return 0; }
Cba_ObjSetName( pNtk, iTerm, NameId );
Vec_IntSetEntryFull( vMap, NameId, iTerm );
}
Vec_IntPush( vBox2Id, iObj );
}
assert( Vec_IntSize(vBox2Id) == Vec_PtrSize(vBoxes) );
// connect BIs
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
{
iObj = Vec_IntEntry( vBox2Id, i );
Cba_BoxForEachBi( pNtk, iObj, iTerm, k )
{
pName = (char *)Vec_PtrEntry( vBox, 2*(k + 1) + 1 );
NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
if ( Vec_IntGetEntryFull(vMap, NameId) == -1 )
printf( "Signal \"%s\" in not driven in module \"%s\".\n", pName, pModuleName );
Cba_ObjSetFanin( pNtk, iTerm, Vec_IntGetEntryFull(vMap, NameId) );
Cba_ObjSetName( pNtk, iTerm, NameId );
}
}
// connect POs
Vec_PtrForEachEntry( char *, vOutputs, pName, i )
{
NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
if ( Vec_IntGetEntryFull(vMap, NameId) == -1 )
printf( "PO with name \"%s\" in not driven in module \"%s\".\n", pName, pModuleName );
iObj = Cba_ObjAlloc( pNtk, CBA_OBJ_PO, -1, Vec_IntGetEntryFull(vMap, NameId) );
Cba_ObjSetName( pNtk, iObj, NameId );
}
// update map
Cba_NtkForEachCi( pNtk, iObj )
Vec_IntSetEntryFull( vMap, Cba_ObjName(pNtk, iObj), -1 );
// double check
Vec_IntForEachEntry( vMap, iObj, i )
assert( iObj == -1 );
assert( Cba_NtkObjNum(pNtk) == Vec_StrCap(&pNtk->vType) );
return 1;
}
Cba_Man_t * Cba_PtrTransformToCba( Vec_Ptr_t * vDes )
{
char * pName = (char *)Vec_PtrEntry(vDes, 0);
Cba_Man_t * pNew = Cba_ManAlloc( pName, Vec_PtrSize(vDes) - 1 );
Vec_Int_t * vMap = Vec_IntStartFull( 1000 );
Vec_Int_t * vBox2Id = Vec_IntAlloc( 1000 );
// create interfaces
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( pNew, pNtk, i )
{
Vec_Ptr_t * vNtk = (Vec_Ptr_t *)Vec_PtrEntry(vDes, i+1);
Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
int NameId = Abc_NamStrFindOrAdd( pNew->pStrs, (char *)Vec_PtrEntry(vNtk, 0), NULL );
Cba_NtkAlloc( pNtk, NameId, Vec_PtrSize(vInputs), Vec_PtrSize(vOutputs), Ptr_ManCountNtk(vNtk) );
Cba_NtkStartNames( pNtk );
}
// parse the networks
Cba_ManForEachNtk( pNew, pNtk, i )
{
Vec_Ptr_t * vNtk = (Vec_Ptr_t *)Vec_PtrEntry(vDes, i+1);
if ( !Cba_NtkDeriveFromPtr( pNtk, vNtk, vMap, vBox2Id ) )
break;
}
if ( i < Cba_ManNtkNum(pNew) )
Cba_ManFree(pNew), pNew = NULL;
Vec_IntFree( vBox2Id );
Vec_IntFree( vMap );
return pNew;
}
/**Function*************************************************************
Synopsis [Create Ptr from mapped Cba_Man_t.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Ptr_t * Cba_NtkTransformToPtrBox( Cba_Ntk_t * p, int iBox )
{
int i, iTerm, fUser = Cba_ObjIsBoxUser( p, iBox );
Cba_Ntk_t * pBoxNtk = Cba_BoxNtk( p, iBox );
Mio_Library_t * pLib = (Mio_Library_t *)p->pDesign->pMioLib;
Mio_Gate_t * pGate = Mio_LibraryReadGateByName( pLib, Cba_BoxNtkName(p, iBox), NULL );
Vec_Ptr_t * vBox = Vec_PtrAllocExact( Cba_BoxSize(p, iBox) );
Vec_PtrPush( vBox, Cba_BoxNtkName(p, iBox) );
Vec_PtrPush( vBox, Cba_ObjNameStr(p, iBox) );
Cba_BoxForEachBi( p, iBox, iTerm, i )
{
Vec_PtrPush( vBox, fUser ? Cba_ObjNameStr(pBoxNtk, Cba_NtkPi(pBoxNtk, i)) : Mio_GateReadPinName(pGate, i) );
Vec_PtrPush( vBox, Cba_ObjNameStr(p, iTerm) );
}
Cba_BoxForEachBo( p, iBox, iTerm, i )
{
Vec_PtrPush( vBox, fUser ? Cba_ObjNameStr(pBoxNtk, Cba_NtkPo(pBoxNtk, i)) : Mio_GateReadOutName(pGate) );
Vec_PtrPush( vBox, Cba_ObjNameStr(p, iTerm) );
}
assert( Ptr_CheckArray(vBox) );
return vBox;
}
Vec_Ptr_t * Cba_NtkTransformToPtrBoxes( Cba_Ntk_t * p )
{
int iBox;
Vec_Ptr_t * vBoxes = Vec_PtrAllocExact( Cba_NtkBoxNum(p) );
Cba_NtkForEachBox( p, iBox )
Vec_PtrPush( vBoxes, Cba_NtkTransformToPtrBox(p, iBox) );
assert( Ptr_CheckArray(vBoxes) );
return vBoxes;
}
Vec_Ptr_t * Cba_NtkTransformToPtrInputs( Cba_Ntk_t * p )
{
int i, iTerm;
Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Cba_NtkPiNum(p) );
Cba_NtkForEachPi( p, iTerm, i )
Vec_PtrPush( vSigs, Cba_ObjNameStr(p, iTerm) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Cba_NtkTransformToPtrOutputs( Cba_Ntk_t * p )
{
int i, iTerm;
Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Cba_NtkPoNum(p) );
Cba_NtkForEachPo( p, iTerm, i )
Vec_PtrPush( vSigs, Cba_ObjNameStr(p, iTerm) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Cba_NtkTransformToPtr( Cba_Ntk_t * p )
{
Vec_Ptr_t * vNtk = Vec_PtrAllocExact(5);
Vec_PtrPush( vNtk, Cba_NtkName(p) );
Vec_PtrPush( vNtk, Cba_NtkTransformToPtrInputs(p) );
Vec_PtrPush( vNtk, Cba_NtkTransformToPtrOutputs(p) );
Vec_PtrPush( vNtk, Vec_PtrAllocExact(0) );
Vec_PtrPush( vNtk, Cba_NtkTransformToPtrBoxes(p) );
assert( Ptr_CheckArray(vNtk) );
return vNtk;
}
Vec_Ptr_t * Cba_PtrDeriveFromCba( Cba_Man_t * p )
{
Vec_Ptr_t * vDes;
Cba_Ntk_t * pTemp; int i;
if ( p == NULL )
return NULL;
vDes = Vec_PtrAllocExact( 1 + Cba_ManNtkNum(p) );
Vec_PtrPush( vDes, p->pName );
Cba_ManForEachNtk( p, pTemp, i )
Vec_PtrPush( vDes, Cba_NtkTransformToPtr(pTemp) );
assert( Ptr_CheckArray(vDes) );
return vDes;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaReadBlif.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [BLIF parser.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -18,7 +18,6 @@ ...@@ -18,7 +18,6 @@
***********************************************************************/ ***********************************************************************/
#include "cba.h"
#include "cbaPrs.h" #include "cbaPrs.h"
ABC_NAMESPACE_IMPL_START ABC_NAMESPACE_IMPL_START
...@@ -29,21 +28,21 @@ ABC_NAMESPACE_IMPL_START ...@@ -29,21 +28,21 @@ ABC_NAMESPACE_IMPL_START
// BLIF keywords // BLIF keywords
typedef enum { typedef enum {
CBA_BLIF_NONE = 0, // 0: unused PRS_BLIF_NONE = 0, // 0: unused
CBA_BLIF_MODEL, // 1: .model PRS_BLIF_MODEL, // 1: .model
CBA_BLIF_INOUTS, // 2: .inouts PRS_BLIF_INOUTS, // 2: .inouts
CBA_BLIF_INPUTS, // 3: .inputs PRS_BLIF_INPUTS, // 3: .inputs
CBA_BLIF_OUTPUTS, // 4: .outputs PRS_BLIF_OUTPUTS, // 4: .outputs
CBA_BLIF_NAMES, // 5: .names PRS_BLIF_NAMES, // 5: .names
CBA_BLIF_SUBCKT, // 6: .subckt PRS_BLIF_SUBCKT, // 6: .subckt
CBA_BLIF_GATE, // 7: .gate PRS_BLIF_GATE, // 7: .gate
CBA_BLIF_LATCH, // 8: .latch PRS_BLIF_LATCH, // 8: .latch
CBA_BLIF_SHORT, // 9: .short PRS_BLIF_SHORT, // 9: .short
CBA_BLIF_END, // 10: .end PRS_BLIF_END, // 10: .end
CBA_BLIF_UNKNOWN // 11: unknown PRS_BLIF_UNKNOWN // 11: unknown
} Cba_BlifType_t; } Cba_BlifType_t;
const char * s_BlifTypes[CBA_BLIF_UNKNOWN+1] = { const char * s_BlifTypes[PRS_BLIF_UNKNOWN+1] = {
NULL, // 0: unused NULL, // 0: unused
".model", // 1: .model ".model", // 1: .model
".inouts", // 2: .inputs ".inouts", // 2: .inputs
...@@ -58,15 +57,12 @@ const char * s_BlifTypes[CBA_BLIF_UNKNOWN+1] = { ...@@ -58,15 +57,12 @@ const char * s_BlifTypes[CBA_BLIF_UNKNOWN+1] = {
NULL // 11: unknown NULL // 11: unknown
}; };
static inline void Cba_PrsAddBlifDirectives( Cba_Prs_t * p ) static inline void Prs_NtkAddBlifDirectives( Prs_Man_t * p )
{ {
int i; int i;
for ( i = 1; s_BlifTypes[i]; i++ ) for ( i = 1; s_BlifTypes[i]; i++ )
Abc_NamStrFindOrAdd( p->pDesign->pNames, (char *)s_BlifTypes[i], NULL ); Abc_NamStrFindOrAdd( p->pStrs, (char *)s_BlifTypes[i], NULL );
assert( Abc_NamObjNumMax(p->pDesign->pNames) == i ); assert( Abc_NamObjNumMax(p->pStrs) == i );
for ( i = 1; i < CBA_NODE_UNKNOWN; i++ )
Abc_NamStrFindOrAdd( p->pDesign->pFuncs, Ptr_TypeToSop(i), NULL );
assert( Abc_NamObjNumMax(p->pDesign->pFuncs) == i );
} }
...@@ -85,19 +81,19 @@ static inline void Cba_PrsAddBlifDirectives( Cba_Prs_t * p ) ...@@ -85,19 +81,19 @@ static inline void Cba_PrsAddBlifDirectives( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline int Cba_CharIsSpace( char c ) { return c == ' ' || c == '\t' || c == '\r'; } static inline int Prs_CharIsSpace( char c ) { return c == ' ' || c == '\t' || c == '\r'; }
static inline int Cba_CharIsStop( char c ) { return c == '#' || c == '\\' || c == '\n' || c == '='; } static inline int Prs_CharIsStop( char c ) { return c == '#' || c == '\\' || c == '\n' || c == '='; }
static inline int Cba_CharIsLit( char c ) { return c == '0' || c == '1' || c == '-'; } static inline int Prs_CharIsLit( char c ) { return c == '0' || c == '1' || c == '-'; }
static inline int Cba_PrsIsSpace( Cba_Prs_t * p ) { return Cba_CharIsSpace(*p->pCur); } static inline int Prs_ManIsSpace( Prs_Man_t * p ) { return Prs_CharIsSpace(*p->pCur); }
static inline int Cba_PrsIsStop( Cba_Prs_t * p ) { return Cba_CharIsStop(*p->pCur); } static inline int Prs_ManIsStop( Prs_Man_t * p ) { return Prs_CharIsStop(*p->pCur); }
static inline int Cba_PrsIsLit( Cba_Prs_t * p ) { return Cba_CharIsLit(*p->pCur); } static inline int Prs_ManIsLit( Prs_Man_t * p ) { return Prs_CharIsLit(*p->pCur); }
static inline int Cba_PrsIsChar( Cba_Prs_t * p, char c ) { return *p->pCur == c; } static inline int Prs_ManIsChar( Prs_Man_t * p, char c ) { return *p->pCur == c; }
static inline int Cba_PrsIsChar2( Cba_Prs_t * p, char c ) { return *p->pCur++ == c; } static inline int Prs_ManIsChar2( Prs_Man_t * p, char c ) { return *p->pCur++ == c; }
static inline void Cba_PrsSkip( Cba_Prs_t * p ) { p->pCur++; } static inline void Prs_ManSkip( Prs_Man_t * p ) { p->pCur++; }
static inline char Cba_PrsSkip2( Cba_Prs_t * p ) { return *p->pCur++; } static inline char Prs_ManSkip2( Prs_Man_t * p ) { return *p->pCur++; }
/**Function************************************************************* /**Function*************************************************************
...@@ -111,79 +107,77 @@ static inline char Cba_PrsSkip2( Cba_Prs_t * p ) { return *p->pCur++; ...@@ -111,79 +107,77 @@ static inline char Cba_PrsSkip2( Cba_Prs_t * p ) { return *p->pCur++;
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline void Cba_PrsSkipToChar( Cba_Prs_t * p, char c ) static inline void Prs_ManSkipToChar( Prs_Man_t * p, char c )
{ {
while ( !Cba_PrsIsChar(p, c) ) while ( !Prs_ManIsChar(p, c) )
Cba_PrsSkip(p); Prs_ManSkip(p);
} }
static inline void Cba_PrsSkipSpaces( Cba_Prs_t * p ) static inline void Prs_ManSkipSpaces( Prs_Man_t * p )
{ {
while ( 1 ) while ( 1 )
{ {
while ( Cba_PrsIsSpace(p) ) while ( Prs_ManIsSpace(p) )
Cba_PrsSkip(p); Prs_ManSkip(p);
if ( Cba_PrsIsChar(p, '\\') ) if ( Prs_ManIsChar(p, '\\') )
{ {
Cba_PrsSkipToChar( p, '\n' ); Prs_ManSkipToChar( p, '\n' );
Cba_PrsSkip(p); Prs_ManSkip(p);
continue; continue;
} }
if ( Cba_PrsIsChar(p, '#') ) if ( Prs_ManIsChar(p, '#') )
Cba_PrsSkipToChar( p, '\n' ); Prs_ManSkipToChar( p, '\n' );
break; break;
} }
assert( !Cba_PrsIsSpace(p) ); assert( !Prs_ManIsSpace(p) );
} }
static inline int Cba_PrsReadName( Cba_Prs_t * p ) static inline int Prs_ManReadName( Prs_Man_t * p )
{ {
char * pStart; char * pStart;
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( Cba_PrsIsChar(p, '\n') ) if ( Prs_ManIsChar(p, '\n') )
return 0; return 0;
pStart = p->pCur; pStart = p->pCur;
while ( !Cba_PrsIsSpace(p) && !Cba_PrsIsStop(p) ) while ( !Prs_ManIsSpace(p) && !Prs_ManIsStop(p) )
Cba_PrsSkip(p); Prs_ManSkip(p);
if ( pStart == p->pCur ) if ( pStart == p->pCur )
return 0; return 0;
return Abc_NamStrFindOrAddLim( p->pDesign->pNames, pStart, p->pCur, NULL ); return Abc_NamStrFindOrAddLim( p->pStrs, pStart, p->pCur, NULL );
} }
static inline int Cba_PrsReadList( Cba_Prs_t * p ) static inline int Prs_ManReadList( Prs_Man_t * p )
{ {
int iToken; int iToken;
Vec_IntClear( &p->vTemp ); Vec_IntClear( &p->vTemp );
while ( (iToken = Cba_PrsReadName(p)) ) while ( (iToken = Prs_ManReadName(p)) )
Vec_IntPush( &p->vTemp, iToken ); Vec_IntPush( &p->vTemp, iToken );
if ( Vec_IntSize(&p->vTemp) == 0 ) return Cba_PrsErrorSet(p, "Signal list is empty.", 1); if ( Vec_IntSize(&p->vTemp) == 0 ) return Prs_ManErrorSet(p, "Signal list is empty.", 1);
return 0; return 0;
} }
static inline int Cba_PrsReadList2( Cba_Prs_t * p ) static inline int Prs_ManReadList2( Prs_Man_t * p )
{ {
int iToken; int iToken;
Vec_IntFill( &p->vTemp, 1, -1 ); Vec_IntClear( &p->vTemp );
while ( (iToken = Cba_PrsReadName(p)) ) while ( (iToken = Prs_ManReadName(p)) )
Vec_IntPush( &p->vTemp, iToken ); Vec_IntPushTwo( &p->vTemp, 0, iToken );
iToken = Vec_IntPop(&p->vTemp); if ( Vec_IntSize(&p->vTemp) == 0 ) return Prs_ManErrorSet(p, "Signal list is empty.", 1);
if ( Vec_IntSize(&p->vTemp) == 0 ) return Cba_PrsErrorSet(p, "Signal list is empty.", 1);
Vec_IntWriteEntry( &p->vTemp, 0, iToken );
return 0; return 0;
} }
static inline int Cba_PrsReadList3( Cba_Prs_t * p ) static inline int Prs_ManReadList3( Prs_Man_t * p )
{ {
Vec_IntClear( &p->vTemp ); Vec_IntClear( &p->vTemp );
while ( !Cba_PrsIsChar(p, '\n') ) while ( !Prs_ManIsChar(p, '\n') )
{ {
int iToken = Cba_PrsReadName(p); int iToken = Prs_ManReadName(p);
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read formal name.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read formal name.", 1);
Vec_IntPush( &p->vTemp, iToken ); Vec_IntPush( &p->vTemp, iToken );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( !Cba_PrsIsChar2(p, '=') ) return Cba_PrsErrorSet(p, "Cannot find symbol \"=\".", 1); if ( !Prs_ManIsChar2(p, '=') ) return Prs_ManErrorSet(p, "Cannot find symbol \"=\".", 1);
iToken = Cba_PrsReadName(p); iToken = Prs_ManReadName(p);
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read actual name.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read actual name.", 1);
Vec_IntPush( &p->vTemp, iToken ); Vec_IntPush( &p->vTemp, iToken );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
} }
if ( Vec_IntSize(&p->vTemp) == 0 ) return Cba_PrsErrorSet(p, "Cannot read a list of formal/actual names.", 1); if ( Vec_IntSize(&p->vTemp) == 0 ) return Prs_ManErrorSet(p, "Cannot read a list of formal/actual names.", 1);
if ( Vec_IntSize(&p->vTemp) % 2 ) return Cba_PrsErrorSet(p, "The number of formal/actual names is not even.", 1); if ( Vec_IntSize(&p->vTemp) % 2 ) return Prs_ManErrorSet(p, "The number of formal/actual names is not even.", 1);
return 0; return 0;
} }
...@@ -198,38 +192,39 @@ static inline int Cba_PrsReadList3( Cba_Prs_t * p ) ...@@ -198,38 +192,39 @@ static inline int Cba_PrsReadList3( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline int Cba_PrsReadCube( Cba_Prs_t * p ) static inline int Prs_ManReadCube( Prs_Man_t * p )
{ {
assert( Cba_PrsIsLit(p) ); assert( Prs_ManIsLit(p) );
while ( Cba_PrsIsLit(p) ) while ( Prs_ManIsLit(p) )
Vec_StrPush( &p->vCover, Cba_PrsSkip2(p) ); Vec_StrPush( &p->vCover, Prs_ManSkip2(p) );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( Cba_PrsIsChar(p, '\n') ) if ( Prs_ManIsChar(p, '\n') )
{ {
if ( Vec_StrSize(&p->vCover) != 1 ) return Cba_PrsErrorSet(p, "Cannot read cube.", 1); if ( Vec_StrSize(&p->vCover) != 1 ) return Prs_ManErrorSet(p, "Cannot read cube.", 1);
// fix single literal cube by adding space // fix single literal cube by adding space
Vec_StrPush( &p->vCover, Vec_StrEntry(&p->vCover,0) ); Vec_StrPush( &p->vCover, Vec_StrEntry(&p->vCover,0) );
Vec_StrWriteEntry( &p->vCover, 0, ' ' ); Vec_StrWriteEntry( &p->vCover, 0, ' ' );
Vec_StrPush( &p->vCover, '\n' ); Vec_StrPush( &p->vCover, '\n' );
return 0; return 0;
} }
if ( !Cba_PrsIsLit(p) ) return Cba_PrsErrorSet(p, "Cannot read output literal.", 1); if ( !Prs_ManIsLit(p) ) return Prs_ManErrorSet(p, "Cannot read output literal.", 1);
Vec_StrPush( &p->vCover, ' ' ); Vec_StrPush( &p->vCover, ' ' );
Vec_StrPush( &p->vCover, Cba_PrsSkip2(p) ); Vec_StrPush( &p->vCover, Prs_ManSkip2(p) );
Vec_StrPush( &p->vCover, '\n' ); Vec_StrPush( &p->vCover, '\n' );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( !Cba_PrsIsChar(p, '\n') ) return Cba_PrsErrorSet(p, "Cannot read end of cube.", 1); if ( !Prs_ManIsChar(p, '\n') ) return Prs_ManErrorSet(p, "Cannot read end of cube.", 1);
return 0; return 0;
} }
static inline void Cba_PrsSaveCover( Cba_Prs_t * p ) static inline void Prs_ManSaveCover( Prs_Man_t * p )
{ {
int iToken; int iToken;
assert( Vec_StrSize(&p->vCover) > 0 ); assert( Vec_StrSize(&p->vCover) > 0 );
Vec_StrPush( &p->vCover, '\0' ); Vec_StrPush( &p->vCover, '\0' );
iToken = Abc_NamStrFindOrAdd( p->pDesign->pFuncs, Vec_StrArray(&p->vCover), NULL ); iToken = Abc_NamStrFindOrAdd( p->pStrs, Vec_StrArray(&p->vCover), NULL );
assert( Vec_IntEntryLast(&p->vFuncsCur) == 1 );
Vec_IntWriteEntry( &p->vFuncsCur, Vec_IntSize(&p->vFuncsCur)-1, iToken );
Vec_StrClear( &p->vCover ); Vec_StrClear( &p->vCover );
// set the cover to the module of this box
assert( Prs_BoxNtk(p->pNtk, Prs_NtkBoxNum(p->pNtk)-1) == 1 ); // default const 0
Prs_BoxSetNtk( p->pNtk, Prs_NtkBoxNum(p->pNtk)-1, iToken );
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -243,144 +238,140 @@ static inline void Cba_PrsSaveCover( Cba_Prs_t * p ) ...@@ -243,144 +238,140 @@ static inline void Cba_PrsSaveCover( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline int Cba_PrsReadInouts( Cba_Prs_t * p ) static inline int Prs_ManReadInouts( Prs_Man_t * p )
{ {
if ( Cba_PrsReadList(p) ) return 1; if ( Prs_ManReadList(p) ) return 1;
Vec_IntAppend( &p->vInoutsCur, &p->vTemp ); Vec_IntAppend( &p->pNtk->vInouts, &p->vTemp );
return 0; return 0;
} }
static inline int Cba_PrsReadInputs( Cba_Prs_t * p ) static inline int Prs_ManReadInputs( Prs_Man_t * p )
{ {
if ( Cba_PrsReadList(p) ) return 1; if ( Prs_ManReadList(p) ) return 1;
Vec_IntAppend( &p->vInputsCur, &p->vTemp ); Vec_IntAppend( &p->pNtk->vInputs, &p->vTemp );
return 0; return 0;
} }
static inline int Cba_PrsReadOutputs( Cba_Prs_t * p ) static inline int Prs_ManReadOutputs( Prs_Man_t * p )
{ {
if ( Cba_PrsReadList(p) ) return 1; if ( Prs_ManReadList(p) ) return 1;
Vec_IntAppend( &p->vOutputsCur, &p->vTemp ); Vec_IntAppend( &p->pNtk->vOutputs, &p->vTemp );
return 0; return 0;
} }
static inline int Cba_PrsReadNode( Cba_Prs_t * p ) static inline int Prs_ManReadNode( Prs_Man_t * p )
{ {
if ( Cba_PrsReadList2(p) ) return 1; if ( Prs_ManReadList2(p) ) return 1;
// save results // save results
Vec_IntPush( &p->vTypesCur, CBA_OBJ_NODE ); Prs_NtkAddBox( p->pNtk, 1, 0, &p->vTemp ); // default const 0 function
Vec_IntPush( &p->vFuncsCur, 1 ); // default const 0 function
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) );
return 0; return 0;
} }
static inline int Cba_PrsReadBox( Cba_Prs_t * p, int fGate ) static inline int Prs_ManReadBox( Prs_Man_t * p, int fGate )
{ {
int iToken = Cba_PrsReadName(p); int iToken = Prs_ManReadName(p);
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read model name.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read model name.", 1);
if ( Cba_PrsReadList3(p) ) return 1; if ( Prs_ManReadList3(p) ) return 1;
// save results // save results
Vec_IntPush( &p->vTypesCur, CBA_OBJ_BOX ); Prs_NtkAddBox( p->pNtk, iToken, 0, &p->vTemp );
Vec_IntPush( &p->vFuncsCur, iToken ); if ( fGate ) p->pNtk->fMapped = 1;
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) );
return 0; return 0;
} }
static inline int Cba_PrsReadLatch( Cba_Prs_t * p ) static inline int Prs_ManReadLatch( Prs_Man_t * p )
{ {
int iToken = Cba_PrsReadName(p); int iToken = Prs_ManReadName(p);
Vec_IntFill( &p->vTemp, 2, -1 ); Vec_IntClear( &p->vTemp );
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read latch input.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read latch input.", 1);
Vec_IntWriteEntry( &p->vTemp, 1, iToken ); Vec_IntWriteEntry( &p->vTemp, 1, iToken );
iToken = Cba_PrsReadName(p); iToken = Prs_ManReadName(p);
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read latch output.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read latch output.", 1);
Vec_IntWriteEntry( &p->vTemp, 0, iToken ); Vec_IntWriteEntry( &p->vTemp, 0, iToken );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( Cba_PrsIsChar(p, '0') ) if ( Prs_ManIsChar(p, '0') )
iToken = 0; iToken = 0;
else if ( Cba_PrsIsChar(p, '1') ) else if ( Prs_ManIsChar(p, '1') )
iToken = 1; iToken = 1;
else else
iToken = 2; iToken = 2;
Cba_PrsSkipToChar( p, '\n' ); Prs_ManSkipToChar( p, '\n' );
// save results // save results
Vec_IntPush( &p->vTypesCur, CBA_OBJ_LATCH ); Prs_NtkAddBox( p->pNtk, -1, iToken, &p->vTemp ); // -1 stands for latch
Vec_IntPush( &p->vFuncsCur, iToken );
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) );
return 0; return 0;
} }
static inline int Cba_PrsReadShort( Cba_Prs_t * p ) static inline int Prs_ManReadShort( Prs_Man_t * p )
{ {
int iToken = Cba_PrsReadName(p); int iToken = Prs_ManReadName(p);
Vec_IntFill( &p->vTemp, 2, -1 ); Vec_IntClear( &p->vTemp );
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read .short input.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read .short input.", 1);
Vec_IntWriteEntry( &p->vTemp, 1, iToken ); Vec_IntWriteEntry( &p->vTemp, 1, iToken );
iToken = Cba_PrsReadName(p); iToken = Prs_ManReadName(p);
if ( iToken == 0 ) return Cba_PrsErrorSet(p, "Cannot read .short output.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read .short output.", 1);
Vec_IntWriteEntry( &p->vTemp, 0, iToken ); Vec_IntWriteEntry( &p->vTemp, 0, iToken );
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( !Cba_PrsIsChar(p, '\n') ) return Cba_PrsErrorSet(p, "Trailing symbols on .short line.", 1); if ( !Prs_ManIsChar(p, '\n') ) return Prs_ManErrorSet(p, "Trailing symbols on .short line.", 1);
// save results // save results
Vec_IntPush( &p->vTypesCur, CBA_OBJ_NODE ); iToken = Abc_NamStrFindOrAdd( p->pStrs, "1 1\n", NULL );
Vec_IntPush( &p->vFuncsCur, 2 ); // default buffer function Prs_NtkAddBox( p->pNtk, iToken, 0, &p->vTemp );
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) );
return 0; return 0;
} }
static inline int Cba_PrsReadModel( Cba_Prs_t * p ) static inline int Prs_ManReadModel( Prs_Man_t * p )
{ {
if ( p->iModuleName > 0 ) return Cba_PrsErrorSet(p, "Parsing previous model is unfinished.", 1); int iToken;
p->iModuleName = Cba_PrsReadName(p); if ( p->pNtk != NULL ) return Prs_ManErrorSet(p, "Parsing previous model is unfinished.", 1);
Cba_PrsSkipSpaces( p ); iToken = Prs_ManReadName(p);
if ( !Cba_PrsIsChar(p, '\n') ) return Cba_PrsErrorSet(p, "Trailing symbols on .model line.", 1); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read model name.", 1);
Prs_ManInitializeNtk( p, iToken, 0 );
Prs_ManSkipSpaces( p );
if ( !Prs_ManIsChar(p, '\n') ) return Prs_ManErrorSet(p, "Trailing symbols on .model line.", 1);
return 0; return 0;
} }
static inline int Cba_PrsReadEnd( Cba_Prs_t * p ) static inline int Prs_ManReadEnd( Prs_Man_t * p )
{ {
if ( p->iModuleName == 0 ) return Cba_PrsErrorSet(p, "Directive .end without .model.", 1); if ( p->pNtk == 0 ) return Prs_ManErrorSet(p, "Directive .end without .model.", 1);
//printf( "Saving model \"%s\".\n", Abc_NamStr(p->pDesign->pNames, p->iModuleName) ); //printf( "Saving model \"%s\".\n", Abc_NamStr(p->pStrs, p->iModuleName) );
Cba_PrsAddCurrentModel( p, p->iModuleName ); Prs_ManFinalizeNtk( p );
p->iModuleName = 0; Prs_ManSkipSpaces( p );
Cba_PrsSkipSpaces( p ); if ( !Prs_ManIsChar(p, '\n') ) return Prs_ManErrorSet(p, "Trailing symbols on .end line.", 1);
if ( !Cba_PrsIsChar(p, '\n') ) return Cba_PrsErrorSet(p, "Trailing symbols on .end line.", 1);
return 0; return 0;
} }
static inline int Cba_PrsReadDirective( Cba_Prs_t * p ) static inline int Prs_ManReadDirective( Prs_Man_t * p )
{ {
int iToken; int iToken;
if ( !Cba_PrsIsChar(p, '.') ) if ( !Prs_ManIsChar(p, '.') )
return Cba_PrsReadCube( p ); return Prs_ManReadCube( p );
if ( Vec_StrSize(&p->vCover) > 0 ) // SOP was specified for the previous node if ( Vec_StrSize(&p->vCover) > 0 ) // SOP was specified for the previous node
Cba_PrsSaveCover( p ); Prs_ManSaveCover( p );
iToken = Cba_PrsReadName( p ); iToken = Prs_ManReadName( p );
if ( iToken == CBA_BLIF_MODEL ) if ( iToken == PRS_BLIF_MODEL )
return Cba_PrsReadModel( p ); return Prs_ManReadModel( p );
if ( iToken == CBA_BLIF_INOUTS ) if ( iToken == PRS_BLIF_INOUTS )
return Cba_PrsReadInouts( p ); return Prs_ManReadInouts( p );
if ( iToken == CBA_BLIF_INPUTS ) if ( iToken == PRS_BLIF_INPUTS )
return Cba_PrsReadInputs( p ); return Prs_ManReadInputs( p );
if ( iToken == CBA_BLIF_OUTPUTS ) if ( iToken == PRS_BLIF_OUTPUTS )
return Cba_PrsReadOutputs( p ); return Prs_ManReadOutputs( p );
if ( iToken == CBA_BLIF_NAMES ) if ( iToken == PRS_BLIF_NAMES )
return Cba_PrsReadNode( p ); return Prs_ManReadNode( p );
if ( iToken == CBA_BLIF_SUBCKT ) if ( iToken == PRS_BLIF_SUBCKT )
return Cba_PrsReadBox( p, 0 ); return Prs_ManReadBox( p, 0 );
if ( iToken == CBA_BLIF_GATE ) if ( iToken == PRS_BLIF_GATE )
return Cba_PrsReadBox( p, 1 ); return Prs_ManReadBox( p, 1 );
if ( iToken == CBA_BLIF_LATCH ) if ( iToken == PRS_BLIF_LATCH )
return Cba_PrsReadLatch( p ); return Prs_ManReadLatch( p );
if ( iToken == CBA_BLIF_SHORT ) if ( iToken == PRS_BLIF_SHORT )
return Cba_PrsReadShort( p ); return Prs_ManReadShort( p );
if ( iToken == CBA_BLIF_END ) if ( iToken == PRS_BLIF_END )
return Cba_PrsReadEnd( p ); return Prs_ManReadEnd( p );
printf( "Cannot read directive \"%s\".\n", Abc_NamStr(p->pDesign->pNames, iToken) ); printf( "Cannot read directive \"%s\".\n", Abc_NamStr(p->pStrs, iToken) );
return 1; return 1;
} }
static inline int Cba_PrsReadLines( Cba_Prs_t * p ) static inline int Prs_ManReadLines( Prs_Man_t * p )
{ {
while ( p->pCur[1] != '\0' ) while ( p->pCur[1] != '\0' )
{ {
assert( Cba_PrsIsChar(p, '\n') ); assert( Prs_ManIsChar(p, '\n') );
Cba_PrsSkip(p); Prs_ManSkip(p);
Cba_PrsSkipSpaces( p ); Prs_ManSkipSpaces( p );
if ( Cba_PrsIsChar(p, '\n') ) if ( Prs_ManIsChar(p, '\n') )
continue; continue;
if ( Cba_PrsReadDirective(p) ) if ( Prs_ManReadDirective(p) )
return 1; return 1;
} }
return 0; return 0;
...@@ -397,19 +388,18 @@ static inline int Cba_PrsReadLines( Cba_Prs_t * p ) ...@@ -397,19 +388,18 @@ static inline int Cba_PrsReadLines( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
Cba_Man_t * Cba_PrsReadBlif( char * pFileName ) Vec_Ptr_t * Prs_ManReadBlif( char * pFileName )
{ {
Cba_Man_t * pDesign = NULL; Vec_Ptr_t * vPrs = NULL;
Cba_Prs_t * p = Cba_PrsAlloc( pFileName ); Prs_Man_t * p = Prs_ManAlloc( pFileName );
if ( p == NULL ) if ( p == NULL )
return NULL; return NULL;
Cba_PrsAddBlifDirectives( p ); Prs_NtkAddBlifDirectives( p );
Cba_PrsReadLines( p ); Prs_ManReadLines( p );
if ( Cba_PrsErrorPrint(p) ) if ( Prs_ManErrorPrint(p) )
ABC_SWAP( Cba_Man_t *, pDesign, p->pDesign ); ABC_SWAP( Vec_Ptr_t *, vPrs, p->vNtks );
Cba_PrsFree( p ); Prs_ManFree( p );
Cba_PrsRemapBoxModels( pDesign ); return vPrs;
return pDesign;
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -423,22 +413,22 @@ Cba_Man_t * Cba_PrsReadBlif( char * pFileName ) ...@@ -423,22 +413,22 @@ Cba_Man_t * Cba_PrsReadBlif( char * pFileName )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Cba_PrsReadBlifTest( char * pFileName ) void Prs_ManReadBlifTest()
{ {
abctime clk = Abc_Clock(); abctime clk = Abc_Clock();
extern void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * pDes ); extern void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * vPrs );
Cba_Man_t * p = Cba_PrsReadBlif( "aga/ray/ray_hie_oper.blif" ); // Vec_Ptr_t * vPrs = Prs_ManReadBlif( "aga/ray/ray_hie_oper.blif" );
if ( !p ) return; Vec_Ptr_t * vPrs = Prs_ManReadBlif( "c/hie/dump/1/netlist_1_out8.blif" );
printf( "Finished reading %d networks. ", Cba_ManNtkNum(p) ); if ( !vPrs ) return;
printf( "NameIDs = %d. ", Abc_NamObjNumMax(p->pNames) ); printf( "Finished reading %d networks. ", Vec_PtrSize(vPrs) );
printf( "Memory = %.2f MB. ", 1.0*Cba_ManMemory(p)/(1<<20) ); printf( "NameIDs = %d. ", Abc_NamObjNumMax(Prs_ManRoot(vPrs)->pStrs) );
printf( "Memory = %.2f MB. ", 1.0*Prs_ManMemory(vPrs)/(1<<20) );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
// Abc_NamPrint( p->pDesign->pNames ); // Abc_NamPrint( p->pStrs );
Cba_PrsWriteBlif( "aga/ray/ray_hie_oper_out.blif", p ); Prs_ManWriteBlif( "c/hie/dump/1/netlist_1_out8_out.blif", vPrs );
Cba_ManFree( p ); Prs_ManVecFree( vPrs );
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaReadVer.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [BLIF writer.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -29,23 +29,23 @@ ABC_NAMESPACE_IMPL_START ...@@ -29,23 +29,23 @@ ABC_NAMESPACE_IMPL_START
// Verilog keywords // Verilog keywords
typedef enum { typedef enum {
CBA_VER_NONE = 0, // 0: unused PRS_VER_NONE = 0, // 0: unused
CBA_VER_MODULE, // 1: module PRS_VER_MODULE, // 1: module
CBA_VER_INOUT, // 2: inout PRS_VER_INOUT, // 2: inout
CBA_VER_INPUT, // 3: input PRS_VER_INPUT, // 3: input
CBA_VER_OUTPUT, // 4: output PRS_VER_OUTPUT, // 4: output
CBA_VER_WIRE, // 5: wire PRS_VER_WIRE, // 5: wire
CBA_VER_ASSIGN, // 6: assign PRS_VER_ASSIGN, // 6: assign
CBA_VER_REG, // 7: reg PRS_VER_REG, // 7: reg
CBA_VER_ALWAYS, // 8: always PRS_VER_ALWAYS, // 8: always
CBA_VER_DEFPARAM, // 9: always PRS_VER_DEFPARAM, // 9: always
CBA_VER_BEGIN, // 10: begin PRS_VER_BEGIN, // 10: begin
CBA_VER_END, // 11: end PRS_VER_END, // 11: end
CBA_VER_ENDMODULE, // 12: endmodule PRS_VER_ENDMODULE, // 12: endmodule
CBA_VER_UNKNOWN // 13: unknown PRS_VER_UNKNOWN // 13: unknown
} Cba_VerType_t; } Cba_VerType_t;
const char * s_VerTypes[CBA_VER_UNKNOWN+1] = { const char * s_VerTypes[PRS_VER_UNKNOWN+1] = {
NULL, // 0: unused NULL, // 0: unused
"module", // 1: module "module", // 1: module
"inout", // 2: inout "inout", // 2: inout
...@@ -62,27 +62,27 @@ const char * s_VerTypes[CBA_VER_UNKNOWN+1] = { ...@@ -62,27 +62,27 @@ const char * s_VerTypes[CBA_VER_UNKNOWN+1] = {
NULL // 13: unknown NULL // 13: unknown
}; };
static inline void Cba_PrsAddVerilogDirectives( Cba_Prs_t * p ) static inline void Prs_NtkAddVerilogDirectives( Prs_Man_t * p )
{ {
int i; int i;
for ( i = 1; s_VerTypes[i]; i++ ) for ( i = 1; s_VerTypes[i]; i++ )
Abc_NamStrFindOrAdd( p->pDesign->pNames, (char *)s_VerTypes[i], NULL ); Abc_NamStrFindOrAdd( p->pStrs, (char *)s_VerTypes[i], NULL );
assert( Abc_NamObjNumMax(p->pDesign->pNames) == i ); assert( Abc_NamObjNumMax(p->pStrs) == i );
} }
// character recognition // character recognition
static inline int Cba_IsSpace( char c ) { return (c == ' ' || c == '\t' || c == '\r' || c == '\n'); } static inline int Prs_CharIsSpace( char c ) { return (c == ' ' || c == '\t' || c == '\r' || c == '\n'); }
static inline int Cba_IsDigit( char c ) { return (c >= '0' && c <= '9'); } static inline int Prs_CharIsDigit( char c ) { return (c >= '0' && c <= '9'); }
static inline int Cba_IsDigitB( char c ) { return (c == '0' || c == '1' || c == 'x' || c == 'z'); } static inline int Prs_CharIsDigitB( char c ) { return (c == '0' || c == '1' || c == 'x' || c == 'z'); }
static inline int Cba_IsDigitH( char c ) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); } static inline int Prs_CharIsDigitH( char c ) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }
static inline int Cba_IsChar( char c ) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } static inline int Prs_CharIsChar( char c ) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); }
static inline int Cba_IsSymb1( char c ) { return Cba_IsChar(c) || c == '_'; } static inline int Prs_CharIsSymb1( char c ) { return Prs_CharIsChar(c) || c == '_'; }
static inline int Cba_IsSymb2( char c ) { return Cba_IsSymb1(c) || Cba_IsDigit(c) || c == '$'; } static inline int Prs_CharIsSymb2( char c ) { return Prs_CharIsSymb1(c) || Prs_CharIsDigit(c) || c == '$'; }
static inline int Cba_PrsIsChar( Cba_Prs_t * p, char c ) { return p->pCur[0] == c; } static inline int Prs_ManIsChar( Prs_Man_t * p, char c ) { return p->pCur[0] == c; }
static inline int Cba_PrsIsChar1( Cba_Prs_t * p, char c ) { return p->pCur[1] == c; } static inline int Prs_ManIsChar1( Prs_Man_t * p, char c ) { return p->pCur[1] == c; }
static inline int Cba_PrsIsDigit( Cba_Prs_t * p ) { return Cba_IsDigit(*p->pCur); } static inline int Prs_ManIsDigit( Prs_Man_t * p ) { return Prs_CharIsDigit(*p->pCur); }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS /// /// FUNCTION DEFINITIONS ///
...@@ -102,43 +102,88 @@ static inline int Cba_PrsIsDigit( Cba_Prs_t * p ) { return Cba_IsDigit ...@@ -102,43 +102,88 @@ static inline int Cba_PrsIsDigit( Cba_Prs_t * p ) { return Cba_IsDigit
// collect predefined modules names // collect predefined modules names
const char * s_KnownModules[100] = { const char * s_KnownModules[100] = {
NULL, // 0: unused NULL, // CBA_OBJ_NONE = 0, // 0: unused
"const", // 1: constant NULL, // CBA_OBJ_PI, // 1: input
"buf", // 2: buffer NULL, // CBA_OBJ_PO, // 2: output
"not", // 3: inverter NULL, // CBA_OBJ_BI, // 3: box input
"and", // 4: AND NULL, // CBA_OBJ_BO, // 4: box output
"nand", // 5: OR NULL, // CBA_OBJ_BOX, // 5: box
"or", // 6: XOR
"nor", // 7: NAND "const0", // CBA_BOX_C0,
"xor", // 8: NOR "const1", // CBA_BOX_C1,
"xnor", // 9: .XNOR "constX", // CBA_BOX_CX,
"mux", // 10: MUX "constZ", // CBA_BOX_CZ,
"maj", // 11: MAJ "buf", // CBA_BOX_BUF,
"not", // CBA_BOX_INV,
"and", // CBA_BOX_AND,
"nand", // CBA_BOX_NAND,
"or", // CBA_BOX_OR,
"nor", // CBA_BOX_NOR,
"xor", // CBA_BOX_XOR,
"xnor", // CBA_BOX_XNOR,
"sharp", // CBA_BOX_SHARP,
"mux", // CBA_BOX_MUX,
"maj", // CBA_BOX_MAJ,
"VERIFIC_", "VERIFIC_",
"wide_",
"reduce_",
"equal_",
"not_equal_",
"sub_",
"add_", "add_",
"mult_", "mult_",
"mux_", "div_",
"mod_",
"rem_",
"shift_left_",
"shift_right_",
"rotate_left_",
"rotate_right_",
"reduce_and_",
"reduce_or_",
"reduce_xor_",
"reduce_nand_",
"reduce_nor_",
"reduce_xnor_",
"LessThan_",
"Mux_", "Mux_",
"Select_", "Select_",
"Decoder_", "Decoder_",
"LessThan_", "EnabledDecoder_",
"PrioSelect_",
"DualPortRam_",
"ReadPort_", "ReadPort_",
"WritePort_", "WritePort_",
"ClockedWritePort_", "ClockedWritePort_",
"lut",
"and_",
"or_",
"xor_",
"nand_",
"nor_",
"xnor_",
"buf_",
"inv_",
"tri_",
"sub_",
"unary_minus_",
"equal_",
"not_equal_",
"mux_",
"wide_mux_",
"wide_select_",
"wide_dff_",
"wide_dlatch_",
"wide_dffrs_",
"wide_dlatchrs_",
"wide_prio_select_",
"pow_",
"PrioEncoder_",
"abs",
NULL NULL
}; };
// check if it is a known module // check if it is a known module
static inline int Cba_PrsIsKnownModule( Cba_Prs_t * p, char * pName ) static inline int Prs_ManIsKnownModule( Prs_Man_t * p, char * pName )
{ {
int i; int i;
for ( i = 1; s_KnownModules[i]; i++ ) for ( i = CBA_BOX_C0; s_KnownModules[i]; i++ )
if ( !strncmp(pName, s_KnownModules[i], strlen(s_KnownModules[i])) ) if ( !strncmp(pName, s_KnownModules[i], strlen(s_KnownModules[i])) )
return i; return i;
return 0; return 0;
...@@ -158,65 +203,65 @@ static inline int Cba_PrsIsKnownModule( Cba_Prs_t * p, char * pName ) ...@@ -158,65 +203,65 @@ static inline int Cba_PrsIsKnownModule( Cba_Prs_t * p, char * pName )
***********************************************************************/ ***********************************************************************/
// skips Verilog comments (returns 1 if some comments were skipped) // skips Verilog comments (returns 1 if some comments were skipped)
static inline int Cba_PrsUtilSkipComments( Cba_Prs_t * p ) static inline int Prs_ManUtilSkipComments( Prs_Man_t * p )
{ {
if ( !Cba_PrsIsChar(p, '/') ) if ( !Prs_ManIsChar(p, '/') )
return 0; return 0;
if ( Cba_PrsIsChar1(p, '/') ) if ( Prs_ManIsChar1(p, '/') )
{ {
for ( p->pCur += 2; p->pCur < p->pLimit; p->pCur++ ) for ( p->pCur += 2; p->pCur < p->pLimit; p->pCur++ )
if ( Cba_PrsIsChar(p, '\n') ) if ( Prs_ManIsChar(p, '\n') )
{ p->pCur++; return 1; } { p->pCur++; return 1; }
} }
else if ( Cba_PrsIsChar1(p, '*') ) else if ( Prs_ManIsChar1(p, '*') )
{ {
for ( p->pCur += 2; p->pCur < p->pLimit; p->pCur++ ) for ( p->pCur += 2; p->pCur < p->pLimit; p->pCur++ )
if ( Cba_PrsIsChar(p, '*') && Cba_PrsIsChar1(p, '/') ) if ( Prs_ManIsChar(p, '*') && Prs_ManIsChar1(p, '/') )
{ p->pCur++; p->pCur++; return 1; } { p->pCur++; p->pCur++; return 1; }
} }
return 0; return 0;
} }
static inline int Cba_PrsUtilSkipName( Cba_Prs_t * p ) static inline int Prs_ManUtilSkipName( Prs_Man_t * p )
{ {
if ( !Cba_PrsIsChar(p, '\\') ) if ( !Prs_ManIsChar(p, '\\') )
return 0; return 0;
for ( p->pCur++; p->pCur < p->pLimit; p->pCur++ ) for ( p->pCur++; p->pCur < p->pLimit; p->pCur++ )
if ( Cba_PrsIsChar(p, ' ') ) if ( Prs_ManIsChar(p, ' ') )
{ p->pCur++; return 1; } { p->pCur++; return 1; }
return 0; return 0;
} }
// skip any number of spaces and comments // skip any number of spaces and comments
static inline int Cba_PrsUtilSkipSpaces( Cba_Prs_t * p ) static inline int Prs_ManUtilSkipSpaces( Prs_Man_t * p )
{ {
while ( p->pCur < p->pLimit ) while ( p->pCur < p->pLimit )
{ {
while ( Cba_IsSpace(*p->pCur) ) while ( Prs_CharIsSpace(*p->pCur) )
p->pCur++; p->pCur++;
if ( !*p->pCur ) if ( !*p->pCur )
return Cba_PrsErrorSet(p, "Unexpectedly reached end-of-file.", 1); return Prs_ManErrorSet(p, "Unexpectedly reached end-of-file.", 1);
if ( !Cba_PrsUtilSkipComments(p) ) if ( !Prs_ManUtilSkipComments(p) )
return 0; return 0;
} }
return Cba_PrsErrorSet(p, "Unexpectedly reached end-of-file.", 1); return Prs_ManErrorSet(p, "Unexpectedly reached end-of-file.", 1);
} }
// skip everything including comments until the given char // skip everything including comments until the given char
static inline int Cba_PrsUtilSkipUntil( Cba_Prs_t * p, char c ) static inline int Prs_ManUtilSkipUntil( Prs_Man_t * p, char c )
{ {
while ( p->pCur < p->pLimit ) while ( p->pCur < p->pLimit )
{ {
if ( Cba_PrsIsChar(p, c) ) if ( Prs_ManIsChar(p, c) )
return 1; return 1;
if ( Cba_PrsUtilSkipComments(p) ) if ( Prs_ManUtilSkipComments(p) )
continue; continue;
if ( Cba_PrsUtilSkipName(p) ) if ( Prs_ManUtilSkipName(p) )
continue; continue;
p->pCur++; p->pCur++;
} }
return 0; return 0;
} }
// skip everything including comments until the given word // skip everything including comments until the given word
static inline int Cba_PrsUtilSkipUntilWord( Cba_Prs_t * p, char * pWord ) static inline int Prs_ManUtilSkipUntilWord( Prs_Man_t * p, char * pWord )
{ {
char * pPlace = strstr( p->pCur, pWord ); char * pPlace = strstr( p->pCur, pWord );
if ( pPlace == NULL ) return 1; if ( pPlace == NULL ) return 1;
...@@ -224,13 +269,6 @@ static inline int Cba_PrsUtilSkipUntilWord( Cba_Prs_t * p, char * pWord ) ...@@ -224,13 +269,6 @@ static inline int Cba_PrsUtilSkipUntilWord( Cba_Prs_t * p, char * pWord )
return 0; return 0;
} }
/*
signal is a pair {NameId; RangeId}
if ( RangeId == 0 ) this is name without range
if ( RangeId == -1 ) this is constant
if ( RangeId == -2 ) this is concatenation
*/
/**Function************************************************************* /**Function*************************************************************
Synopsis [] Synopsis []
...@@ -242,206 +280,186 @@ if ( RangeId == -2 ) this is concatenation ...@@ -242,206 +280,186 @@ if ( RangeId == -2 ) this is concatenation
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline int Cba_PrsReadName( Cba_Prs_t * p ) static inline int Prs_ManReadName( Prs_Man_t * p )
{ {
char * pStart = p->pCur; char * pStart = p->pCur;
if ( Cba_PrsIsChar(p, '\\') ) // escaped name if ( Prs_ManIsChar(p, '\\') ) // escaped name
{ {
pStart = ++p->pCur; pStart = ++p->pCur;
while ( !Cba_PrsIsChar(p, ' ') ) while ( !Prs_ManIsChar(p, ' ') )
p->pCur++; p->pCur++;
} }
else if ( Cba_IsSymb1(*p->pCur) ) // simple name else if ( Prs_CharIsSymb1(*p->pCur) ) // simple name
{ {
p->pCur++; p->pCur++;
while ( Cba_IsSymb2(*p->pCur) ) while ( Prs_CharIsSymb2(*p->pCur) )
p->pCur++; p->pCur++;
} }
else else
return 0; return 0;
return Abc_NamStrFindOrAddLim( p->pDesign->pNames, pStart, p->pCur, NULL ); return Abc_NamStrFindOrAddLim( p->pStrs, pStart, p->pCur, NULL );
}
static inline int Prs_ManReadNameList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb )
{
Vec_IntClear( vTemp );
while ( 1 )
{
int Item = Prs_ManReadName(p);
if ( Item == 0 ) return Prs_ManErrorSet(p, "Cannot read name in the list.", 0);
Vec_IntPush( vTemp, Item );
if ( Prs_ManIsChar(p, LastSymb) ) break;
if ( !Prs_ManIsChar(p, ',') ) return Prs_ManErrorSet(p, "Expecting comma in the list.", 0);
p->pCur++;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
}
return 1;
} }
static inline int Cba_PrsReadConstant( Cba_Prs_t * p ) static inline int Prs_ManReadConstant( Prs_Man_t * p )
{ {
char * pStart = p->pCur; char * pStart = p->pCur;
assert( Cba_PrsIsDigit(p) ); assert( Prs_ManIsDigit(p) );
while ( Cba_PrsIsDigit(p) ) while ( Prs_ManIsDigit(p) )
p->pCur++; p->pCur++;
if ( !Cba_PrsIsChar(p, '\'') ) return Cba_PrsErrorSet(p, "Cannot read constant.", 0); if ( !Prs_ManIsChar(p, '\'') ) return Prs_ManErrorSet(p, "Cannot read constant.", 0);
p->pCur++; p->pCur++;
if ( Cba_PrsIsChar(p, 'b') ) if ( Prs_ManIsChar(p, 'b') )
{ {
p->pCur++; p->pCur++;
while ( Cba_IsDigitB(*p->pCur) ) while ( Prs_CharIsDigitB(*p->pCur) )
p->pCur++; p->pCur++;
} }
else if ( Cba_PrsIsChar(p, 'h') ) else if ( Prs_ManIsChar(p, 'h') )
{ {
p->pCur++; p->pCur++;
while ( Cba_IsDigitH(*p->pCur) ) while ( Prs_CharIsDigitH(*p->pCur) )
p->pCur++; p->pCur++;
} }
else if ( Cba_PrsIsChar(p, 'd') ) else if ( Prs_ManIsChar(p, 'd') )
{ {
p->pCur++; p->pCur++;
while ( Cba_PrsIsDigit(p) ) while ( Prs_ManIsDigit(p) )
p->pCur++; p->pCur++;
} }
else return Cba_PrsErrorSet(p, "Cannot read radix of constant.", 0); else return Prs_ManErrorSet(p, "Cannot read radix of constant.", 0);
return Abc_NamStrFindOrAddLim( p->pDesign->pNames, pStart, p->pCur, NULL ); return Abc_NamStrFindOrAddLim( p->pStrs, pStart, p->pCur, NULL );
} }
static inline int Cba_PrsReadRange( Cba_Prs_t * p ) static inline int Prs_ManReadRange( Prs_Man_t * p )
{ {
assert( Cba_PrsIsChar(p, '[') ); assert( Prs_ManIsChar(p, '[') );
Vec_StrClear( &p->vCover ); Vec_StrClear( &p->vCover );
Vec_StrPush( &p->vCover, *p->pCur++ ); Vec_StrPush( &p->vCover, *p->pCur++ );
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsIsDigit(p) ) return Cba_PrsErrorSet(p, "Cannot read digit in range specification.", 0); if ( !Prs_ManIsDigit(p) ) return Prs_ManErrorSet(p, "Cannot read digit in range specification.", 0);
while ( Cba_PrsIsDigit(p) ) while ( Prs_ManIsDigit(p) )
Vec_StrPush( &p->vCover, *p->pCur++ ); Vec_StrPush( &p->vCover, *p->pCur++ );
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsIsChar(p, ':') ) if ( Prs_ManIsChar(p, ':') )
{ {
Vec_StrPush( &p->vCover, *p->pCur++ ); Vec_StrPush( &p->vCover, *p->pCur++ );
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsIsDigit(p) ) return Cba_PrsErrorSet(p, "Cannot read digit in range specification.", 0); if ( !Prs_ManIsDigit(p) ) return Prs_ManErrorSet(p, "Cannot read digit in range specification.", 0);
while ( Cba_PrsIsDigit(p) ) while ( Prs_ManIsDigit(p) )
Vec_StrPush( &p->vCover, *p->pCur++ ); Vec_StrPush( &p->vCover, *p->pCur++ );
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
} }
if ( !Cba_PrsIsChar(p, ']') ) return Cba_PrsErrorSet(p, "Cannot read closing brace in range specification.", 0); if ( !Prs_ManIsChar(p, ']') ) return Prs_ManErrorSet(p, "Cannot read closing brace in range specification.", 0);
Vec_StrPush( &p->vCover, *p->pCur++ ); Vec_StrPush( &p->vCover, *p->pCur++ );
Vec_StrPush( &p->vCover, '\0' ); Vec_StrPush( &p->vCover, '\0' );
return Abc_NamStrFindOrAdd( p->pDesign->pNames, Vec_StrArray(&p->vCover), NULL ); return Abc_NamStrFindOrAdd( p->pStrs, Vec_StrArray(&p->vCover), NULL );
}
static inline int Cba_PrsReadSignal( Cba_Prs_t * p, int * pName, int * pRange )
{
*pName = *pRange = 0;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsIsDigit(p) )
{
*pName = Cba_PrsReadConstant(p);
if ( *pName == 0 ) return 0;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
*pRange = -1;
return 1;
}
*pName = Cba_PrsReadName( p );
if ( *pName == 0 )
return 1;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsIsChar(p, '[') )
return 1;
*pRange = Cba_PrsReadRange(p);
if ( *pRange == 0 ) return 0;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
return 1;
} }
static inline int Cba_PrsReadSignalList( Cba_Prs_t * p, Vec_Int_t * vTemp, char LastSymb ) static inline int Prs_ManReadConcat( Prs_Man_t * p, Vec_Int_t * vTemp2 )
{ {
Vec_IntClear( vTemp ); extern int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm );
while ( 1 ) assert( Prs_ManIsChar(p, '{') );
{
int NameId, RangeId;
if ( !Cba_PrsReadSignal(p, &NameId, &RangeId) ) return 0;
if ( NameId == 0 ) return Cba_PrsErrorSet(p, "Cannot read signal in the list.", 0);
Vec_IntPushTwo( vTemp, NameId, RangeId );
if ( Cba_PrsIsChar(p, LastSymb) ) break;
if ( !Cba_PrsIsChar(p, ',') ) return Cba_PrsErrorSet(p, "Expecting comma in the list.", 0);
p->pCur++; p->pCur++;
} if ( !Prs_ManReadSignalList( p, vTemp2, '}', 0 ) ) return 0;
assert( Vec_IntSize(vTemp) > 0 );
assert( Vec_IntSize(vTemp) % 2 == 0 );
return 1;
}
static inline int Cba_PrsReadConcat( Cba_Prs_t * p, Vec_Int_t * vTemp2 )
{
assert( Cba_PrsIsChar(p, '{') );
p->pCur++;
if ( !Cba_PrsReadSignalList(p, vTemp2, '}') ) return 0;
// check final // check final
assert( Cba_PrsIsChar(p, '}') ); assert( Prs_ManIsChar(p, '}') );
p->pCur++; p->pCur++;
// return special case // return special case
if ( Vec_IntSize(vTemp2) == 2 ) return -1; // trivial concatentation assert( Vec_IntSize(vTemp2) > 0 );
assert( Vec_IntSize(vTemp2) > 2 ); if ( Vec_IntSize(vTemp2) == 1 )
assert( Vec_IntSize(vTemp2) % 2 == 0 ); return Vec_IntEntry(vTemp2, 0);
// create new concatentation return Abc_Var2Lit2( Prs_NtkAddConcat(p->pNtk, vTemp2), CBA_PRS_CONCAT );
Vec_IntPush( &p->vTypesCur, CBA_OBJ_CONCAT );
Vec_IntPush( &p->vFuncsCur, 0 );
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, vTemp2) );
Vec_IntPush( &p->vInstIdsCur, 0 );
return Vec_IntSize(&p->vFaninsCur);
} }
static inline int Cba_PrsReadSignalOrConcat( Cba_Prs_t * p, int * pName, int * pRange ) static inline int Prs_ManReadSignal( Prs_Man_t * p )
{ {
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; int Item;
if ( Cba_PrsIsChar(p, '{') ) if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Prs_ManIsDigit(p) )
{ {
int Status = Cba_PrsReadConcat(p, &p->vTemp2); Item = Prs_ManReadConstant(p);
if ( Status == 0 ) return 0; if ( Item == 0 ) return 0;
*pName = Status == -1 ? Vec_IntEntry( &p->vTemp2, 0 ) : Status; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
*pRange = Status == -1 ? Vec_IntEntry( &p->vTemp2, 1 ) : -2; return Abc_Var2Lit2( Item, CBA_PRS_CONST );
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; }
if ( Prs_ManIsChar(p, '{') )
{
if ( p->fUsingTemp2 ) return Prs_ManErrorSet(p, "Cannot read nested concatenations.", 0);
p->fUsingTemp2 = 1;
Item = Prs_ManReadConcat(p, &p->vTemp2);
p->fUsingTemp2 = 0;
if ( Item == 0 ) return 0;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
return Item;
} }
else else
{ {
if ( !Cba_PrsReadSignal(p, pName, pRange) ) return 0; Item = Prs_ManReadName( p );
if ( *pName == 0 ) return Cba_PrsErrorSet(p, "Cannot read formal name in the list.", 0); if ( Item == 0 ) return 0; // was return 1;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Prs_ManIsChar(p, '[') )
{
int Range = Prs_ManReadRange(p);
if ( Range == 0 ) return 0;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
return Abc_Var2Lit2( Prs_NtkAddSlice(p->pNtk, Item, Range), CBA_PRS_SLICE );
}
return Abc_Var2Lit2( Item, CBA_PRS_NAME );
} }
return 1;
} }
static inline int Cba_PrsReadSignalList1( Cba_Prs_t * p, Vec_Int_t * vTemp ) static inline int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm )
{ {
Vec_IntClear( vTemp ); Vec_IntClear( vTemp );
while ( 1 ) while ( 1 )
{ {
int NameId, RangeId; int Item = Prs_ManReadSignal(p);
if ( !Cba_PrsReadSignalOrConcat(p, &NameId, &RangeId) ) return 0; if ( Item == 0 ) return Prs_ManErrorSet(p, "Cannot read signal in the list.", 0);
if ( NameId == 0 ) return Cba_PrsErrorSet(p, "Cannot read signal or concatenation in the list.", 0); if ( fAddForm )
Vec_IntPushTwo( vTemp, NameId, RangeId ); Vec_IntPush( vTemp, 0 );
if ( Cba_PrsIsChar(p, ')') ) break; Vec_IntPush( vTemp, Item );
if ( !Cba_PrsIsChar(p, ',') ) return Cba_PrsErrorSet(p, "Expecting comma in the list.", 0); if ( Prs_ManIsChar(p, LastSymb) ) break;
if ( !Prs_ManIsChar(p, ',') ) return Prs_ManErrorSet(p, "Expecting comma in the list.", 0);
p->pCur++; p->pCur++;
} }
p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsIsChar(p, ';') ) return Cba_PrsErrorSet(p, "Expecting semicolon in the instance.", 0);
assert( Vec_IntSize(vTemp) > 0 );
assert( Vec_IntSize(vTemp) % 2 == 0 );
return 1; return 1;
} }
static inline int Cba_PrsReadSignalList2( Cba_Prs_t * p, Vec_Int_t * vTemp ) static inline int Prs_ManReadSignalList2( Prs_Man_t * p, Vec_Int_t * vTemp )
{ {
int FormId, NameId, RangeId; int FormId, ActItem;
Vec_IntClear( vTemp ); Vec_IntClear( vTemp );
assert( Cba_PrsIsChar(p, '.') ); assert( Prs_ManIsChar(p, '.') );
while ( Cba_PrsIsChar(p, '.') ) while ( Prs_ManIsChar(p, '.') )
{ {
p->pCur++; p->pCur++;
if ( !Cba_PrsReadSignal(p, &FormId, &RangeId) ) return 0; FormId = Prs_ManReadName( p );
if ( FormId == 0 ) return Cba_PrsErrorSet(p, "Cannot read formal name of the instance.", 0); if ( FormId == 0 ) return Prs_ManErrorSet(p, "Cannot read formal name of the instance.", 0);
if ( RangeId != 0 ) return Cba_PrsErrorSet(p, "Formal signal cannot have range.", 0); if ( !Prs_ManIsChar(p, '(') ) return Prs_ManErrorSet(p, "Cannot read \"(\" in the instance.", 0);
if ( !Cba_PrsIsChar(p, '(') ) return Cba_PrsErrorSet(p, "Cannot read \"(\" in the instance.", 0);
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsReadSignalOrConcat(p, &NameId, &RangeId) ) return 0; ActItem = Prs_ManReadSignal( p );
if ( NameId == 0 ) return Cba_PrsErrorSet(p, "Cannot read actual name of the instance.", 0); if ( ActItem == 0 ) return Prs_ManErrorSet(p, "Cannot read actual name of the instance.", 0);
if ( !Cba_PrsIsChar(p, ')') ) return Cba_PrsErrorSet(p, "Cannot read \")\" in the instance.", 0); if ( !Prs_ManIsChar(p, ')') ) return Prs_ManErrorSet(p, "Cannot read \")\" in the instance.", 0);
p->pCur++; p->pCur++;
Vec_IntPush( vTemp, FormId ); Vec_IntPushTwo( vTemp, FormId, ActItem );
Vec_IntPushTwo( vTemp, NameId, RangeId ); if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManIsChar(p, ')') ) break;
if ( Cba_PrsIsChar(p, ')') ) break; if ( !Prs_ManIsChar(p, ',') ) return Prs_ManErrorSet(p, "Expecting comma in the instance.", 0);
if ( !Cba_PrsIsChar(p, ',') ) return Cba_PrsErrorSet(p, "Expecting comma in the instance.", 0);
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
} }
p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0;
if ( !Cba_PrsIsChar(p, ';') ) return Cba_PrsErrorSet(p, "Expecting semicolon in the instance.", 0);
assert( Vec_IntSize(vTemp) > 0 ); assert( Vec_IntSize(vTemp) > 0 );
assert( Vec_IntSize(vTemp) % 3 == 0 ); assert( Vec_IntSize(vTemp) % 2 == 0 );
return 1; return 1;
} }
...@@ -456,204 +474,245 @@ static inline int Cba_PrsReadSignalList2( Cba_Prs_t * p, Vec_Int_t * vTemp ) ...@@ -456,204 +474,245 @@ static inline int Cba_PrsReadSignalList2( Cba_Prs_t * p, Vec_Int_t * vTemp )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
static inline int Cba_PrsReadDeclaration( Cba_Prs_t * p, int Type ) static inline int Prs_ManReadDeclaration( Prs_Man_t * p, int Type )
{ {
int NameId, RangeId, RangeIdTemp, i; int i, Sig, RangeId = 0;
Vec_Int_t * vSigs[4] = { &p->vInoutsCur, &p->vInputsCur, &p->vOutputsCur, &p->vWiresCur }; Vec_Int_t * vSigs[4] = { &p->pNtk->vInouts, &p->pNtk->vInputs, &p->pNtk->vOutputs, &p->pNtk->vWires };
assert( Type >= CBA_VER_INOUT && Type <= CBA_VER_WIRE ); Vec_Int_t * vSigsR[4] = { &p->pNtk->vInoutsR, &p->pNtk->vInputsR, &p->pNtk->vOutputsR, &p->pNtk->vWiresR };
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; assert( Type >= PRS_VER_INOUT && Type <= PRS_VER_WIRE );
RangeId = 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsIsChar(p, '[') && !(RangeId = Cba_PrsReadRange(p)) ) return 0; if ( Prs_ManIsChar(p, '[') && !(RangeId = Prs_ManReadRange(p)) ) return 0;
if ( !Cba_PrsReadSignalList( p, &p->vTemp, ';' ) ) return 0; if ( !Prs_ManReadNameList( p, &p->vTemp, ';' ) ) return 0;
Vec_IntForEachEntryDouble( &p->vTemp, NameId, RangeIdTemp, i ) Vec_IntForEachEntry( &p->vTemp, Sig, i )
{ {
if ( RangeIdTemp ) return Cba_PrsErrorSet(p, "Range is specified twice in the declaration.", 0); Vec_IntPush( vSigs[Type - PRS_VER_INOUT], Sig );
Vec_IntPushTwo( vSigs[Type - CBA_VER_INOUT], NameId, RangeId ); Vec_IntPush( vSigsR[Type - PRS_VER_INOUT], RangeId );
} }
return 1; return 1;
} }
static inline int Cba_PrsReadAssign( Cba_Prs_t * p ) static inline int Prs_ManReadAssign( Prs_Man_t * p )
{ {
int OutName = 0, InName = 0, RangeId = 0, fCompl = 0, Oper = 0; int OutItem, InItem, fCompl = 0, Oper = 0;
Vec_IntClear( &p->vTemp );
// read output name // read output name
if ( !Cba_PrsReadSignal(p, &OutName, &RangeId) ) return 0; OutItem = Prs_ManReadSignal( p );
if ( OutName == 0 ) return Cba_PrsErrorSet(p, "Cannot read output in assign-statement.", 0); if ( OutItem == 0 ) return Prs_ManErrorSet(p, "Cannot read output in assign-statement.", 0);
if ( !Cba_PrsIsChar(p, '=') ) return Cba_PrsErrorSet(p, "Expecting \"=\" in assign-statement.", 0); if ( !Prs_ManIsChar(p, '=') ) return Prs_ManErrorSet(p, "Expecting \"=\" in assign-statement.", 0);
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsIsChar(p, '~') ) if ( Prs_ManIsChar(p, '~') )
{ {
fCompl = 1; fCompl = 1;
p->pCur++; p->pCur++;
} }
Vec_IntPush( &p->vTemp, OutName );
Vec_IntPush( &p->vTemp, RangeId );
// read first name // read first name
if ( !Cba_PrsReadSignal(p, &InName, &RangeId)) return 0; InItem = Prs_ManReadSignal( p );
if ( InName == 0 ) return Cba_PrsErrorSet(p, "Cannot read first input name in the assign-statement.", 0); if ( InItem == 0 ) return Prs_ManErrorSet(p, "Cannot read first input name in the assign-statement.", 0);
Vec_IntPush( &p->vTemp, InName ); Vec_IntClear( &p->vTemp );
Vec_IntPush( &p->vTemp, RangeId ); Vec_IntPush( &p->vTemp, 0 );
Vec_IntPush( &p->vTemp, InItem );
// check unary operator // check unary operator
if ( Cba_PrsIsChar(p, ';') ) if ( Prs_ManIsChar(p, ';') )
{ {
Vec_IntPush( &p->vTypesCur, CBA_OBJ_NODE ); Vec_IntPush( &p->vTemp, 0 );
Vec_IntPush( &p->vFuncsCur, fCompl ? CBA_NODE_INV : CBA_NODE_BUF ); Vec_IntPush( &p->vTemp, OutItem );
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); Oper = fCompl ? CBA_BOX_INV : CBA_BOX_BUF;
Vec_IntPush( &p->vInstIdsCur, 0 ); Prs_NtkAddBox( p->pNtk, Oper, 0, &p->vTemp );
return 1; return 1;
} }
if ( Cba_PrsIsChar(p, '&') ) if ( Prs_ManIsChar(p, '&') )
Oper = CBA_NODE_AND; Oper = CBA_BOX_AND;
else if ( Cba_PrsIsChar(p, '|') ) else if ( Prs_ManIsChar(p, '|') )
Oper = CBA_NODE_OR; Oper = CBA_BOX_OR;
else if ( Cba_PrsIsChar(p, '^') ) else if ( Prs_ManIsChar(p, '^') )
Oper = fCompl ? CBA_NODE_XNOR : CBA_NODE_XOR; Oper = fCompl ? CBA_BOX_XNOR : CBA_BOX_XOR;
else if ( Cba_PrsIsChar(p, '?') ) else if ( Prs_ManIsChar(p, '?') )
Oper = CBA_NODE_MUX; Oper = CBA_BOX_MUX;
else return Cba_PrsErrorSet(p, "Unrecognized operator in the assign-statement.", 0); else return Prs_ManErrorSet(p, "Unrecognized operator in the assign-statement.", 0);
p->pCur++; p->pCur++;
// read second name // read second name
if ( !Cba_PrsReadSignal(p, &InName, &RangeId)) return 0; InItem = Prs_ManReadSignal( p );
if ( InName == 0 ) return Cba_PrsErrorSet(p, "Cannot read second input name in the assign-statement.", 0); if ( InItem == 0 ) return Prs_ManErrorSet(p, "Cannot read second input name in the assign-statement.", 0);
Vec_IntPush( &p->vTemp, InName ); Vec_IntPush( &p->vTemp, 0 );
Vec_IntPush( &p->vTemp, RangeId ); Vec_IntPush( &p->vTemp, InItem );
// read third argument // read third argument
if ( Oper == CBA_NODE_MUX ) if ( Oper == CBA_BOX_MUX )
{ {
assert( fCompl == 0 ); assert( fCompl == 0 );
if ( !Cba_PrsIsChar(p, ':') ) return Cba_PrsErrorSet(p, "Expected colon in the MUX assignment.", 0); if ( !Prs_ManIsChar(p, ':') ) return Prs_ManErrorSet(p, "Expected colon in the MUX assignment.", 0);
p->pCur++; p->pCur++;
// read third name // read third name
if ( !Cba_PrsReadSignal(p, &InName, &RangeId)) return 0; InItem = Prs_ManReadSignal( p );
if ( InName == 0 ) return Cba_PrsErrorSet(p, "Cannot read third input name in the assign-statement.", 0); if ( InItem == 0 ) return Prs_ManErrorSet(p, "Cannot read third input name in the assign-statement.", 0);
Vec_IntPush( &p->vTemp, InName ); Vec_IntPush( &p->vTemp, 0 );
Vec_IntPush( &p->vTemp, RangeId ); Vec_IntPush( &p->vTemp, InItem );
if ( !Cba_PrsIsChar(p, ';') ) return Cba_PrsErrorSet(p, "Expected semicolon at the end of the assign-statement.", 0); if ( !Prs_ManIsChar(p, ';') ) return Prs_ManErrorSet(p, "Expected semicolon at the end of the assign-statement.", 0);
} }
// write binary operator // write binary operator
Vec_IntPush( &p->vTypesCur, CBA_OBJ_NODE ); Vec_IntPush( &p->vTemp, 0 );
Vec_IntPush( &p->vFuncsCur, Oper ); Vec_IntPush( &p->vTemp, OutItem );
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); Prs_NtkAddBox( p->pNtk, Oper, 0, &p->vTemp );
Vec_IntPush( &p->vInstIdsCur, 0 );
return 1; return 1;
} }
static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func ) static inline int Prs_ManReadInstance( Prs_Man_t * p, int Func )
{ {
// have to assign Type, Func, InstId, vFanins int InstId, Status;
int InstId, Status, Type; /*
Vec_IntClear( &p->vTemp ); static Counter = 0;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( ++Counter == 7 )
InstId = Cba_PrsReadName( p ); {
if ( InstId && Cba_PrsUtilSkipSpaces(p) ) return 0; int s=0;
if ( !Cba_PrsIsChar(p, '(') ) return Cba_PrsErrorSet(p, "Expecting \"(\" in module instantiation.", 0); }
*/
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( (InstId = Prs_ManReadName(p)) )
if (Prs_ManUtilSkipSpaces(p)) return 0;
if ( !Prs_ManIsChar(p, '(') ) return Prs_ManErrorSet(p, "Expecting \"(\" in module instantiation.", 0);
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 0; if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( Cba_PrsIsChar(p, '.') ) // node if ( Prs_ManIsChar(p, '.') ) // box
Status = Cba_PrsReadSignalList2(p, &p->vTemp), Type = CBA_OBJ_BOX; Status = Prs_ManReadSignalList2(p, &p->vTemp);
else else // node
Status = Cba_PrsReadSignalList1(p, &p->vTemp), Type = CBA_OBJ_NODE;
if ( Status == 0 ) return 0;
// translate elementary gate
if ( Type == CBA_OBJ_NODE )
{ {
int iFuncNew = Cba_PrsIsKnownModule(p, Abc_NamStr(p->pDesign->pNames, Func)); //char * s = Abc_NamStr(p->pStrs, Func);
if ( iFuncNew == 0 ) return Cba_PrsErrorSet(p, "Cannot find elementary gate.", 0); // translate elementary gate
int iFuncNew = Prs_ManIsKnownModule(p, Abc_NamStr(p->pStrs, Func));
if ( iFuncNew == 0 ) return Prs_ManErrorSet(p, "Cannot find elementary gate.", 0);
Func = iFuncNew; Func = iFuncNew;
Status = Prs_ManReadSignalList( p, &p->vTemp, ')', 1 );
} }
// assign if ( Status == 0 ) return 0;
Vec_IntPush( &p->vTypesCur, Type ); assert( Prs_ManIsChar(p, ')') );
Vec_IntPush( &p->vFuncsCur, Func ); p->pCur++;
Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); if ( Prs_ManUtilSkipSpaces(p) ) return 0;
Vec_IntPush( &p->vInstIdsCur, InstId ); if ( !Prs_ManIsChar(p, ';') ) return Prs_ManErrorSet(p, "Expecting semicolon in the instance.", 0);
// add box
Prs_NtkAddBox( p->pNtk, Func, InstId, &p->vTemp );
return 1;
}
static inline int Prs_ManReadArguments( Prs_Man_t * p )
{
int iRange = 0, iType = -1;
Vec_Int_t * vSigs[3] = { &p->pNtk->vInouts, &p->pNtk->vInputs, &p->pNtk->vOutputs };
Vec_Int_t * vSigsR[3] = { &p->pNtk->vInoutsR, &p->pNtk->vInputsR, &p->pNtk->vOutputsR };
assert( Prs_ManIsChar(p, '(') );
p->pCur++;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
while ( 1 )
{
int iName = Prs_ManReadName( p );
if ( iName == 0 ) return 0;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
if ( iName >= PRS_VER_INOUT && iName <= PRS_VER_OUTPUT ) // declaration
{
iType = iName;
if ( Prs_ManIsChar(p, '[') )
{
iRange = Prs_ManReadRange(p);
if ( iRange == 0 ) return 0;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
}
}
if ( iType > 0 )
{
Vec_IntPush( vSigs[iType - PRS_VER_INOUT], iName );
Vec_IntPush( vSigsR[iType - PRS_VER_INOUT], iRange );
}
Vec_IntPush( &p->pNtk->vOrder, iName );
if ( Prs_ManIsChar(p, ')') )
break;
if ( !Prs_ManIsChar(p, ',') ) return Prs_ManErrorSet(p, "Expecting comma in the instance.", 0);
p->pCur++;
if ( Prs_ManUtilSkipSpaces(p) ) return 0;
}
// check final
assert( Prs_ManIsChar(p, ')') );
return 1; return 1;
} }
// this procedure can return: // this procedure can return:
// 0 = reached end-of-file; 1 = successfully parsed; 2 = recognized as primitive; 3 = failed and skipped; 4 = error (failed and could not skip) // 0 = reached end-of-file; 1 = successfully parsed; 2 = recognized as primitive; 3 = failed and skipped; 4 = error (failed and could not skip)
static inline int Cba_PrsReadModule( Cba_Prs_t * p ) static inline int Prs_ManReadModule( Prs_Man_t * p )
{ {
int iToken, Status; int iToken, Status;
if ( p->iModuleName != 0 ) return Cba_PrsErrorSet(p, "Parsing previous module is unfinished.", 4); if ( p->pNtk != NULL ) return Prs_ManErrorSet(p, "Parsing previous module is unfinished.", 4);
if ( Cba_PrsUtilSkipSpaces(p) ) if ( Prs_ManUtilSkipSpaces(p) )
{ {
Cba_PrsErrorClear( p ); Prs_ManErrorClear( p );
return 0; return 0;
} }
// read keyword // read keyword
iToken = Cba_PrsReadName( p ); iToken = Prs_ManReadName( p );
if ( iToken != CBA_VER_MODULE ) return Cba_PrsErrorSet(p, "Cannot read \"module\" keyword.", 4); if ( iToken != PRS_VER_MODULE ) return Prs_ManErrorSet(p, "Cannot read \"module\" keyword.", 4);
if ( Cba_PrsUtilSkipSpaces(p) ) return 4; if ( Prs_ManUtilSkipSpaces(p) ) return 4;
// read module name // read module name
p->iModuleName = Cba_PrsReadName( p ); iToken = Prs_ManReadName( p );
if ( p->iModuleName == 0 ) return Cba_PrsErrorSet(p, "Cannot read module name.", 4); if ( iToken == 0 ) return Prs_ManErrorSet(p, "Cannot read module name.", 4);
if ( Cba_PrsIsKnownModule(p, Abc_NamStr(p->pDesign->pNames, p->iModuleName)) ) if ( Prs_ManIsKnownModule(p, Abc_NamStr(p->pStrs, iToken)) )
{ {
if ( Cba_PrsUtilSkipUntilWord( p, "endmodule" ) ) return Cba_PrsErrorSet(p, "Cannot find \"endmodule\" keyword.", 4); if ( Prs_ManUtilSkipUntilWord( p, "endmodule" ) ) return Prs_ManErrorSet(p, "Cannot find \"endmodule\" keyword.", 4);
//printf( "Warning! Skipped known module \"%s\".\n", Abc_NamStr(p->pDesign->pNames, p->iModuleName) ); //printf( "Warning! Skipped known module \"%s\".\n", Abc_NamStr(p->pStrs, iToken) );
Vec_IntPush( &p->vKnown, p->iModuleName ); Vec_IntPush( &p->vKnown, iToken );
p->iModuleName = 0;
return 2; return 2;
} }
Prs_ManInitializeNtk( p, iToken, 1 );
// skip arguments // skip arguments
if ( Cba_PrsUtilSkipSpaces(p) ) return 4; if ( Prs_ManUtilSkipSpaces(p) ) return 4;
if ( !Cba_PrsIsChar(p, '(') ) return Cba_PrsErrorSet(p, "Cannot find \"(\" in the argument declaration.", 4); if ( !Prs_ManIsChar(p, '(') ) return Prs_ManErrorSet(p, "Cannot find \"(\" in the argument declaration.", 4);
if ( !Cba_PrsUtilSkipUntil(p,')') ) return 4; if ( !Prs_ManReadArguments(p) ) return 4;
assert( *p->pCur == ')' ); assert( *p->pCur == ')' );
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 4; if ( Prs_ManUtilSkipSpaces(p) ) return 4;
// read declarations and instances // read declarations and instances
while ( Cba_PrsIsChar(p, ';') ) while ( Prs_ManIsChar(p, ';') )
{ {
p->pCur++; p->pCur++;
if ( Cba_PrsUtilSkipSpaces(p) ) return 4; if ( Prs_ManUtilSkipSpaces(p) ) return 4;
iToken = Cba_PrsReadName( p ); iToken = Prs_ManReadName( p );
if ( iToken == CBA_VER_ENDMODULE ) if ( iToken == PRS_VER_ENDMODULE )
{ {
Vec_IntPush( &p->vSucceeded, p->iModuleName ); Vec_IntPush( &p->vSucceeded, p->pNtk->iModuleName );
Cba_PrsAddCurrentModel( p, p->iModuleName ); Prs_ManFinalizeNtk( p );
p->iModuleName = 0;
return 1; return 1;
} }
if ( iToken >= CBA_VER_INOUT && iToken <= CBA_VER_WIRE ) // declaration if ( iToken >= PRS_VER_INOUT && iToken <= PRS_VER_WIRE ) // declaration
Status = Cba_PrsReadDeclaration( p, iToken ); Status = Prs_ManReadDeclaration( p, iToken );
else if ( iToken == CBA_VER_REG || iToken == CBA_VER_DEFPARAM ) // unsupported keywords else if ( iToken == PRS_VER_REG || iToken == PRS_VER_DEFPARAM ) // unsupported keywords
Status = Cba_PrsUtilSkipUntil( p, ';' ); Status = Prs_ManUtilSkipUntil( p, ';' );
else // read instance else // read instance
{ {
if ( iToken == CBA_VER_ASSIGN ) if ( iToken == PRS_VER_ASSIGN )
Status = Cba_PrsReadAssign( p ); Status = Prs_ManReadAssign( p );
else else
Status = Cba_PrsReadInstance( p, iToken ); Status = Prs_ManReadInstance( p, iToken );
if ( Status == 0 ) if ( Status == 0 )
{ {
if ( Cba_PrsUtilSkipUntilWord( p, "endmodule" ) ) return Cba_PrsErrorSet(p, "Cannot find \"endmodule\" keyword.", 4); if ( Prs_ManUtilSkipUntilWord( p, "endmodule" ) ) return Prs_ManErrorSet(p, "Cannot find \"endmodule\" keyword.", 4);
//printf( "Warning! Failed to parse \"%s\". Adding module \"%s\" as blackbox.\n", //printf( "Warning! Failed to parse \"%s\". Adding module \"%s\" as blackbox.\n",
// Abc_NamStr(p->pDesign->pNames, iToken), Abc_NamStr(p->pDesign->pNames, p->iModuleName) ); // Abc_NamStr(p->pStrs, iToken), Abc_NamStr(p->pStrs, p->pNtk->iModuleName) );
Vec_IntPush( &p->vFailed, p->iModuleName ); Vec_IntPush( &p->vFailed, p->pNtk->iModuleName );
// cleanup // cleanup
Vec_IntClear( &p->vWiresCur ); Vec_IntErase( &p->pNtk->vWires );
Vec_IntClear( &p->vTypesCur ); Vec_IntErase( &p->pNtk->vWiresR );
Vec_IntClear( &p->vFuncsCur ); Vec_IntErase( &p->pNtk->vSlices );
Vec_IntClear( &p->vFaninsCur ); Vec_IntErase( &p->pNtk->vConcats );
Vec_IntClear( &p->vInstIdsCur ); Vec_IntErase( &p->pNtk->vBoxes );
Vec_IntErase( &p->pNtk->vObjs );
p->fUsingTemp2 = 0;
// add // add
Cba_PrsAddCurrentModel( p, p->iModuleName ); Prs_ManFinalizeNtk( p );
Cba_PrsErrorClear( p ); Prs_ManErrorClear( p );
p->iModuleName = 0;
return 3; return 3;
} }
} }
if ( !Status ) return 4; if ( !Status ) return 4;
if ( Cba_PrsUtilSkipSpaces(p) ) return 4; if ( Prs_ManUtilSkipSpaces(p) ) return 4;
} }
return Cba_PrsErrorSet(p, "Cannot find \";\" in the module definition.", 4); return Prs_ManErrorSet(p, "Cannot find \";\" in the module definition.", 4);
} }
static inline int Cba_PrsReadDesign( Cba_Prs_t * p ) static inline int Prs_ManReadDesign( Prs_Man_t * p )
{ {
while ( 1 ) while ( 1 )
{ {
int RetValue = Cba_PrsReadModule( p ); int RetValue = Prs_ManReadModule( p );
if ( RetValue == 0 ) // end of file if ( RetValue == 0 ) // end of file
break; break;
if ( RetValue == 1 ) // successfully parsed if ( RetValue == 1 ) // successfully parsed
...@@ -680,19 +739,19 @@ static inline int Cba_PrsReadDesign( Cba_Prs_t * p ) ...@@ -680,19 +739,19 @@ static inline int Cba_PrsReadDesign( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Cba_PrsPrintModules( Cba_Prs_t * p ) void Prs_ManPrintModules( Prs_Man_t * p )
{ {
char * pName; int i; char * pName; int i;
printf( "Succeeded parsing %d models:\n", Vec_IntSize(&p->vSucceeded) ); printf( "Succeeded parsing %d models:\n", Vec_IntSize(&p->vSucceeded) );
Cba_PrsForEachModelVec( &p->vSucceeded, p, pName, i ) Prs_ManForEachNameVec( &p->vSucceeded, p, pName, i )
printf( " %s", pName ); printf( " %s", pName );
printf( "\n" ); printf( "\n" );
printf( "Skipped %d known models:\n", Vec_IntSize(&p->vKnown) ); printf( "Skipped %d known models:\n", Vec_IntSize(&p->vKnown) );
Cba_PrsForEachModelVec( &p->vKnown, p, pName, i ) Prs_ManForEachNameVec( &p->vKnown, p, pName, i )
printf( " %s", pName ); printf( " %s", pName );
printf( "\n" ); printf( "\n" );
printf( "Skipped %d failed models:\n", Vec_IntSize(&p->vFailed) ); printf( "Skipped %d failed models:\n", Vec_IntSize(&p->vFailed) );
Cba_PrsForEachModelVec( &p->vFailed, p, pName, i ) Prs_ManForEachNameVec( &p->vFailed, p, pName, i )
printf( " %s", pName ); printf( " %s", pName );
printf( "\n" ); printf( "\n" );
} }
...@@ -708,96 +767,41 @@ void Cba_PrsPrintModules( Cba_Prs_t * p ) ...@@ -708,96 +767,41 @@ void Cba_PrsPrintModules( Cba_Prs_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Cba_PrsSkipRangesNtk( Cba_Ntk_t * p ) Vec_Ptr_t * Prs_ManReadVerilog( char * pFileName )
{
Vec_Int_t * vFanins;
int FormId, NameId, RangeId;
int i, k, s, Count = 0;
Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires };
for ( s = 0; s < 4; s++ )
{
k = 0;
Vec_IntForEachEntryDouble( vSigs[s], NameId, RangeId, i )
Vec_IntWriteEntry( vSigs[s], k++, NameId ), Count += RangeId > 0;
Vec_IntShrink( vSigs[s], k );
}
Cba_NtkForEachNode( p, i )
{
k = 0;
vFanins = Cba_ObjFaninVec( p, i );
Vec_IntForEachEntryDouble( vFanins, NameId, RangeId, s )
Vec_IntWriteEntry( vFanins, k++, NameId ), Count += RangeId > 0;
Cba_ObjFaninArray(p, i)[0] = k;
}
Cba_NtkForEachBox( p, i )
{
k = 0;
vFanins = Cba_ObjFaninVec( p, i );
Vec_IntForEachEntryTriple( vFanins, FormId, NameId, RangeId, s )
Vec_IntWriteEntry( vFanins, k++, FormId ), Vec_IntWriteEntry( vFanins, k++, NameId ), Count += RangeId > 0;
Cba_ObjFaninArray(p, i)[0] = k;
}
if ( Count )
printf( "Network %s has %d non-trivial ranges.\n", Cba_NtkName(p), Count );
}
void Cba_PrsSkipRanges( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_PrsSkipRangesNtk( pNtk );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_Man_t * Cba_PrsReadVerilog( char * pFileName, int fBinary )
{ {
Cba_Man_t * pDesign = NULL; Vec_Ptr_t * vPrs = NULL;
Cba_Prs_t * p = Cba_PrsAlloc( pFileName ); Prs_Man_t * p = Prs_ManAlloc( pFileName );
if ( p == NULL ) if ( p == NULL )
return NULL; return NULL;
Cba_PrsAddVerilogDirectives( p ); Prs_NtkAddVerilogDirectives( p );
Cba_PrsReadDesign( p ); Prs_ManReadDesign( p );
//Cba_PrsPrintModules( p ); //Prs_ManPrintModules( p );
if ( Cba_PrsErrorPrint(p) ) if ( Prs_ManErrorPrint(p) )
ABC_SWAP( Cba_Man_t *, pDesign, p->pDesign ); ABC_SWAP( Vec_Ptr_t *, vPrs, p->vNtks );
Cba_PrsFree( p ); Prs_ManFree( p );
Cba_PrsRemapBoxModels( pDesign ); return vPrs;
// transform to binary ranges
if ( fBinary )
Cba_PrsSkipRanges( pDesign );
return pDesign;
} }
void Cba_PrsReadVerilogTest( char * pFileName ) void Prs_ManReadVerilogTest( char * pFileName )
{ {
abctime clk = Abc_Clock(); abctime clk = Abc_Clock();
extern void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p ); extern void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
Cba_Man_t * p = Cba_PrsReadVerilog( "c/hie/dump/24/netlist_0.v", 0 ); Vec_Ptr_t * vPrs = Prs_ManReadVerilog( "c/hie/dump/1/netlist_1.v" );
// Cba_Man_t * p = Cba_PrsReadVerilog( "aga/me/me_wide.v", 0 ); // Vec_Ptr_t * vPrs = Prs_ManReadVerilog( "aga/me/me_wide.v" );
// Cba_Man_t * p = Cba_PrsReadVerilog( "aga/ray/ray_wide.v", 0 ); // Vec_Ptr_t * vPrs = Prs_ManReadVerilog( "aga/ray/ray_wide.v" );
if ( !p ) return; if ( !vPrs ) return;
printf( "Finished reading %d networks. ", Cba_ManNtkNum(p) ); printf( "Finished reading %d networks. ", Vec_PtrSize(vPrs) );
printf( "NameIDs = %d. ", Abc_NamObjNumMax(p->pNames) ); printf( "NameIDs = %d. ", Abc_NamObjNumMax(Prs_ManRoot(vPrs)->pStrs) );
printf( "Memory = %.2f MB. ", 1.0*Cba_ManMemory(p)/(1<<20) ); printf( "Memory = %.2f MB. ", 1.0*Prs_ManMemory(vPrs)/(1<<20) );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
// Abc_NamPrint( p->pDesign->pNames ); Prs_ManWriteVerilog( "c/hie/dump/1/netlist_1_out_new.v", vPrs );
Cba_PrsWriteVerilog( "c/hie/dump/24/netlist_0_out.v", p ); // Prs_ManWriteVerilog( "aga/me/me_wide_out.v", vPrs );
// Cba_PrsWriteVerilog( "aga/me/me_wide_out.v", p ); // Prs_ManWriteVerilog( "aga/ray/ray_wide_out.v", vPrs );
// Cba_PrsWriteVerilog( "aga/ray/ray_wide_out.v", p ); // Abc_NamPrint( p->pStrs );
Cba_ManFree( p ); Prs_ManVecFree( vPrs );
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// END OF FILE /// /// END OF FILE ///
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaSimple.c deleted 100644 → 0
/**CFile****************************************************************
FileName [cbaSimple.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.]
Synopsis [Parses several flavors of word-level Verilog.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaSimple.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
#include "cbaPrs.h"
#include "base/abc/abc.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
/*
design = array containing design name (as the first entry in the array) followed by pointers to modules
module = array containing module name (as the first entry in the array) followed by pointers to 6 arrays:
{array of input names; array of output names; array of nodes; array of boxes,
array of floating-point input-arrival times; array of floating-point output-required times}
node = array containing output name, followed by node type, followed by input names
box = array containing model name, instance name, followed by pairs of formal/actual names for each port
Comments:
- in describing boxes
- input formal/actual name pairs should be listed before output name pairs
- the order of formal names should be the same as the order of inputs/outputs in the module description
- all formal names present in the module description should be listed
- if an input pin is not driven or an output pin has no fanout, the actual pin name is NULL
- word-level formal name "a" is written as bit-level names (a[0]. a[1], etc) ordered LSB to MSB
- primitive names should be given as char*-strings in description of nodes and boxes
- primitive modules should not be written, but the list of primitives and formal names should be provided
- constant 0/1 nets can be specified as char*-strings "NetConst0" and "NetConst1".
- arrays of input-arrival/output-required times in the module description are optional
*/
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Node type conversions.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_NodeType_t Ptr_HopToType( Abc_Obj_t * pObj )
{
static word uTruth, uTruths6[3] = {
ABC_CONST(0xAAAAAAAAAAAAAAAA),
ABC_CONST(0xCCCCCCCCCCCCCCCC),
ABC_CONST(0xF0F0F0F0F0F0F0F0),
};
assert( Abc_ObjIsNode(pObj) );
uTruth = Hop_ManComputeTruth6( (Hop_Man_t *)Abc_ObjNtk(pObj)->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj) );
if ( uTruth == 0 ) return CBA_NODE_C0;
if ( uTruth == ~(word)0 ) return CBA_NODE_C1;
if ( uTruth == uTruths6[0] ) return CBA_NODE_BUF;
if ( uTruth == ~uTruths6[0] ) return CBA_NODE_INV;
if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return CBA_NODE_AND;
if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return CBA_NODE_OR;
if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return CBA_NODE_XOR;
if ( uTruth == (uTruths6[0] ^~uTruths6[1]) ) return CBA_NODE_XNOR;
assert( 0 );
return CBA_NODE_NONE;
}
/**Function*************************************************************
Synopsis [Dumping hierarchical Abc_Ntk_t in Ptr form.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Ptr_AbcObjName( Abc_Obj_t * pObj )
{
if ( Abc_ObjIsNet(pObj) || Abc_ObjIsBox(pObj) )
return Abc_ObjName(pObj);
if ( Abc_ObjIsCi(pObj) || Abc_ObjIsNode(pObj) )
return Ptr_AbcObjName(Abc_ObjFanout0(pObj));
if ( Abc_ObjIsCo(pObj) )
return Ptr_AbcObjName(Abc_ObjFanin0(pObj));
assert( 0 );
return NULL;
}
static int Ptr_CheckArray( Vec_Ptr_t * vArray )
{
if ( Vec_PtrSize(vArray) == 0 )
return 1;
if ( Abc_MaxInt(8, Vec_PtrSize(vArray)) == Vec_PtrCap(vArray) )
return 1;
assert( 0 );
return 0;
}
Vec_Ptr_t * Ptr_AbcDeriveNode( Abc_Obj_t * pObj )
{
Abc_Obj_t * pFanin; int i;
Vec_Ptr_t * vNode = Vec_PtrAlloc( 2 + Abc_ObjFaninNum(pObj) );
assert( Abc_ObjIsNode(pObj) );
Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
if ( Abc_NtkHasAig(pObj->pNtk) )
Vec_PtrPush( vNode, Abc_Int2Ptr(Ptr_HopToType(pObj)) );
else if ( Abc_NtkHasSop(pObj->pNtk) )
Vec_PtrPush( vNode, Abc_Int2Ptr(Ptr_SopToType((char *)pObj->pData)) );
else assert( 0 );
Abc_ObjForEachFanin( pObj, pFanin, i )
Vec_PtrPush( vNode, Ptr_AbcObjName(pFanin) );
assert( Ptr_CheckArray(vNode) );
return vNode;
}
Vec_Ptr_t * Ptr_AbcDeriveNodes( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vNodes = Vec_PtrAlloc( Abc_NtkNodeNum(pNtk) );
Abc_NtkForEachNode( pNtk, pObj, i )
Vec_PtrPush( vNodes, Ptr_AbcDeriveNode(pObj) );
assert( Ptr_CheckArray(vNodes) );
return vNodes;
}
Vec_Ptr_t * Ptr_AbcDeriveBox( Abc_Obj_t * pObj )
{
Abc_Obj_t * pNext; int i;
Abc_Ntk_t * pModel = Abc_ObjModel(pObj);
Vec_Ptr_t * vBox = Vec_PtrAlloc( 2 + 2 * Abc_ObjFaninNum(pObj) + 2 * Abc_ObjFanoutNum(pObj) );
assert( Abc_ObjIsBox(pObj) );
Vec_PtrPush( vBox, Abc_NtkName(pModel) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pObj) );
Abc_ObjForEachFanin( pObj, pNext, i )
{
Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPi(pModel, i)) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
}
Abc_ObjForEachFanout( pObj, pNext, i )
{
Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPo(pModel, i)) );
Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
}
assert( Ptr_CheckArray(vBox) );
return vBox;
}
Vec_Ptr_t * Ptr_AbcDeriveBoxes( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vBoxes = Vec_PtrAlloc( Abc_NtkBoxNum(pNtk) );
Abc_NtkForEachBox( pNtk, pObj, i )
Vec_PtrPush( vBoxes, Ptr_AbcDeriveBox(pObj) );
assert( Ptr_CheckArray(vBoxes) );
return vBoxes;
}
Vec_Ptr_t * Ptr_AbcDeriveInputs( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vSigs = Vec_PtrAlloc( Abc_NtkPiNum(pNtk) );
Abc_NtkForEachPi( pNtk, pObj, i )
Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_AbcDeriveOutputs( Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj; int i;
Vec_Ptr_t * vSigs = Vec_PtrAlloc( Abc_NtkPoNum(pNtk) );
Abc_NtkForEachPo( pNtk, pObj, i )
Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_AbcDeriveNtk( Abc_Ntk_t * pNtk )
{
Vec_Ptr_t * vNtk = Vec_PtrAlloc( 5 );
Vec_PtrPush( vNtk, Abc_NtkName(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveInputs(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveOutputs(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveNodes(pNtk) );
Vec_PtrPush( vNtk, Ptr_AbcDeriveBoxes(pNtk) );
assert( Ptr_CheckArray(vNtk) );
return vNtk;
}
Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk )
{
Vec_Ptr_t * vDes;
Abc_Ntk_t * pTemp; int i;
vDes = Vec_PtrAlloc( 1 + Vec_PtrSize(pNtk->pDesign->vModules) );
Vec_PtrPush( vDes, pNtk->pDesign->pName );
Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
Vec_PtrPush( vDes, Ptr_AbcDeriveNtk(pTemp) );
assert( Ptr_CheckArray(vDes) );
return vDes;
}
/**Function*************************************************************
Synopsis [Dumping Ptr into a Verilog file.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ptr_ManDumpNodeBlif( FILE * pFile, Vec_Ptr_t * vNode )
{
char * pName; int i;
fprintf( pFile, ".names" );
Vec_PtrForEachEntryStart( char *, vNode, pName, i, 2 )
fprintf( pFile, " %s", pName );
fprintf( pFile, " %s\n", (char *)Vec_PtrEntry(vNode, 0) );
fprintf( pFile, "%s", Ptr_TypeToSop( Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ) );
}
void Ptr_ManDumpNodesBlif( FILE * pFile, Vec_Ptr_t * vNodes )
{
Vec_Ptr_t * vNode; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
Ptr_ManDumpNodeBlif( pFile, vNode );
}
void Ptr_ManDumpBoxBlif( FILE * pFile, Vec_Ptr_t * vBox )
{
char * pName; int i;
fprintf( pFile, ".subckt %s", (char *)Vec_PtrEntry(vBox, 0) );
Vec_PtrForEachEntryStart( char *, vBox, pName, i, 2 )
fprintf( pFile, " %s=%s", pName, (char *)Vec_PtrEntry(vBox, i+1) ), i++;
fprintf( pFile, "\n" );
}
void Ptr_ManDumpBoxesBlif( FILE * pFile, Vec_Ptr_t * vBoxes )
{
Vec_Ptr_t * vBox; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
Ptr_ManDumpBoxBlif( pFile, vBox );
}
void Ptr_ManDumpSignalsBlif( FILE * pFile, Vec_Ptr_t * vSigs, int fSkipLastComma )
{
char * pSig; int i;
Vec_PtrForEachEntry( char *, vSigs, pSig, i )
fprintf( pFile, " %s", pSig );
}
void Ptr_ManDumpModuleBlif( FILE * pFile, Vec_Ptr_t * vNtk )
{
fprintf( pFile, ".model %s\n", (char *)Vec_PtrEntry(vNtk, 0) );
fprintf( pFile, ".inputs" );
Ptr_ManDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), 0 );
fprintf( pFile, "\n" );
fprintf( pFile, ".outputs" );
Ptr_ManDumpSignalsBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 );
fprintf( pFile, "\n" );
Ptr_ManDumpNodesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) );
Ptr_ManDumpBoxesBlif( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
fprintf( pFile, ".end\n\n" );
}
void Ptr_ManDumpBlif( char * pFileName, Vec_Ptr_t * vDes )
{
FILE * pFile;
Vec_Ptr_t * vNtk; int i;
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL )
{
printf( "Cannot open output file \"%s\".\n", pFileName );
return;
}
fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", (char *)Vec_PtrEntry(vDes, 0), Extra_TimeStamp() );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Ptr_ManDumpModuleBlif( pFile, vNtk );
fclose( pFile );
}
/**Function*************************************************************
Synopsis [Dumping Ptr into a Verilog file.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ptr_ManDumpNodeVerilog( FILE * pFile, Vec_Ptr_t * vNode )
{
char * pName; int i;
fprintf( pFile, "%s", Ptr_TypeToName( (Cba_NodeType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) ) );
fprintf( pFile, "( %s", (char *)Vec_PtrEntry(vNode, 0) );
Vec_PtrForEachEntryStart( char *, vNode, pName, i, 2 )
fprintf( pFile, ", %s", pName );
fprintf( pFile, " );\n" );
}
void Ptr_ManDumpNodesVerilog( FILE * pFile, Vec_Ptr_t * vNodes )
{
Vec_Ptr_t * vNode; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
Ptr_ManDumpNodeVerilog( pFile, vNode );
}
void Ptr_ManDumpBoxVerilog( FILE * pFile, Vec_Ptr_t * vBox )
{
char * pName; int i;
fprintf( pFile, "%s %s (", (char *)Vec_PtrEntry(vBox, 0), (char *)Vec_PtrEntry(vBox, 1) );
Vec_PtrForEachEntryStart( char *, vBox, pName, i, 2 )
fprintf( pFile, " .%s(%s)%s", pName, (char *)Vec_PtrEntry(vBox, i+1), i >= Vec_PtrSize(vBox)-2 ? "" : "," ), i++;
fprintf( pFile, " );\n" );
}
void Ptr_ManDumpBoxesVerilog( FILE * pFile, Vec_Ptr_t * vBoxes )
{
Vec_Ptr_t * vBox; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
Ptr_ManDumpBoxVerilog( pFile, vBox );
}
void Ptr_ManDumpSignalsVerilog( FILE * pFile, Vec_Ptr_t * vSigs, int fSkipLastComma )
{
char * pSig; int i;
Vec_PtrForEachEntry( char *, vSigs, pSig, i )
fprintf( pFile, " %s%s", pSig, (fSkipLastComma && i == Vec_PtrSize(vSigs)-1) ? "" : "," );
}
void Ptr_ManDumpModuleVerilog( FILE * pFile, Vec_Ptr_t * vNtk )
{
fprintf( pFile, "module %s\n", (char *)Vec_PtrEntry(vNtk, 0) );
fprintf( pFile, "(\n" );
Ptr_ManDumpSignalsVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), 0 );
fprintf( pFile, "\n" );
Ptr_ManDumpSignalsVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 );
fprintf( pFile, "\n);\ninput" );
Ptr_ManDumpSignalsVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), 1 );
fprintf( pFile, ";\noutput" );
Ptr_ManDumpSignalsVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 1 );
fprintf( pFile, ";\n\n" );
Ptr_ManDumpNodesVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) );
fprintf( pFile, "\n" );
Ptr_ManDumpBoxesVerilog( pFile, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
fprintf( pFile, "endmodule\n\n" );
}
void Ptr_ManDumpVerilog( char * pFileName, Vec_Ptr_t * vDes )
{
FILE * pFile;
Vec_Ptr_t * vNtk; int i;
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL )
{
printf( "Cannot open output file \"%s\".\n", pFileName );
return;
}
fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", (char *)Vec_PtrEntry(vDes, 0), Extra_TimeStamp() );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Ptr_ManDumpModuleVerilog( pFile, vNtk );
fclose( pFile );
}
/**Function*************************************************************
Synopsis [Count memory used by Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Ptr_ManMemArray( Vec_Ptr_t * vArray )
{
return (int)Vec_PtrMemory(vArray);
}
int Ptr_ManMemArrayArray( Vec_Ptr_t * vArrayArray )
{
Vec_Ptr_t * vArray; int i, nBytes = 0;
Vec_PtrForEachEntry( Vec_Ptr_t *, vArrayArray, vArray, i )
nBytes += Ptr_ManMemArray(vArray);
return nBytes;
}
int Ptr_ManMemNtk( Vec_Ptr_t * vNtk )
{
int nBytes = (int)Vec_PtrMemory(vNtk);
nBytes += Ptr_ManMemArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1) );
nBytes += Ptr_ManMemArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2) );
nBytes += Ptr_ManMemArrayArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3) );
nBytes += Ptr_ManMemArrayArray( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4) );
return nBytes;
}
int Ptr_ManMemDes( Vec_Ptr_t * vDes )
{
Vec_Ptr_t * vNtk; int i, nBytes = (int)Vec_PtrMemory(vDes);
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
nBytes += Ptr_ManMemNtk(vNtk);
return nBytes;
}
/**Function*************************************************************
Synopsis [Free Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ptr_ManFreeNtk( Vec_Ptr_t * vNtk )
{
Vec_PtrFree( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1) );
Vec_PtrFree( (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2) );
Vec_VecFree( (Vec_Vec_t *)Vec_PtrEntry(vNtk, 3) );
Vec_VecFree( (Vec_Vec_t *)Vec_PtrEntry(vNtk, 4) );
Vec_PtrFree( vNtk );
}
void Ptr_ManFreeDes( Vec_Ptr_t * vDes )
{
Vec_Ptr_t * vNtk; int i;
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Ptr_ManFreeNtk( vNtk );
Vec_PtrFree( vDes );
}
/**Function*************************************************************
Synopsis [Count memory use used by Ptr.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ptr_ManExperiment( Abc_Ntk_t * pNtk )
{
abctime clk = Abc_Clock();
char * pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out.blif");
Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
printf( "Converting to Ptr: Memory = %6.3f MB ", 1.0*Ptr_ManMemDes(vDes)/(1<<20) );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
Ptr_ManDumpBlif( pFileName, vDes );
printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
Ptr_ManFreeDes( vDes );
}
/**Function*************************************************************
Synopsis [Dumping hierarchical Cba_Ntk_t in Ptr form.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Ptr_t * Ptr_CbaDeriveNode( Cba_Ntk_t * pNtk, int iObj )
{
Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
Vec_Ptr_t * vNode = Vec_PtrAlloc( 2 + Vec_IntSize(vFanins) );
int i, iFanin;
assert( Cba_ObjIsNode(pNtk, iObj) );
Vec_PtrPush( vNode, Cba_ObjNameStr(pNtk, iObj) );
if ( Abc_NamObjNumMax(pNtk->pDesign->pFuncs) > 1 )
Vec_PtrPush( vNode, Cba_NtkFuncStr( pNtk, Cba_ObjFuncId(pNtk, iObj) ) );
else
Vec_PtrPush( vNode, Abc_Int2Ptr(Cba_ObjFuncId(pNtk, iObj)) );
Vec_IntForEachEntry( vFanins, iFanin, i )
Vec_PtrPush( vNode, Cba_ObjNameStr(pNtk, iFanin) );
assert( Ptr_CheckArray(vNode) );
return vNode;
}
Vec_Ptr_t * Ptr_CbaDeriveNodes( Cba_Ntk_t * pNtk )
{
int i;
Vec_Ptr_t * vNodes = Vec_PtrAlloc( Cba_NtkNodeNum(pNtk) );
Cba_NtkForEachNode( pNtk, i )
Vec_PtrPush( vNodes, Ptr_CbaDeriveNode(pNtk, i) );
assert( Ptr_CheckArray(vNodes) );
return vNodes;
}
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_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) );
Vec_PtrPush( vBox, Cba_NtkName(pModel) );
Vec_PtrPush( vBox, Vec_IntSize(&pNtk->vInstIds) ? Cba_ObjInstStr(pNtk, iObj) : NULL );
Cba_NtkForEachPi( pModel, iTerm, i )
{
Vec_PtrPush( vBox, Cba_ObjNameStr(pModel, iTerm) );
Vec_PtrPush( vBox, Cba_ObjNameStr(pNtk, Vec_IntEntry(vFanins, i)) );
}
Cba_NtkForEachPo( pModel, iTerm, i )
{
Vec_PtrPush( vBox, Cba_ObjNameStr(pModel, iTerm) );
Vec_PtrPush( vBox, Cba_ObjNameStr(pNtk, iObj+1+i) );
}
assert( Ptr_CheckArray(vBox) );
return vBox;
}
Vec_Ptr_t * Ptr_CbaDeriveBoxes( Cba_Ntk_t * pNtk )
{
int i;
Vec_Ptr_t * vBoxes = Vec_PtrAlloc( Cba_NtkBoxNum(pNtk) );
Cba_NtkForEachBox( pNtk, i )
Vec_PtrPush( vBoxes, Ptr_CbaDeriveBox(pNtk, i) );
assert( Ptr_CheckArray(vBoxes) );
return vBoxes;
}
Vec_Ptr_t * Ptr_CbaDeriveInputs( Cba_Ntk_t * pNtk )
{
int i, iObj;
Vec_Ptr_t * vSigs = Vec_PtrAlloc( Cba_NtkPiNum(pNtk) );
Cba_NtkForEachPi( pNtk, iObj, i )
Vec_PtrPush( vSigs, Cba_ObjNameStr(pNtk, iObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_CbaDeriveOutputs( Cba_Ntk_t * pNtk )
{
int i, iObj;
Vec_Ptr_t * vSigs = Vec_PtrAlloc( Cba_NtkPoNum(pNtk) );
Cba_NtkForEachPo( pNtk, iObj, i )
Vec_PtrPush( vSigs, Cba_ObjNameStr(pNtk, iObj) );
assert( Ptr_CheckArray(vSigs) );
return vSigs;
}
Vec_Ptr_t * Ptr_CbaDeriveNtk( Cba_Ntk_t * pNtk )
{
Vec_Ptr_t * vNtk = Vec_PtrAlloc( 5 );
Vec_PtrPush( vNtk, Cba_NtkName(pNtk) );
Vec_PtrPush( vNtk, Ptr_CbaDeriveInputs(pNtk) );
Vec_PtrPush( vNtk, Ptr_CbaDeriveOutputs(pNtk) );
Vec_PtrPush( vNtk, Ptr_CbaDeriveNodes(pNtk) );
Vec_PtrPush( vNtk, Ptr_CbaDeriveBoxes(pNtk) );
assert( Ptr_CheckArray(vNtk) );
return vNtk;
}
Vec_Ptr_t * Ptr_CbaDeriveDes( Cba_Man_t * p )
{
Vec_Ptr_t * vDes;
Cba_Ntk_t * pTemp; int i;
vDes = Vec_PtrAlloc( 1 + Cba_ManNtkNum(p) );
Vec_PtrPush( vDes, p->pName );
Cba_ManForEachNtk( p, pTemp, i )
Vec_PtrPush( vDes, Ptr_CbaDeriveNtk(pTemp) );
assert( Ptr_CheckArray(vDes) );
return vDes;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Int_t * Cba_PrsReadList( Cba_Man_t * p, Vec_Ptr_t * vNames, Vec_Int_t * vList, int nSkip, int nSkip2 )
{
char * pName; int i;
Vec_IntClear( vList );
Vec_PtrForEachEntry( char *, vNames, pName, i )
if ( i != nSkip && i != nSkip2 )
Vec_IntPush( vList, Abc_NamStrFindOrAdd(p->pNames, pName, NULL) );
return vList;
}
void Cba_PrsReadNodes( Cba_Man_t * p, Vec_Ptr_t * vNodes, Vec_Int_t * vTypesCur, Vec_Int_t * vFuncsCur, Vec_Int_t * vFaninsCur, Vec_Int_t * vInstIdsCur, Vec_Int_t * vList )
{
Vec_Ptr_t * vNode; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
{
Vec_IntPush( vTypesCur, CBA_OBJ_NODE );
Vec_IntPush( vFuncsCur, (Cba_NodeType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) );
Vec_IntPush( vFaninsCur, Cba_ManHandleArray(p, Cba_PrsReadList(p, vNode, vList, 1, -1)) );
Vec_IntPush( vInstIdsCur, 0 );
}
}
void Cba_PrsReadBoxes( Cba_Man_t * p, Vec_Ptr_t * vBoxes, Vec_Int_t * vTypesCur, Vec_Int_t * vFuncsCur, Vec_Int_t * vFaninsCur, Vec_Int_t * vInstIdsCur, Vec_Int_t * vList )
{
Vec_Ptr_t * vBox; int i;
Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
{
Vec_IntPush( vTypesCur, CBA_OBJ_BOX );
Vec_IntPush( vFuncsCur, Abc_NamStrFindOrAdd(p->pModels, Vec_PtrEntry(vBox, 0), NULL) );
Vec_IntPush( vFaninsCur, Cba_ManHandleArray(p, Cba_PrsReadList(p, vBox, vList, 0, 1)) );
Vec_IntPush( vInstIdsCur, Abc_NamStrFindOrAdd(p->pNames, Vec_PtrEntry(vBox, 1), NULL) );
}
}
void Cba_PrsReadModule( Cba_Man_t * p, Cba_Ntk_t * pNtk, Vec_Ptr_t * vNtk, Vec_Int_t * vList )
{
Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
Vec_Ptr_t * vNodes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3);
Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
Cba_ManAllocArray( p, &pNtk->vInputs, Vec_PtrSize(vInputs) );
Cba_ManAllocArray( p, &pNtk->vOutputs, Vec_PtrSize(vOutputs) );
Cba_ManAllocArray( p, &pNtk->vTypes, Vec_PtrSize(vNodes) + Vec_PtrSize(vBoxes) );
Cba_ManAllocArray( p, &pNtk->vFuncs, Vec_PtrSize(vNodes) + Vec_PtrSize(vBoxes) );
Cba_ManAllocArray( p, &pNtk->vFanins, Vec_PtrSize(vNodes) + Vec_PtrSize(vBoxes) );
Cba_ManAllocArray( p, &pNtk->vInstIds, Vec_PtrSize(vNodes) + Vec_PtrSize(vBoxes) );
Cba_PrsReadList( p, vInputs, &pNtk->vInputs, -1, -1 );
Cba_PrsReadList( p, vOutputs, &pNtk->vOutputs, -1, -1 );
Cba_PrsReadNodes( p, vNodes, &pNtk->vTypes, &pNtk->vFuncs, &pNtk->vFanins, &pNtk->vInstIds, vList );
Cba_PrsReadBoxes( p, vBoxes, &pNtk->vTypes, &pNtk->vFuncs, &pNtk->vFanins, &pNtk->vInstIds, vList );
}
Cba_Man_t * Cba_PrsReadPtr( Vec_Ptr_t * vDes )
{
Vec_Ptr_t * vNtk; int i;
Vec_Int_t * vList = Vec_IntAlloc( 100 );
Cba_Man_t * p = Cba_ManAlloc( NULL, (char *)Vec_PtrEntry(vDes, 0) );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Cba_NtkAlloc( p, (char *)Vec_PtrEntry(vNtk, 0) );
Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
Cba_PrsReadModule( p, Cba_ManNtk(p, i), vNtk, vList );
Vec_IntFree( vList );
return p;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk )
{
extern Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p );
abctime clk = Abc_Clock();
Cba_Man_t * p, * pTemp;
char * pFileName;
// derive Ptr from ABC
Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
printf( "Converting to Ptr: Memory = %6.3f MB ", 1.0*Ptr_ManMemDes(vDes)/(1<<20) );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
// dump
pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out1.blif");
// Ptr_ManDumpBlif( pFileName, vDes );
printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
clk = Abc_Clock();
// derive CBA from Ptr
p = Cba_PrsReadPtr( vDes );
Ptr_ManFreeDes( vDes );
// dump
pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out2.blif");
// Cba_PrsWriteBlif( pFileName, p );
printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
// Abc_NamPrint( p->pNames );
clk = Abc_Clock();
// build CBA from CBA
p = Cba_ManBuild( pTemp = p );
Cba_ManFree( pTemp );
// dump
pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out3.blif");
// Cba_ManWriteBlif( pFileName, p );
printf( "Finished writing output file \"%s\". ", pFileName );
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
clk = Abc_Clock();
// 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 );
clk = Abc_Clock();
// 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 );
clk = Abc_Clock();
Cba_ManFree( p );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
src/base/cba/cbaWriteBlif.c
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Verilog parser.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
Date [Ver. 1.0. Started - November 29, 2014.] Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cbaWriteVer.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $] Revision [$Id: cbaWriteBlif.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/ ***********************************************************************/
...@@ -44,84 +44,79 @@ ABC_NAMESPACE_IMPL_START ...@@ -44,84 +44,79 @@ ABC_NAMESPACE_IMPL_START
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Cba_PrsWriteBlifArray( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins, int fFirst ) void Prs_ManWriteBlifArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vFanins )
{ {
int NameId, i; int i, NameId;
Vec_IntForEachEntryStart( vFanins, NameId, i, fFirst ) Vec_IntForEachEntry( vFanins, NameId, i )
fprintf( pFile, " %s", Cba_NtkStr(p, NameId) ); fprintf( pFile, " %s", Prs_NtkStr(p, NameId) );
if ( fFirst )
fprintf( pFile, " %s", Cba_NtkStr(p, Vec_IntEntry(vFanins,0)) );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
} }
void Cba_PrsWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins ) void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
{ {
int FormId, NameId, i; Vec_Int_t * vBox;
assert( Vec_IntSize(vFanins) % 2 == 0 ); int i, k, FormId, ActId;
Vec_IntForEachEntryDouble( vFanins, FormId, NameId, i ) Prs_NtkForEachBox( p, vBox, i )
fprintf( pFile, " %s=%s", Cba_NtkStr(p, FormId), Cba_NtkStr(p, NameId) ); {
fprintf( pFile, "\n" ); int NtkId = Prs_BoxNtk(p, i);
} assert( Prs_BoxIONum(p, i) > 0 );
void Cba_PrsWriteBlifLines( FILE * pFile, Cba_Ntk_t * p ) assert( Vec_IntSize(vBox) % 2 == 0 );
{ if ( NtkId == -1 ) // latch
int i, Type; {
Cba_NtkForEachObjType( p, Type, i ) fprintf( pFile, ".latch" );
if ( Type == CBA_OBJ_NODE ) // .names/assign/box2 (no formal/actual binding) fprintf( pFile, " %s", Prs_NtkStr(p, Vec_IntEntry(vBox, 1)) );
fprintf( pFile, " %s", Prs_NtkStr(p, Vec_IntEntry(vBox, 3)) );
fprintf( pFile, " %c\n", '0' + Prs_BoxName(p, i) );
}
else if ( Prs_BoxIsNode(p, i) ) // node
{ {
fprintf( pFile, ".names" ); fprintf( pFile, ".names" );
Cba_PrsWriteBlifArray( pFile, p, Cba_ObjFaninVec(p, i), 1 ); Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
//fprintf( pFile, "%s", Cba_NtkFuncStr(p, Cba_ObjFuncId(p, i)) ); fprintf( pFile, " %s", Prs_NtkStr(p, ActId) );
fprintf( pFile, "%s", Ptr_TypeToSop( Cba_ObjFuncId(p, i) ) ); fprintf( pFile, "\n%s", Prs_NtkStr(p, NtkId) );
} }
else if ( Type == CBA_OBJ_BOX ) // .names/assign/box2 (no formal/actual binding) else // box
{ {
fprintf( pFile, ".subckt" ); fprintf( pFile, ".subckt" );
fprintf( pFile, " %s", Cba_NtkName(Cba_ObjBoxModel(p, i)) ); fprintf( pFile, " %s", Prs_NtkStr(p, NtkId) );
Cba_PrsWriteBlifArray2( pFile, p, Cba_ObjFaninVec(p, i) ); Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
fprintf( pFile, " %s=%s", Prs_NtkStr(p, FormId), Prs_NtkStr(p, ActId) );
fprintf( pFile, "\n" );
} }
else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding)
{
Vec_Int_t * vFanins = Cba_ObjFaninVec(p, i);
fprintf( pFile, ".latch" );
fprintf( pFile, " %s", Cba_NtkStr(p, Vec_IntEntry(vFanins, 1)) );
fprintf( pFile, " %s", Cba_NtkStr(p, Vec_IntEntry(vFanins, 0)) );
fprintf( pFile, " %c\n", '0' + Cba_ObjFuncId(p, i) );
} }
} }
void Cba_PrsWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p ) void Prs_ManWriteBlifNtk( FILE * pFile, Prs_Ntk_t * p )
{ {
assert( Vec_IntSize(&p->vTypes) == Cba_NtkObjNum(p) );
assert( Vec_IntSize(&p->vFuncs) == Cba_NtkObjNum(p) );
// write header // write header
fprintf( pFile, ".model %s\n", Cba_NtkName(p) ); fprintf( pFile, ".model %s\n", Prs_NtkStr(p, p->iModuleName) );
if ( Vec_IntSize(&p->vInouts) ) if ( Vec_IntSize(&p->vInouts) )
fprintf( pFile, ".inouts" ); fprintf( pFile, ".inouts" );
if ( Vec_IntSize(&p->vInouts) ) if ( Vec_IntSize(&p->vInouts) )
Cba_PrsWriteBlifArray( pFile, p, &p->vInouts, 0 ); Prs_ManWriteBlifArray( pFile, p, &p->vInouts );
fprintf( pFile, ".inputs" ); fprintf( pFile, ".inputs" );
Cba_PrsWriteBlifArray( pFile, p, &p->vInputs, 0 ); Prs_ManWriteBlifArray( pFile, p, &p->vInputs );
fprintf( pFile, ".outputs" ); fprintf( pFile, ".outputs" );
Cba_PrsWriteBlifArray( pFile, p, &p->vOutputs, 0 ); Prs_ManWriteBlifArray( pFile, p, &p->vOutputs );
// write objects // write objects
Cba_PrsWriteBlifLines( pFile, p ); Prs_ManWriteBlifLines( pFile, p );
fprintf( pFile, ".end\n\n" ); fprintf( pFile, ".end\n\n" );
} }
void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * p ) void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * vPrs )
{ {
FILE * pFile; Prs_Ntk_t * pNtk = Prs_ManRoot(vPrs);
Cba_Ntk_t * pNtk; FILE * pFile = fopen( pFileName, "wb" ); int i;
int i;
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL ) if ( pFile == NULL )
{ {
printf( "Cannot open output file \"%s\".\n", pFileName ); printf( "Cannot open output file \"%s\".\n", pFileName );
return; return;
} }
fprintf( pFile, "# Design \"%s\" written by ABC on %s\n\n", Cba_ManName(p), Extra_TimeStamp() ); fprintf( pFile, "# Design \"%s\" written by ABC on %s\n\n", Prs_NtkStr(pNtk, pNtk->iModuleName), Extra_TimeStamp() );
Cba_ManForEachNtk( p, pNtk, i ) Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
Cba_PrsWriteBlifNtk( pFile, pNtk ); Prs_ManWriteBlifNtk( pFile, pNtk );
fclose( pFile ); fclose( pFile );
} }
/**Function************************************************************* /**Function*************************************************************
Synopsis [Write elaborated design.] Synopsis [Write elaborated design.]
...@@ -153,67 +148,52 @@ void Cba_ManWriteBlifArray( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins, in ...@@ -153,67 +148,52 @@ void Cba_ManWriteBlifArray( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins, in
void Cba_ManWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, int iObj ) void Cba_ManWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, int iObj )
{ {
int iTerm, i; int iTerm, i;
Cba_Ntk_t * pModel = Cba_ObjBoxModel( p, iObj ); Cba_Ntk_t * pModel = Cba_BoxNtk( p, iObj );
Cba_NtkForEachPi( pModel, iTerm, i ) Cba_NtkForEachPi( pModel, iTerm, i )
fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_ObjBoxBi(p, iObj, i)) ); fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_BoxBi(p, iObj, i)) );
Cba_NtkForEachPo( pModel, iTerm, i ) Cba_NtkForEachPo( pModel, iTerm, i )
fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_ObjBoxBo(p, iObj, i)) ); fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_BoxBo(p, iObj, i)) );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
} }
void Cba_ManWriteBlifLines( FILE * pFile, Cba_Ntk_t * p ) void Cba_ManWriteBlifLines( FILE * pFile, Cba_Ntk_t * p )
{ {
int Type, i; int i, k, iTerm;
Cba_NtkForEachObjType( p, Type, i ) Cba_NtkForEachBox( p, i )
{ {
if ( Type == CBA_OBJ_NODE ) // .names/assign/box2 (no formal/actual binding) if ( Cba_ObjIsBoxUser(p, i) )
{ {
if ( p->pDesign->pMioLib ) // mapped fprintf( pFile, ".subckt" );
{ fprintf( pFile, " %s", Cba_NtkName(Cba_BoxNtk(p, i)) );
char * pGateName = Abc_NamStr( p->pDesign->pFuncs, Cba_ObjFuncId(p, i) ); Cba_ManWriteBlifArray2( pFile, p, i );
Mio_Gate_t * pGate = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pDesign->pMioLib, pGateName, NULL );
fprintf( pFile, ".gate %s", pGateName );
Cba_ManWriteBlifGate( pFile, p, pGate, Cba_ObjFaninVec(p, i), i );
} }
else if ( Abc_NamObjNumMax(p->pDesign->pFuncs) > 1 ) // SOP functions else if ( Cba_ObjIsGate(p, i) )
{ {
fprintf( pFile, ".names" ); char * pGateName = Abc_NamStr(p->pDesign->pMods, Cba_BoxNtkId(p, i));
Cba_ManWriteBlifArray( pFile, p, Cba_ObjFaninVec(p, i), i ); Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen( Abc_FrameGetGlobalFrame() );
fprintf( pFile, "%s", Cba_ObjFuncStr(p, i) ); Mio_Gate_t * pGate = Mio_LibraryReadGateByName( pLib, pGateName, NULL );
fprintf( pFile, ".gate %s", pGateName );
Cba_BoxForEachBi( p, i, iTerm, k )
fprintf( pFile, " %s=%s", Mio_GateReadPinName(pGate, k), Cba_ObjNameStr(p, iTerm) );
Cba_BoxForEachBo( p, i, iTerm, k )
fprintf( pFile, " %s=%s", Mio_GateReadOutName(pGate), Cba_ObjNameStr(p, iTerm) );
fprintf( pFile, "\n" );
} }
else else
{ {
fprintf( pFile, ".names" ); fprintf( pFile, ".names" );
Cba_ManWriteBlifArray( pFile, p, Cba_ObjFaninVec(p, i), i ); Cba_BoxForEachBi( p, i, iTerm, k )
//fprintf( pFile, "%s", Cba_NtkFuncStr(p, Cba_ObjFuncId(p, i)) ); fprintf( pFile, " %s", Cba_ObjNameStr(p, iTerm) );
fprintf( pFile, "%s", Ptr_TypeToSop( Cba_ObjFuncId(p, i) ) ); Cba_BoxForEachBo( p, i, iTerm, k )
} fprintf( pFile, " %s", Cba_ObjNameStr(p, iTerm) );
} fprintf( pFile, "\n%s", Ptr_TypeToSop(Cba_ObjType(p, i)) );
else if ( Type == CBA_OBJ_BOX ) // .names/assign/box2 (no formal/actual binding)
{
fprintf( pFile, ".subckt" );
fprintf( pFile, " %s", Cba_NtkName(Cba_ObjBoxModel(p, i)) );
Cba_ManWriteBlifArray2( pFile, p, i );
}
else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding)
{
Vec_Int_t * vFanins = Cba_ObjFaninVec(p, i);
fprintf( pFile, ".latch" );
fprintf( pFile, " %s", Cba_ObjNameStr(p, Vec_IntEntry(vFanins, 1)) );
fprintf( pFile, " %s", Cba_ObjNameStr(p, Vec_IntEntry(vFanins, 0)) );
fprintf( pFile, " %c\n", '0' + Cba_ObjFuncId(p, i) );
} }
} }
} }
void Cba_ManWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p ) void Cba_ManWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p )
{ {
assert( Vec_IntSize(&p->vTypes) == Cba_NtkObjNum(p) ); assert( Vec_IntSize(&p->vFanin) == Cba_NtkObjNum(p) );
assert( Vec_IntSize(&p->vFuncs) == Cba_NtkObjNum(p) );
// write header // write header
fprintf( pFile, ".model %s\n", Cba_NtkName(p) ); fprintf( pFile, ".model %s\n", Cba_NtkName(p) );
if ( Vec_IntSize(&p->vInouts) )
fprintf( pFile, ".inouts" );
if ( Vec_IntSize(&p->vInouts) )
Cba_ManWriteBlifArray( pFile, p, &p->vInouts, -1 );
fprintf( pFile, ".inputs" ); fprintf( pFile, ".inputs" );
Cba_ManWriteBlifArray( pFile, p, &p->vInputs, -1 ); Cba_ManWriteBlifArray( pFile, p, &p->vInputs, -1 );
fprintf( pFile, ".outputs" ); fprintf( pFile, ".outputs" );
...@@ -228,7 +208,7 @@ void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p ) ...@@ -228,7 +208,7 @@ void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p )
Cba_Ntk_t * pNtk; Cba_Ntk_t * pNtk;
int i; int i;
// check the library // check the library
if ( Abc_NamObjNumMax(p->pFuncs) > 1 && p->pMioLib != Abc_FrameReadLibGen() ) if ( p->pMioLib && p->pMioLib != Abc_FrameReadLibGen() )
{ {
printf( "Genlib library used in the mapped design is not longer a current library.\n" ); printf( "Genlib library used in the mapped design is not longer a current library.\n" );
return; return;
......
src/base/cba/cbaWriteVer.c
/**CFile**************************************************************** /**CFile****************************************************************
FileName [cba.c] FileName [cbaWriteVer.c]
SystemName [ABC: Logic synthesis and verification system.] SystemName [ABC: Logic synthesis and verification system.]
PackageName [Verilog parser.] PackageName [Hierarchical word-level netlist.]
Synopsis [Parses several flavors of word-level Verilog.] Synopsis [Verilog writer.]
Author [Alan Mishchenko] Author [Alan Mishchenko]
...@@ -14,12 +14,13 @@ ...@@ -14,12 +14,13 @@
Date [Ver. 1.0. Started - November 29, 2014.] Date [Ver. 1.0. Started - November 29, 2014.]
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $] Revision [$Id: cbaWriteVer.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/ ***********************************************************************/
#include "cba.h" #include "cba.h"
#include "cbaPrs.h" #include "cbaPrs.h"
#include "base/main/main.h"
ABC_NAMESPACE_IMPL_START ABC_NAMESPACE_IMPL_START
...@@ -42,147 +43,142 @@ ABC_NAMESPACE_IMPL_START ...@@ -42,147 +43,142 @@ ABC_NAMESPACE_IMPL_START
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Cba_PrsWriteVerilogMux( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins ) void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
{ {
int NameId, RangeId, i; extern void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd );
char * pStrs[4] = { " = ", " ? ", " : ", ";\n" }; Vec_Int_t * vSigs = Prs_CatSignals(p, Con);
assert( Vec_IntSize(vFanins) == 8 );
fprintf( pFile, " assign " );
Vec_IntForEachEntryDouble( vFanins, NameId, RangeId, i )
{
fprintf( pFile, "%s%s%s", Cba_NtkStr(p, NameId), RangeId > 0 ? Cba_NtkStr(p, RangeId) : "", pStrs[i/2] );
}
}
void Cba_PrsWriteVerilogConcat( FILE * pFile, Cba_Ntk_t * p, int Id )
{
extern void Cba_PrsWriteVerilogArray2( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins );
fprintf( pFile, "{" ); fprintf( pFile, "{" );
Cba_PrsWriteVerilogArray2( pFile, p, Cba_ObjFaninVec2(p, Id) ); Prs_ManWriteVerilogArray( pFile, p, vSigs, 0, Vec_IntSize(vSigs), 0 );
fprintf( pFile, "}" ); fprintf( pFile, "}" );
} }
void Cba_PrsWriteVerilogArray2( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins ) void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
{ {
int NameId, RangeId, i; int Value = Abc_Lit2Var2( Sig );
assert( Vec_IntSize(vFanins) % 2 == 0 ); Prs_ManType_t Type = Abc_Lit2Att2( Sig );
Vec_IntForEachEntryDouble( vFanins, NameId, RangeId, i ) if ( Type == CBA_PRS_NAME || Type == CBA_PRS_CONST )
{ fprintf( pFile, "%s", Prs_NtkStr(p, Value) );
assert( RangeId >= -2 ); else if ( Type == CBA_PRS_SLICE )
if ( RangeId == -2 ) fprintf( pFile, "%s%s", Prs_NtkStr(p, Prs_SliceName(p, Value)), Prs_NtkStr(p, Prs_SliceRange(p, Value)) );
Cba_PrsWriteVerilogConcat( pFile, p, NameId-1 ); else if ( Type == CBA_PRS_CONCAT )
else if ( RangeId == -1 ) Prs_ManWriteVerilogConcat( pFile, p, Value );
fprintf( pFile, "%s", Cba_NtkStr(p, NameId) ); else assert( 0 );
else
fprintf( pFile, "%s%s", Cba_NtkStr(p, NameId), RangeId ? Cba_NtkStr(p, RangeId) : "" );
fprintf( pFile, "%s", (i == Vec_IntSize(vFanins) - 2) ? "" : ", " );
}
} }
void Cba_PrsWriteVerilogArray3( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins ) void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd )
{ {
int FormId, NameId, RangeId, i; int i, Sig;
assert( Vec_IntSize(vFanins) % 3 == 0 ); assert( Vec_IntSize(vSigs) > 0 );
Vec_IntForEachEntryTriple( vFanins, FormId, NameId, RangeId, i ) Vec_IntForEachEntryStartStop( vSigs, Sig, i, Start, Stop )
{ {
fprintf( pFile, ".%s(", Cba_NtkStr(p, FormId) ); if ( fOdd && !(i & 1) )
if ( RangeId == -2 ) continue;
Cba_PrsWriteVerilogConcat( pFile, p, NameId-1 ); Prs_ManWriteVerilogSignal( pFile, p, Sig );
else if ( RangeId == -1 ) fprintf( pFile, "%s", i == Stop - 1 ? "" : ", " );
fprintf( pFile, "%s", Cba_NtkStr(p, NameId) );
else
fprintf( pFile, "%s%s", Cba_NtkStr(p, NameId), RangeId ? Cba_NtkStr(p, RangeId) : "" );
fprintf( pFile, ")%s", (i == Vec_IntSize(vFanins) - 3) ? "" : ", " );
} }
} }
void Cba_PrsWriteVerilogNodes( FILE * pFile, Cba_Ntk_t * p ) void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
{ {
int Type, Func, i; int i, FormId, ActSig;
Cba_NtkForEachObjType( p, Type, i ) assert( Vec_IntSize(vSigs) % 2 == 0 );
if ( Type == CBA_OBJ_NODE ) // .names/assign/box2 (no formal/actual binding) Vec_IntForEachEntryDouble( vSigs, FormId, ActSig, i )
{
Func = Cba_ObjFuncId(p, i);
if ( Func >= CBA_NODE_BUF && Func <= CBA_NODE_XNOR )
{ {
fprintf( pFile, " %s (", Ptr_TypeToName(Func) ); fprintf( pFile, "." );
Cba_PrsWriteVerilogArray2( pFile, p, Cba_ObjFaninVec(p, i) ); fprintf( pFile, "%s", Prs_NtkStr(p, FormId) );
fprintf( pFile, ");\n" ); fprintf( pFile, "(" );
Prs_ManWriteVerilogSignal( pFile, p, ActSig );
fprintf( pFile, ")%s", (i == Vec_IntSize(vSigs) - 2) ? "" : ", " );
} }
else if ( Func == CBA_NODE_MUX ) }
Cba_PrsWriteVerilogMux( pFile, p, Cba_ObjFaninVec(p, i) ); void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
else {
int i, FormId, ActSig;
char * pStrs[4] = { " = ", " ? ", " : ", ";\n" };
assert( Vec_IntSize(vSigs) == 8 );
fprintf( pFile, " assign " );
Prs_ManWriteVerilogSignal( pFile, p, Vec_IntEntryLast(vSigs) );
fprintf( pFile, "%s", pStrs[0] );
Vec_IntForEachEntryDouble( vSigs, FormId, ActSig, i )
{ {
//char * pName = Cba_NtkStr(p, Func); Prs_ManWriteVerilogSignal( pFile, p, ActSig );
assert( 0 ); fprintf( pFile, "%s", pStrs[1+i/2] );
} if ( i == 4 )
break;
} }
} }
void Cba_PrsWriteVerilogBoxes( FILE * pFile, Cba_Ntk_t * p ) void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
{ {
int i; Vec_Int_t * vBox; int i;
Cba_NtkForEachBox( p, i ) // .subckt/.gate/box (formal/actual binding) Prs_NtkForEachBox( p, vBox, i )
{
int NtkId = Prs_BoxNtk(p, i);
if ( NtkId == CBA_BOX_MUX )
Prs_ManWriteVerilogMux( pFile, p, vBox );
else if ( Prs_BoxIsNode(p, i) ) // node ------- check order of fanins
{ {
fprintf( pFile, " %s %s (", Cba_NtkName(Cba_ObjBoxModel(p, i)), Cba_ObjInstStr(p, i) ); fprintf( pFile, " %s (", Ptr_TypeToName(NtkId) );
Cba_PrsWriteVerilogArray3( pFile, p, Cba_ObjFaninVec(p, i) ); Prs_ManWriteVerilogSignal( pFile, p, Vec_IntEntryLast(vBox) );
if ( Prs_BoxIONum(p, i) > 1 )
fprintf( pFile, ", " );
Prs_ManWriteVerilogArray( pFile, p, vBox, 0, Vec_IntSize(vBox)-2, 1 );
fprintf( pFile, ");\n" ); fprintf( pFile, ");\n" );
} }
else // box
{
//char * s = Prs_NtkStr(p, Vec_IntEntry(vBox, 0));
fprintf( pFile, " %s %s (", Prs_NtkStr(p, NtkId), Prs_BoxName(p, i) ? Prs_NtkStr(p, Prs_BoxName(p, i)) : "" );
Prs_ManWriteVerilogArray2( pFile, p, vBox );
fprintf( pFile, ");\n" );
}
}
} }
void Cba_PrsWriteVerilogSignals( FILE * pFile, Cba_Ntk_t * p, int SigType ) void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
{ {
int NameId, RangeId, i; int NameId, RangeId, i;
char * pSigNames[4] = { "inout", "input", "output", "wire" }; char * pSigNames[4] = { "inout", "input", "output", "wire" };
Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires }; Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires };
Vec_IntForEachEntryDouble( vSigs[SigType], NameId, RangeId, i ) Vec_Int_t * vSigsR[4] = { &p->vInoutsR, &p->vInputsR, &p->vOutputsR, &p->vWiresR };
fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Cba_NtkStr(p, RangeId) : "", Cba_NtkStr(p, NameId) ); if ( SigType == 3 )
fprintf( pFile, "\n" );
Vec_IntForEachEntryTwo( vSigs[SigType], vSigsR[SigType], NameId, RangeId, i )
fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Prs_NtkStr(p, RangeId) : "", Prs_NtkStr(p, NameId) );
} }
void Cba_PrsWriteVerilogSignalList( FILE * pFile, Cba_Ntk_t * p, int SigType, int fSkipComma ) void Prs_ManWriteVerilogIoOrder( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vOrder )
{ {
int NameId, RangeId, i; int i, NameId;
Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires }; Vec_IntForEachEntry( vOrder, NameId, i )
Vec_IntForEachEntryDouble( vSigs[SigType], NameId, RangeId, i ) fprintf( pFile, "%s%s", Prs_NtkStr(p, NameId), i == Vec_IntSize(vOrder) - 1 ? "" : ", " );
fprintf( pFile, "%s%s", Cba_NtkStr(p, NameId), (fSkipComma && i == Vec_IntSize(vSigs[SigType]) - 2) ? "" : ", " );
} }
void Cba_PrsWriteVerilogNtk( FILE * pFile, Cba_Ntk_t * p ) void Prs_ManWriteVerilogNtk( FILE * pFile, Prs_Ntk_t * p )
{ {
int s; int s;
assert( Vec_IntSize(&p->vTypes) == Cba_NtkObjNum(p) );
assert( Vec_IntSize(&p->vFuncs) == Cba_NtkObjNum(p) );
assert( Vec_IntSize(&p->vInstIds) == Cba_NtkObjNum(p) );
// write header // write header
fprintf( pFile, "module %s (\n", Cba_NtkName(p) ); fprintf( pFile, "module %s (\n ", Prs_NtkStr(p, p->iModuleName) );
for ( s = 0; s < 3; s++ ) Prs_ManWriteVerilogIoOrder( pFile, p, &p->vOrder );
{ fprintf( pFile, "\n );\n" );
if ( s == 0 && Vec_IntSize(&p->vInouts) == 0 )
continue;
fprintf( pFile, " " );
Cba_PrsWriteVerilogSignalList( pFile, p, s, s==2 );
fprintf( pFile, "\n" );
}
fprintf( pFile, " );\n" );
// write declarations // write declarations
for ( s = 0; s < 4; s++ ) for ( s = 0; s < 4; s++ )
Cba_PrsWriteVerilogSignals( pFile, p, s ); Prs_ManWriteVerilogIos( pFile, p, s );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
// write objects // write objects
Cba_PrsWriteVerilogNodes( pFile, p ); Prs_ManWriteVerilogBoxes( pFile, p );
Cba_PrsWriteVerilogBoxes( pFile, p );
fprintf( pFile, "endmodule\n\n" ); fprintf( pFile, "endmodule\n\n" );
} }
void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p ) void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * vPrs )
{ {
FILE * pFile; Prs_Ntk_t * pNtk = Prs_ManRoot(vPrs); int i;
Cba_Ntk_t * pNtk; FILE * pFile = fopen( pFileName, "wb" );
int i;
pFile = fopen( pFileName, "wb" );
if ( pFile == NULL ) if ( pFile == NULL )
{ {
printf( "Cannot open output file \"%s\".\n", pFileName ); printf( "Cannot open output file \"%s\".\n", pFileName );
return; return;
} }
fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Cba_ManName(p), Extra_TimeStamp() ); fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Prs_NtkStr(pNtk, pNtk->iModuleName), Extra_TimeStamp() );
Cba_ManForEachNtk( p, pNtk, i ) Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
Cba_PrsWriteVerilogNtk( pFile, pNtk ); Prs_ManWriteVerilogNtk( pFile, pNtk );
fclose( pFile ); fclose( pFile );
} }
/**Function************************************************************* /**Function*************************************************************
Synopsis [Collect all nodes names used that are not inputs/outputs.] Synopsis [Collect all nodes names used that are not inputs/outputs.]
...@@ -194,47 +190,42 @@ void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p ) ...@@ -194,47 +190,42 @@ void Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * p )
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
Vec_Int_t * Cba_NtkCollectWires( Cba_Ntk_t * p, Vec_Int_t * vMap ) Vec_Int_t * Cba_NtkCollectWires( Cba_Ntk_t * p, Vec_Int_t * vMap, Vec_Int_t * vWires )
{ {
Vec_Int_t * vWires = &p->vWires; int i, k, iTerm, iObj, NameId;
int i, iObj, iFanin, Type, NameId;
Vec_IntClear( vWires ); Vec_IntClear( vWires );
Cba_NtkForEachPi( p, iObj, i ) Cba_NtkForEachPi( p, iObj, i )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 ); Vec_IntWriteEntry( vMap, Cba_ObjName(p, iObj), 1 );
Cba_NtkForEachPo( p, iObj, i ) Cba_NtkForEachPo( p, iObj, i )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 ); Vec_IntWriteEntry( vMap, Cba_ObjName(p, iObj), 1 );
Cba_NtkForEachObjType( p, Type, iObj ) Cba_NtkForEachBox( p, iObj )
{ {
if ( Type == CBA_OBJ_NODE ) Cba_BoxForEachBi( p, iObj, iTerm, k )
{ {
Vec_Int_t * vFanins = Cba_ObjFaninVec( p, iObj ); NameId = Cba_ObjName( p, iTerm );
Vec_IntForEachEntry( vFanins, iFanin, i )
{
NameId = Cba_ObjNameId( p, iFanin );
if ( Vec_IntEntry(vMap, NameId) == 0 ) if ( Vec_IntEntry(vMap, NameId) == 0 )
{ {
Vec_IntWriteEntry( vMap, NameId, 1 ); Vec_IntWriteEntry( vMap, NameId, 1 );
Vec_IntPush( vWires, NameId ); Vec_IntPush( vWires, iTerm );
}
} }
} }
else if ( Cba_ObjIsPo(p, iObj) || Cba_ObjIsBi(p, iObj) ) Cba_BoxForEachBo( p, iObj, iTerm, k )
{ {
iFanin = Cba_ObjFanin0( p, iObj ); NameId = Cba_ObjName( p, iTerm );
NameId = Cba_ObjNameId( p, iFanin );
if ( Vec_IntEntry(vMap, NameId) == 0 ) if ( Vec_IntEntry(vMap, NameId) == 0 )
{ {
Vec_IntWriteEntry( vMap, NameId, 1 ); Vec_IntWriteEntry( vMap, NameId, 1 );
Vec_IntPush( vWires, NameId ); Vec_IntPush( vWires, iTerm );
} }
} }
} }
Cba_NtkForEachPi( p, iObj, i ) Cba_NtkForEachPi( p, iObj, i )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 ); Vec_IntWriteEntry( vMap, Cba_ObjName(p, iObj), 0 );
Cba_NtkForEachPo( p, iObj, i ) Cba_NtkForEachPo( p, iObj, i )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 ); Vec_IntWriteEntry( vMap, Cba_ObjName(p, iObj), 0 );
Vec_IntForEachEntry( vWires, NameId, i ) Vec_IntForEachEntry( vWires, iObj, i )
Vec_IntWriteEntry( vMap, NameId, 0 ); Vec_IntWriteEntry( vMap, Cba_ObjName(p, iObj), 0 );
//Vec_IntSort( vWires, 0 );
return vWires; return vWires;
} }
...@@ -256,40 +247,39 @@ void Cba_ManWriteVerilogArray2( FILE * pFile, Cba_Ntk_t * p, int iObj, Vec_Int_t ...@@ -256,40 +247,39 @@ void Cba_ManWriteVerilogArray2( FILE * pFile, Cba_Ntk_t * p, int iObj, Vec_Int_t
Vec_IntForEachEntry( vFanins, iFanin, i ) Vec_IntForEachEntry( vFanins, iFanin, i )
fprintf( pFile, "%s%s", Cba_ObjNameStr(p, iFanin), (i == Vec_IntSize(vFanins) - 1) ? "" : ", " ); fprintf( pFile, "%s%s", Cba_ObjNameStr(p, iFanin), (i == Vec_IntSize(vFanins) - 1) ? "" : ", " );
} }
void Cba_ManWriteVerilogNodes( FILE * pFile, Cba_Ntk_t * p )
{
int Func, i;
Cba_NtkForEachNode( p, i ) // .names/assign/box2 (no formal/actual binding)
{
Func = Cba_ObjFuncId(p, i);
if ( Func >= CBA_NODE_BUF && Func <= CBA_NODE_XNOR )
{
fprintf( pFile, " %s (", Ptr_TypeToName(Func) );
Cba_ManWriteVerilogArray2( pFile, p, i, Cba_ObjFaninVec(p, i) );
fprintf( pFile, ");\n" );
}
else assert( 0 );
}
}
void Cba_ManWriteVerilogBoxes( FILE * pFile, Cba_Ntk_t * p ) void Cba_ManWriteVerilogBoxes( FILE * pFile, Cba_Ntk_t * p )
{ {
int i, k, iTerm; int i, k, iTerm;
Cba_NtkForEachBox( p, i ) // .subckt/.gate/box (formal/actual binding) Cba_NtkForEachBox( p, i ) // .subckt/.gate/box (formal/actual binding)
{ {
Cba_Ntk_t * pModel = Cba_ObjBoxModel( p, i ); if ( Cba_ObjIsBoxUser(p, i) )
fprintf( pFile, " %s %s (", Cba_NtkName(pModel), Vec_IntSize(&p->vInstIds) ? Cba_ObjInstStr(p, i) : "" ); {
Cba_Ntk_t * pModel = Cba_BoxNtk( p, i );
fprintf( pFile, " %s %s (", Cba_NtkName(pModel), Cba_ObjNameStr(p, i) ? Cba_ObjNameStr(p, i) : "" );
Cba_NtkForEachPi( pModel, iTerm, k ) Cba_NtkForEachPi( pModel, iTerm, k )
fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_ObjBoxBi(p, i, k)) ); fprintf( pFile, "%s.%s(%s)", k ? ", " : "", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_BoxBi(p, i, k)) );
Cba_NtkForEachPo( pModel, iTerm, k ) Cba_NtkForEachPo( pModel, iTerm, k )
fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_ObjBoxBo(p, i, k)) ); fprintf( pFile, "%s.%s(%s)", Cba_NtkPiNum(pModel) ? ", " : "", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Cba_BoxBo(p, i, k)) );
fprintf( pFile, "\n" ); fprintf( pFile, ")\n" );
}
else
{
Cba_ObjType_t Type = Cba_ObjType( p, i );
int nInputs = Cba_BoxBiNum(p, i);
fprintf( pFile, " %s (", Ptr_TypeToName(Type) );
Cba_BoxForEachBo( p, i, iTerm, k )
fprintf( pFile, "%s%s", Cba_ObjNameStr(p, iTerm), nInputs ? ", " : "" );
Cba_BoxForEachBi( p, i, iTerm, k )
fprintf( pFile, "%s%s", Cba_ObjNameStr(p, iTerm), k < nInputs - 1 ? ", " : "" );
fprintf( pFile, ");\n" );
}
} }
} }
void Cba_ManWriteVerilogSignals( FILE * pFile, Cba_Ntk_t * p, int SigType, int fNoRange ) void Cba_ManWriteVerilogSignals( FILE * pFile, Cba_Ntk_t * p, int SigType, int fNoRange, Vec_Int_t * vWires )
{ {
int NameId, RangeId, i; int NameId, RangeId, i;
char * pSigNames[4] = { "inout", "input", "output", "wire" }; char * pSigNames[3] = { "input", "output", "wire" };
Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires }; Vec_Int_t * vSigs[3] = { &p->vInputs, &p->vOutputs, vWires };
if ( fNoRange ) if ( fNoRange )
{ {
Vec_IntForEachEntry( vSigs[SigType], NameId, i ) Vec_IntForEachEntry( vSigs[SigType], NameId, i )
...@@ -301,10 +291,10 @@ void Cba_ManWriteVerilogSignals( FILE * pFile, Cba_Ntk_t * p, int SigType, int f ...@@ -301,10 +291,10 @@ void Cba_ManWriteVerilogSignals( FILE * pFile, Cba_Ntk_t * p, int SigType, int f
fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Cba_NtkStr(p, RangeId) : "", SigType==3 ? Cba_NtkStr(p, NameId) : Cba_ObjNameStr(p, NameId) ); fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Cba_NtkStr(p, RangeId) : "", SigType==3 ? Cba_NtkStr(p, NameId) : Cba_ObjNameStr(p, NameId) );
} }
} }
void Cba_ManWriteVerilogSignalList( FILE * pFile, Cba_Ntk_t * p, int SigType, int fSkipComma, int fNoRange ) void Cba_ManWriteVerilogSignalList( FILE * pFile, Cba_Ntk_t * p, int SigType, int fSkipComma, int fNoRange, Vec_Int_t * vWires )
{ {
int NameId, RangeId, i; int NameId, RangeId, i;
Vec_Int_t * vSigs[4] = { &p->vInouts, &p->vInputs, &p->vOutputs, &p->vWires }; Vec_Int_t * vSigs[3] = { &p->vInputs, &p->vOutputs, vWires };
if ( fNoRange ) if ( fNoRange )
{ {
Vec_IntForEachEntry( vSigs[SigType], NameId, i ) Vec_IntForEachEntry( vSigs[SigType], NameId, i )
...@@ -316,40 +306,41 @@ void Cba_ManWriteVerilogSignalList( FILE * pFile, Cba_Ntk_t * p, int SigType, in ...@@ -316,40 +306,41 @@ void Cba_ManWriteVerilogSignalList( FILE * pFile, Cba_Ntk_t * p, int SigType, in
fprintf( pFile, "%s%s", Cba_ObjNameStr(p, NameId), (fSkipComma && i == Vec_IntSize(vSigs[SigType]) - 2) ? "" : ", " ); fprintf( pFile, "%s%s", Cba_ObjNameStr(p, NameId), (fSkipComma && i == Vec_IntSize(vSigs[SigType]) - 2) ? "" : ", " );
} }
} }
void Cba_ManWriteVerilogNtk( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vMap ) void Cba_ManWriteVerilogNtk( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vMap, Vec_Int_t * vWires )
{ {
int s; int s;
assert( Vec_IntSize(&p->vTypes) == Cba_NtkObjNum(p) ); assert( Vec_IntSize(&p->vFanin) == Cba_NtkObjNum(p) );
assert( Vec_IntSize(&p->vFuncs) == Cba_NtkObjNum(p) );
// collect wires // collect wires
Cba_NtkCollectWires( p, vMap ); Cba_NtkCollectWires( p, vMap, vWires );
// write header // write header
fprintf( pFile, "module %s (\n", Cba_NtkName(p) ); fprintf( pFile, "module %s (\n", Cba_NtkName(p) );
for ( s = 0; s < 3; s++ ) for ( s = 0; s < 2; s++ )
{ {
if ( s == 0 && Vec_IntSize(&p->vInouts) == 0 )
continue;
fprintf( pFile, " " ); fprintf( pFile, " " );
Cba_ManWriteVerilogSignalList( pFile, p, s, s==2, 1 ); Cba_ManWriteVerilogSignalList( pFile, p, s, s==2, 1, vWires );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
} }
fprintf( pFile, " );\n" ); fprintf( pFile, " );\n" );
// write declarations // write declarations
for ( s = 0; s < 4; s++ ) for ( s = 0; s < 3; s++ )
Cba_ManWriteVerilogSignals( pFile, p, s, 1 ); Cba_ManWriteVerilogSignals( pFile, p, s, 1, vWires );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
// write objects // write objects
Cba_ManWriteVerilogNodes( pFile, p );
Cba_ManWriteVerilogBoxes( pFile, p ); Cba_ManWriteVerilogBoxes( pFile, p );
fprintf( pFile, "endmodule\n\n" ); fprintf( pFile, "endmodule\n\n" );
Vec_IntErase( &p->vWires );
} }
void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p ) void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p )
{ {
FILE * pFile; FILE * pFile;
Cba_Ntk_t * pNtk; Cba_Ntk_t * pNtk;
Vec_Int_t * vMap; Vec_Int_t * vMap, * vWires;
int i; int i;
// check the library
if ( p->pMioLib && p->pMioLib != Abc_FrameReadLibGen() )
{
printf( "Genlib library used in the mapped design is not longer a current library.\n" );
return;
}
pFile = fopen( pFileName, "wb" ); pFile = fopen( pFileName, "wb" );
if ( pFile == NULL ) if ( pFile == NULL )
{ {
...@@ -358,9 +349,11 @@ void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p ) ...@@ -358,9 +349,11 @@ void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p )
} }
fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Cba_ManName(p), Extra_TimeStamp() ); fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Cba_ManName(p), Extra_TimeStamp() );
Cba_ManAssignInternNames( p ); Cba_ManAssignInternNames( p );
vMap = Vec_IntStart( Abc_NamObjNumMax(p->pNames) + 1 ); vMap = Vec_IntStart( Abc_NamObjNumMax(p->pStrs) + 1 );
vWires = Vec_IntAlloc( 1000 );
Cba_ManForEachNtk( p, pNtk, i ) Cba_ManForEachNtk( p, pNtk, i )
Cba_ManWriteVerilogNtk( pFile, pNtk, vMap ); Cba_ManWriteVerilogNtk( pFile, pNtk, vMap, vWires );
Vec_IntFree( vWires );
Vec_IntFree( vMap ); Vec_IntFree( vMap );
fclose( pFile ); fclose( pFile );
} }
......
src/base/cba/module.make
SRC += src/base/cba/cbaBlast.c \ SRC += src/base/cba/cbaBlast.c \
src/base/cba/cbaBuild.c \
src/base/cba/cbaCom.c \ src/base/cba/cbaCom.c \
src/base/cba/cbaLib.c \ src/base/cba/cbaLib.c \
src/base/cba/cbaNtk.c \ src/base/cba/cbaNtk.c \
src/base/cba/cbaPrsBuild.c \
src/base/cba/cbaPrsTrans.c \
src/base/cba/cbaPtr.c \
src/base/cba/cbaPtrAbc.c \
src/base/cba/cbaReadBlif.c \ src/base/cba/cbaReadBlif.c \
src/base/cba/cbaReadVer.c \ src/base/cba/cbaReadVer.c \
src/base/cba/cbaSimple.c \
src/base/cba/cbaWriteBlif.c \ src/base/cba/cbaWriteBlif.c \
src/base/cba/cbaWriteVer.c src/base/cba/cbaWriteVer.c
src/map/mio/mio.h
...@@ -98,6 +98,7 @@ extern Mio_Gate_t * Mio_LibraryReadGates ( Mio_Library_t * pLib ); ...@@ -98,6 +98,7 @@ extern Mio_Gate_t * Mio_LibraryReadGates ( Mio_Library_t * pLib );
extern Mio_Gate_t ** Mio_LibraryReadGateArray ( Mio_Library_t * pLib ); extern Mio_Gate_t ** Mio_LibraryReadGateArray ( Mio_Library_t * pLib );
extern Mio_Gate_t * Mio_LibraryReadGateByName ( Mio_Library_t * pLib, char * pName, char * pOutName ); extern Mio_Gate_t * Mio_LibraryReadGateByName ( Mio_Library_t * pLib, char * pName, char * pOutName );
extern char * Mio_LibraryReadSopByName ( Mio_Library_t * pLib, char * pName ); extern char * Mio_LibraryReadSopByName ( Mio_Library_t * pLib, char * pName );
extern Mio_Gate_t * Mio_LibraryReadGateByTruth( Mio_Library_t * pLib, word t );
extern Mio_Gate_t * Mio_LibraryReadConst0 ( Mio_Library_t * pLib ); extern Mio_Gate_t * Mio_LibraryReadConst0 ( Mio_Library_t * pLib );
extern Mio_Gate_t * Mio_LibraryReadConst1 ( Mio_Library_t * pLib ); extern Mio_Gate_t * Mio_LibraryReadConst1 ( Mio_Library_t * pLib );
extern Mio_Gate_t * Mio_LibraryReadNand2 ( Mio_Library_t * pLib ); extern Mio_Gate_t * Mio_LibraryReadNand2 ( Mio_Library_t * pLib );
......
src/map/mio/mioApi.c
...@@ -112,6 +112,26 @@ Mio_Gate_t * Mio_LibraryReadGateByName( Mio_Library_t * pLib, char * pName, char ...@@ -112,6 +112,26 @@ Mio_Gate_t * Mio_LibraryReadGateByName( Mio_Library_t * pLib, char * pName, char
/**Function************************************************************* /**Function*************************************************************
Synopsis [Returns the first gate in the library with the given TT.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Mio_Gate_t * Mio_LibraryReadGateByTruth( Mio_Library_t * pLib, word t )
{
Mio_Gate_t * pGate;
Mio_LibraryForEachGate( pLib, pGate )
if ( pGate->nInputs <= 6 && pGate->uTruth == t )
return pGate;
return NULL;
}
/**Function*************************************************************
Synopsis [Read Mvc of the gate by name.] Synopsis [Read Mvc of the gate by name.]
Description [] Description []
......
src/misc/util/utilNam.c
...@@ -478,7 +478,7 @@ int Abc_NamStrFindOrAddLim( Abc_Nam_t * p, char * pStr, char * pLim, int * pfFou ...@@ -478,7 +478,7 @@ int Abc_NamStrFindOrAddLim( Abc_Nam_t * p, char * pStr, char * pLim, int * pfFou
***********************************************************************/ ***********************************************************************/
char * Abc_NamStr( Abc_Nam_t * p, int NameId ) char * Abc_NamStr( Abc_Nam_t * p, int NameId )
{ {
return NameId? Abc_NamIntToStr(p, NameId) : NULL; return NameId > 0 ? Abc_NamIntToStr(p, NameId) : NULL;
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecInt.h
...@@ -65,6 +65,8 @@ struct Vec_Int_t_ ...@@ -65,6 +65,8 @@ struct Vec_Int_t_
for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ ) for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
#define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i ) \ #define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i ) \
for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 ) for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
#define Vec_IntForEachEntryDoubleStart( vVec, Entry1, Entry2, i, Start ) \
for ( i = Start; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
#define Vec_IntForEachEntryTriple( vVec, Entry1, Entry2, Entry3, i ) \ #define Vec_IntForEachEntryTriple( vVec, Entry1, Entry2, Entry3, i ) \
for ( i = 0; (i+2 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1) && (((Entry3) = Vec_IntEntry(vVec, i+2)), 1); i += 3 ) for ( i = 0; (i+2 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1) && (((Entry3) = Vec_IntEntry(vVec, i+2)), 1); i += 3 )
#define Vec_IntForEachEntryThisNext( vVec, This, Next, i ) \ #define Vec_IntForEachEntryThisNext( vVec, This, Next, i ) \
...@@ -613,6 +615,11 @@ static inline int Vec_IntGetEntry( Vec_Int_t * p, int i ) ...@@ -613,6 +615,11 @@ static inline int Vec_IntGetEntry( Vec_Int_t * p, int i )
Vec_IntFillExtra( p, i + 1, 0 ); Vec_IntFillExtra( p, i + 1, 0 );
return Vec_IntEntry( p, i ); return Vec_IntEntry( p, i );
} }
static inline int Vec_IntGetEntryFull( Vec_Int_t * p, int i )
{
Vec_IntFillExtra( p, i + 1, -1 );
return Vec_IntEntry( p, i );
}
/**Function************************************************************* /**Function*************************************************************
...@@ -1170,6 +1177,20 @@ static inline int Vec_IntCountEntry( Vec_Int_t * p, int Entry ) ...@@ -1170,6 +1177,20 @@ static inline int Vec_IntCountEntry( Vec_Int_t * p, int Entry )
Counter += (p->pArray[i] == Entry); Counter += (p->pArray[i] == Entry);
return Counter; return Counter;
} }
static inline int Vec_IntCountLarger( Vec_Int_t * p, int Entry )
{
int i, Counter = 0;
for ( i = 0; i < p->nSize; i++ )
Counter += (p->pArray[i] > Entry);
return Counter;
}
static inline int Vec_IntCountSmaller( Vec_Int_t * p, int Entry )
{
int i, Counter = 0;
for ( i = 0; i < p->nSize; i++ )
Counter += (p->pArray[i] < Entry);
return Counter;
}
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecStr.h
...@@ -706,6 +706,39 @@ static inline int Vec_StrSum( Vec_Str_t * p ) ...@@ -706,6 +706,39 @@ static inline int Vec_StrSum( Vec_Str_t * p )
/**Function************************************************************* /**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Vec_StrCountEntry( Vec_Str_t * p, char Entry )
{
int i, Counter = 0;
for ( i = 0; i < p->nSize; i++ )
Counter += (p->pArray[i] == Entry);
return Counter;
}
static inline int Vec_StrCountLarger( Vec_Str_t * p, char Entry )
{
int i, Counter = 0;
for ( i = 0; i < p->nSize; i++ )
Counter += (p->pArray[i] > Entry);
return Counter;
}
static inline int Vec_StrCountSmaller( Vec_Str_t * p, char Entry )
{
int i, Counter = 0;
for ( i = 0; i < p->nSize; i++ )
Counter += (p->pArray[i] < Entry);
return Counter;
}
/**Function*************************************************************
Synopsis [Compares two strings.] Synopsis [Compares two strings.]
Description [] Description []
......
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