ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
acb.h
Go to the documentation of this file.
1
20
21#ifndef ABC__base__acb__acb_h
22#define ABC__base__acb__acb_h
23
27
28#include "aig/gia/gia.h"
29#include "misc/extra/extra.h"
30#include "misc/util/utilNam.h"
31#include "misc/vec/vecHash.h"
32#include "aig/miniaig/abcOper.h"
33#include "misc/vec/vecQue.h"
34
38
39ABC_NAMESPACE_HEADER_START
40
44
45
46typedef struct Acb_Aig_t_ Acb_Aig_t;
47typedef struct Acb_Ntk_t_ Acb_Ntk_t;
48typedef struct Acb_Man_t_ Acb_Man_t;
49
50// network
51struct Acb_Ntk_t_
52{
53 Acb_Man_t * pDesign; // design
54 int Id; // network ID
55 int NameId; // name ID
56 int iCopy; // copy module
57 unsigned Mark : 1; // visit mark
58 unsigned fComb: 1; // the network is combinational
59 unsigned fSeq : 1; // the network is sequential
60 // interface
61 Vec_Int_t vCis; // inputs
62 Vec_Int_t vCos; // outputs
63 Vec_Int_t vOrder; // order
64 Vec_Int_t vSeq; // sequential objects
65 int nRegs; // flop count
66 int nFaninMax; // default fanin count
67 int nObjTravs; // trav ID
68 int LevelMax; // max level
69 int nPaths; // the number of paths
70 // stucture
71 Vec_Str_t vObjType; // type
72 Vec_Int_t vObjFans; // fanin offsets
73 Vec_Int_t vFanSto; // fanin storage
74 // optional
75 Vec_Int_t vObjCopy; // copy
76 Vec_Int_t vObjFunc; // function
77 Vec_Int_t vObjWeight; // weight
78 Vec_Wrd_t vObjTruth; // function
79 Vec_Int_t vObjName; // name
80 Vec_Int_t vObjRange; // range
81 Vec_Int_t vObjTrav; // trav ID
82 Vec_Int_t vObjBits; // obj mapping into AIG nodes
83 Vec_Int_t vObjAttr; // attribute offset
84 Vec_Int_t vAttrSto; // attribute storage
85 Vec_Int_t vNtkObjs; // instances
86 Vec_Int_t vTargets; // targets
87 Vec_Int_t vLevelD; // level
88 Vec_Int_t vLevelR; // level
89 Vec_Int_t vPathD; // path
90 Vec_Int_t vPathR; // path
91 Vec_Flt_t vCounts; // priority counts
92 Vec_Wec_t vFanouts; // fanouts
93 Vec_Wec_t vCnfs; // CNF
94 Vec_Str_t vCnf; // CNF
95 Vec_Int_t vSuppOld; // previous support
96 // other
97 Vec_Que_t * vQue; // temporary
98 Vec_Int_t vCover; // temporary
99 Vec_Int_t vArray0; // temporary
100 Vec_Int_t vArray1; // temporary
101 Vec_Int_t vArray2; // temporary
102};
103
104// design
105struct Acb_Man_t_
106{
107 char * pName; // design name
108 char * pSpec; // spec file name
109 Abc_Nam_t * pStrs; // string manager
110 Abc_Nam_t * pFuns; // constant manager
111 Abc_Nam_t * pMods; // module name manager
112 Hash_IntMan_t * vHash; // variable ranges
113 Vec_Int_t vNameMap; // mapping names
114 Vec_Int_t vNameMap2; // mapping names
115 Vec_Int_t vUsed; // used map entries
116 Vec_Int_t vUsed2; // used map entries
117 char * pTypeNames[ABC_OPER_LAST];
118 int nObjs[ABC_OPER_LAST]; // counter of objects of each type
119 int nAnds[ABC_OPER_LAST]; // counter of AND gates after blasting
120 // internal data
121 int iRoot; // root network
122 Vec_Ptr_t vNtks; // networks
123 // user data
124 int nOpens;
125 Vec_Str_t vOut;
126 Vec_Str_t vOut2;
127 void * pMioLib;
128};
129
133
134static inline char * Acb_ManName( Acb_Man_t * p ) { return p->pName; }
135static inline char * Acb_ManSpec( Acb_Man_t * p ) { return p->pSpec; }
136static inline int Acb_ManNtkNum( Acb_Man_t * p ) { return Vec_PtrSize(&p->vNtks)-1; }
137static inline int Acb_ManNtkIsOk( Acb_Man_t * p, int i ) { return i > 0 && i <= Acb_ManNtkNum(p); }
138static inline Acb_Ntk_t * Acb_ManNtk( Acb_Man_t * p, int i ) { return Acb_ManNtkIsOk(p, i) ? (Acb_Ntk_t *)Vec_PtrEntry(&p->vNtks, i) : NULL; }
139static inline int Acb_ManNtkFindId( Acb_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName); }
140static inline Acb_Ntk_t * Acb_ManNtkFind( Acb_Man_t * p, char * pName ) { return Acb_ManNtk( p, Acb_ManNtkFindId(p, pName) ); }
141static inline Acb_Ntk_t * Acb_ManRoot( Acb_Man_t * p ) { return Acb_ManNtk(p, p->iRoot); }
142static inline char * Acb_ManStr( Acb_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); }
143static inline int Acb_ManStrId( Acb_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); }
144static inline int Acb_ManNameIdMax( Acb_Man_t * p ) { return Abc_NamObjNumMax(p->pStrs) + 1; }
145static inline char * Acb_ManConst( Acb_Man_t * p, int i ) { return Abc_NamStr(p->pFuns, i); }
146static inline int Acb_ManConstId( Acb_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pFuns, pStr); }
147static inline int Acb_ManConstIdMax( Acb_Man_t * p ) { return Abc_NamObjNumMax(p->pFuns) + 1; }
148
149static inline Acb_Man_t * Acb_NtkMan( Acb_Ntk_t * p ) { return p->pDesign; }
150static inline Acb_Ntk_t * Acb_NtkNtk( Acb_Ntk_t * p, int i ) { return Acb_ManNtk(p->pDesign, i); }
151static inline int Acb_NtkId( Acb_Ntk_t * p ) { return p->Id; }
152static inline int Acb_NtkCi( Acb_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCis, i); }
153static inline int Acb_NtkCo( Acb_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCos, i); }
154static inline int Acb_NtkCioOrder( Acb_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOrder, i); }
155static inline int Acb_NtkBoxSeq( Acb_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vSeq, i); }
156static inline Abc_Nam_t * Acb_NtkNam( Acb_Ntk_t * p ) { return p->pDesign->pStrs; }
157static inline char * Acb_NtkStr( Acb_Ntk_t * p, int i ) { return Acb_ManStr(p->pDesign, i); }
158static inline int Acb_NtkStrId( Acb_Ntk_t * p, char * pName ) { return Acb_ManStrId(p->pDesign, pName); }
159static inline char * Acb_NtkConst( Acb_Ntk_t * p, int i ) { return Acb_ManConst(p->pDesign, i); }
160static inline char * Acb_NtkSop( Acb_Ntk_t * p, int i ) { return Acb_ManConst(p->pDesign, i); }
161static inline int Acb_NtkNameId( Acb_Ntk_t * p ) { return p->NameId; }
162static inline char * Acb_NtkName( Acb_Ntk_t * p ) { return Acb_NtkStr(p, p->NameId); }
163static inline char * Acb_NtkTypeName( Acb_Ntk_t * p, int Type ) { return p->pDesign->pTypeNames[Type]; }
164static inline int Acb_NtkCopy( Acb_Ntk_t * p ) { return p->iCopy; }
165static inline Acb_Ntk_t * Acb_NtkCopyNtk(Acb_Man_t * pNew, Acb_Ntk_t * p) { return Acb_ManNtk(pNew, Acb_NtkCopy(p)); }
166static inline void Acb_NtkSetCopy( Acb_Ntk_t * p, int i ) { assert(p->iCopy == 0); p->iCopy = i; }
167static inline int Acb_NtkHashRange( Acb_Ntk_t * p, int l, int r ) { return Hash_Int2ManInsert( p->pDesign->vHash, l, r, 0 ); }
168static inline int Acb_NtkRangeLeft( Acb_Ntk_t * p, int h ) { return h ? Hash_IntObjData0( p->pDesign->vHash, h ) : 0; }
169static inline int Acb_NtkRangeRight( Acb_Ntk_t * p, int h ) { return h ? Hash_IntObjData1( p->pDesign->vHash, h ) : 0; }
170static inline int Acb_NtkRangeSize( Acb_Ntk_t * p, int h ) { int l = Acb_NtkRangeLeft(p, h), r = Acb_NtkRangeRight(p, h); return 1 + (l > r ? l-r : r-l);}
171
172static inline int Acb_NtkCiNum( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vCis); }
173static inline int Acb_NtkCoNum( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vCos); }
174static inline int Acb_NtkCioNum( Acb_Ntk_t * p ) { return Acb_NtkCiNum(p) + Acb_NtkCoNum(p); }
175static inline int Acb_NtkCiNumAlloc( Acb_Ntk_t * p ) { return Vec_IntCap(&p->vCis); }
176static inline int Acb_NtkCoNumAlloc( Acb_Ntk_t * p ) { return Vec_IntCap(&p->vCos); }
177static inline int Acb_NtkRegNum( Acb_Ntk_t * p ) { return p->nRegs; }
178static inline void Acb_NtkSetRegNum( Acb_Ntk_t * p, int nRegs ) { p->nRegs = nRegs; }
179static inline int Acb_NtkPiNum( Acb_Ntk_t * p ) { return Acb_NtkCiNum(p) - Acb_NtkRegNum(p); }
180static inline int Acb_NtkPoNum( Acb_Ntk_t * p ) { return Acb_NtkCoNum(p) - Acb_NtkRegNum(p); }
181static inline int Acb_NtkCioOrderNum( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vOrder); }
182static inline int Acb_NtkObjNumAlloc( Acb_Ntk_t * p ) { return Vec_StrCap(&p->vObjType)-1; }
183static inline int Acb_NtkObjNum( Acb_Ntk_t * p ) { return Vec_StrSize(&p->vObjType)-1; }
184static inline int Acb_NtkObjNumMax( Acb_Ntk_t * p ) { return Vec_StrSize(&p->vObjType); }
185static inline int Acb_NtkTypeNum( Acb_Ntk_t * p, int Type ) { return Vec_StrCountEntry(&p->vObjType, (char)Type); }
186static inline int Acb_NtkBoxNum( Acb_Ntk_t * p ) { return Acb_NtkTypeNum(p, ABC_OPER_BOX); }
187static inline int Acb_NtkNodeNum( Acb_Ntk_t * p ) { return Vec_StrCountLarger(&p->vObjType, (char)ABC_OPER_BOX); }
188static inline int Acb_NtkSeqNum( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vSeq); }
189
190static inline void Acb_NtkCleanObjCopies( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjCopy, Vec_StrCap(&p->vObjType), -1); }
191static inline void Acb_NtkCleanObjFuncs( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjFunc, Vec_StrCap(&p->vObjType), -1); }
192static inline void Acb_NtkCleanObjWeights( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjWeight,Vec_StrCap(&p->vObjType), 0); }
193static inline void Acb_NtkCleanObjTruths( Acb_Ntk_t * p ) { Vec_WrdFill(&p->vObjTruth, Vec_StrCap(&p->vObjType), 0); }
194static inline void Acb_NtkCleanObjNames( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjName, Vec_StrCap(&p->vObjType), 0); }
195static inline void Acb_NtkCleanObjRanges( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjRange, Vec_StrCap(&p->vObjType), 0); }
196static inline void Acb_NtkCleanObjTravs( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjTrav, Vec_StrCap(&p->vObjType), 0); }
197static inline void Acb_NtkCleanObjAttrs( Acb_Ntk_t * p ) { Vec_IntFill(&p->vObjAttr, Vec_StrCap(&p->vObjType), 0); Vec_IntFill(&p->vAttrSto, 1, -1); }
198static inline void Acb_NtkCleanObjLevelD( Acb_Ntk_t * p ) { Vec_IntFill(&p->vLevelD, Vec_StrCap(&p->vObjType), 0); }
199static inline void Acb_NtkCleanObjLevelR( Acb_Ntk_t * p ) { Vec_IntFill(&p->vLevelR, Vec_StrCap(&p->vObjType), 0); }
200static inline void Acb_NtkCleanObjPathD( Acb_Ntk_t * p ) { Vec_IntFill(&p->vPathD, Vec_StrCap(&p->vObjType), 0); }
201static inline void Acb_NtkCleanObjPathR( Acb_Ntk_t * p ) { Vec_IntFill(&p->vPathR, Vec_StrCap(&p->vObjType), 0); }
202static inline void Acb_NtkCleanObjCounts( Acb_Ntk_t * p ) { Vec_FltFill(&p->vCounts, Vec_StrCap(&p->vObjType), 0); }
203static inline void Acb_NtkCleanObjFanout( Acb_Ntk_t * p ) { Vec_WecInit(&p->vFanouts, Vec_StrCap(&p->vObjType) ); }
204static inline void Acb_NtkCleanObjCnfs( Acb_Ntk_t * p ) { Vec_WecInit(&p->vCnfs, Vec_StrCap(&p->vObjType) ); }
205
206static inline int Acb_NtkHasObjCopies( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjCopy) > 0; }
207static inline int Acb_NtkHasObjFuncs( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjFunc) > 0; }
208static inline int Acb_NtkHasObjWeights( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjWeight)> 0; }
209static inline int Acb_NtkHasObjTruths( Acb_Ntk_t * p ) { return Vec_WrdSize(&p->vObjTruth) > 0; }
210static inline int Acb_NtkHasObjNames( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjName) > 0; }
211static inline int Acb_NtkHasObjRanges( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjRange) > 0; }
212static inline int Acb_NtkHasObjTravs( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjTrav) > 0; }
213static inline int Acb_NtkHasObjAttrs( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vObjAttr) > 0; }
214static inline int Acb_NtkHasObjLevelD( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vLevelD) > 0; }
215static inline int Acb_NtkHasObjLevelR( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vLevelR) > 0; }
216static inline int Acb_NtkHasObjPathD( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vPathD) > 0; }
217static inline int Acb_NtkHasObjPathR( Acb_Ntk_t * p ) { return Vec_IntSize(&p->vPathR) > 0; }
218static inline int Acb_NtkHasObjCounts( Acb_Ntk_t * p ) { return Vec_FltSize(&p->vCounts) > 0; }
219static inline int Acb_NtkHasObjFanout( Acb_Ntk_t * p ) { return Vec_WecSize(&p->vFanouts) > 0; }
220static inline int Acb_NtkHasObjCnfs( Acb_Ntk_t * p ) { return Vec_WecSize(&p->vCnfs) > 0; }
221
222static inline void Acb_NtkFreeObjCopies( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjCopy); }
223static inline void Acb_NtkFreeObjFuncs( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjFunc); }
224static inline void Acb_NtkFreeObjWeights( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjWeight); }
225static inline void Acb_NtkFreeObjTruths( Acb_Ntk_t * p ) { Vec_WrdErase(&p->vObjTruth); }
226static inline void Acb_NtkFreeObjNames( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjName); }
227static inline void Acb_NtkFreeObjRanges( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjRange); }
228static inline void Acb_NtkFreeObjTravs( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjTrav); }
229static inline void Acb_NtkFreeObjAttrs( Acb_Ntk_t * p ) { Vec_IntErase(&p->vObjAttr); }
230static inline void Acb_NtkFreeObjLevelD( Acb_Ntk_t * p ) { Vec_IntErase(&p->vLevelD); }
231static inline void Acb_NtkFreeObjLevelR( Acb_Ntk_t * p ) { Vec_IntErase(&p->vLevelR); }
232static inline void Acb_NtkFreeObjPathD( Acb_Ntk_t * p ) { Vec_IntErase(&p->vPathD); }
233static inline void Acb_NtkFreeObjPathR( Acb_Ntk_t * p ) { Vec_IntErase(&p->vPathR); }
234static inline void Acb_NtkFreeObjCounts( Acb_Ntk_t * p ) { Vec_FltErase(&p->vCounts); }
235static inline void Acb_NtkFreeObjFanout( Acb_Ntk_t * p ) { Vec_WecErase(&p->vFanouts); }
236static inline void Acb_NtkFreeObjCnfs( Acb_Ntk_t * p ) { Vec_WecErase(&p->vCnfs); }
237
238static inline Acb_ObjType_t Acb_ObjType( Acb_Ntk_t * p, int i ) { assert(i>0); return (Acb_ObjType_t)(int)(unsigned char)Vec_StrEntry(&p->vObjType, i); }
239static inline void Acb_ObjCleanType( Acb_Ntk_t * p, int i ) { assert(i>0); Vec_StrWriteEntry( &p->vObjType, i, (char)ABC_OPER_NONE ); }
240static inline int Acb_TypeIsSeq( Acb_ObjType_t Type ) { return Type >= ABC_OPER_RAM && Type <= ABC_OPER_DFFLAST; }
241static inline int Acb_TypeIsUnary( Acb_ObjType_t Type ) { return Type == ABC_OPER_BIT_BUF || Type == ABC_OPER_BIT_INV || Type == ABC_OPER_LOGIC_NOT || Type == ABC_OPER_ARI_MIN || Type == ABC_OPER_ARI_SQRT || Type == ABC_OPER_ARI_ABS || (Type >= ABC_OPER_RED_AND && Type <= ABC_OPER_RED_NXOR); }
242static inline int Acb_TypeIsMux( Acb_ObjType_t Type ) { return Type == ABC_OPER_BIT_MUX || Type == ABC_OPER_SEL_NMUX || Type == ABC_OPER_SEL_SEL || Type == ABC_OPER_SEL_PSEL; }
243
244static inline int Acb_ObjIsCi( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_CI; }
245static inline int Acb_ObjIsCo( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_CO; }
246static inline int Acb_ObjIsCio( Acb_Ntk_t * p, int i ) { return Acb_ObjIsCi(p, i) || Acb_ObjIsCo(p, i); }
247static inline int Acb_ObjIsFon( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_FON; }
248static inline int Acb_ObjIsBox( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_BOX; }
249static inline int Acb_ObjIsGate( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_GATE; }
250static inline int Acb_ObjIsSlice( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_SLICE; }
251static inline int Acb_ObjIsConcat( Acb_Ntk_t * p, int i ) { return Acb_ObjType(p, i) == ABC_OPER_CONCAT; }
252static inline int Acb_ObjIsUnary( Acb_Ntk_t * p, int i ) { return Acb_TypeIsUnary(Acb_ObjType(p, i)); }
253
254static inline int Acb_ObjFanOffset( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFans, i); }
255static inline int * Acb_ObjFanins( Acb_Ntk_t * p, int i ) { return Vec_IntEntryP(&p->vFanSto, Acb_ObjFanOffset(p, i)); }
256static inline int Acb_ObjFanin( Acb_Ntk_t * p, int i, int k ) { return Acb_ObjFanins(p, i)[k+1]; }
257static inline int Acb_ObjFaninNum( Acb_Ntk_t * p, int i ) { return Acb_ObjFanins(p, i)[0]; }
258static inline int Acb_ObjFanoutNum( Acb_Ntk_t * p, int i ) { return Vec_IntSize( Vec_WecEntry(&p->vFanouts, i) ); }
259static inline Vec_Int_t * Acb_ObjFanoutVec( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_WecEntry( &p->vFanouts, i ); }
260static inline int Acb_ObjFanout( Acb_Ntk_t * p, int i, int k ) { return Vec_IntEntry( Acb_ObjFanoutVec(p, i), k ); }
261static inline int Acb_ObjFanin0( Acb_Ntk_t * p, int i ) { return Acb_ObjFanins(p, i)[1]; }
262static inline int Acb_ObjCioId( Acb_Ntk_t * p, int i ) { return Acb_ObjFanins(p, i)[2]; }
263
264static inline int Acb_ObjCopy( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjCopies(p) ); return Vec_IntEntry(&p->vObjCopy, i); }
265static inline int Acb_ObjFunc( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjFuncs(p) ); return Vec_IntEntry(&p->vObjFunc, i); }
266static inline int Acb_ObjWeight( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjWeights(p) );return Vec_IntEntry(&p->vObjWeight, i); }
267static inline word Acb_ObjTruth( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjTruths(p) ); return Vec_WrdEntry(&p->vObjTruth, i); }
268static inline word * Acb_ObjTruthP( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjTruths(p) ); return Vec_WrdEntryP(&p->vObjTruth, i); }
269static inline int Acb_ObjName( Acb_Ntk_t * p, int i ) { assert(i>0); assert( Acb_NtkHasObjNames(p) ); return Vec_IntEntry(&p->vObjName, i); }
270static inline char * Acb_ObjNameStr( Acb_Ntk_t * p, int i ) { assert(i>0); return Acb_NtkStr(p, Acb_ObjName(p, i)); }
271static inline int Acb_ObjAttr( Acb_Ntk_t * p, int i ) { assert(i>=0); return Acb_NtkHasObjAttrs(p) ? Vec_IntEntry(&p->vObjAttr, i) : 0; }
272static inline int Acb_ObjAttrSize( Acb_Ntk_t * p, int i ) { assert(i>=0); return Acb_ObjAttr(p, i) ? Vec_IntEntry(&p->vAttrSto, Acb_ObjAttr(p, i)) : 0; }
273static inline int * Acb_ObjAttrArray( Acb_Ntk_t * p, int i ) { assert(i>=0); return Acb_ObjAttr(p, i) ? Vec_IntEntryP(&p->vAttrSto, Acb_ObjAttr(p, i)+1) : NULL; }
274static inline int Acb_ObjAttrValue( Acb_Ntk_t * p, int i, int x ) { int k, s = Acb_ObjAttrSize(p, i), * a = Acb_ObjAttrArray(p, i); for ( k = 0; k < s; k += 2) if (a[k] == x) return a[k+1]; return 0; }
275static inline int Acb_ObjLevelD( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vLevelD, i); }
276static inline int Acb_ObjLevelR( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vLevelR, i); }
277static inline int Acb_ObjPathD( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vPathD, i); }
278static inline int Acb_ObjPathR( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vPathR, i); }
279static inline float Acb_ObjCounts( Acb_Ntk_t * p, int i ) { assert(i>0); return Vec_FltEntry(&p->vCounts, i); }
280static inline Vec_Str_t * Acb_ObjCnfs( Acb_Ntk_t * p, int i ) { assert(i>0); return (Vec_Str_t *)Vec_WecEntry(&p->vCnfs, i); }
281
282static inline void Acb_ObjSetCopy( Acb_Ntk_t * p, int i, int x ) { assert(Acb_ObjCopy(p, i) == -1); Vec_IntWriteEntry( &p->vObjCopy, i, x ); }
283static inline void Acb_ObjSetFunc( Acb_Ntk_t * p, int i, int x ) { assert(Acb_ObjFunc(p, i) == -1); Vec_IntWriteEntry( &p->vObjFunc, i, x ); }
284static inline void Acb_ObjSetWeight( Acb_Ntk_t * p, int i, int x ) { assert(Acb_ObjWeight(p, i)== 0); Vec_IntWriteEntry( &p->vObjWeight, i, x ); }
285static inline void Acb_ObjSetTruth( Acb_Ntk_t * p, int i, word x ) { assert(Acb_ObjTruth(p, i) == 0); Vec_WrdWriteEntry( &p->vObjTruth, i, x ); }
286static inline void Acb_ObjSetName( Acb_Ntk_t * p, int i, int x ) { assert(Acb_ObjName(p, i) == 0); Vec_IntWriteEntry( &p->vObjName, i, x ); }
287static inline void Acb_ObjSetAttrs( Acb_Ntk_t * p, int i, int * a, int s ) { assert(Acb_ObjAttr(p, i) == 0); if ( !a ) return; Vec_IntWriteEntry(&p->vObjAttr, i, Vec_IntSize(&p->vAttrSto)); Vec_IntPush(&p->vAttrSto, s); Vec_IntPushArray(&p->vAttrSto, a, s); }
288static inline int Acb_ObjSetLevelD( Acb_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( &p->vLevelD, i, x ); return x; }
289static inline int Acb_ObjSetLevelR( Acb_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( &p->vLevelR, i, x ); return x; }
290static inline int Acb_ObjSetPathD( Acb_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( &p->vPathD, i, x ); return x; }
291static inline int Acb_ObjSetPathR( Acb_Ntk_t * p, int i, int x ) { Vec_IntWriteEntry( &p->vPathR, i, x ); return x; }
292static inline float Acb_ObjSetCounts( Acb_Ntk_t * p, int i, float x ) { Vec_FltWriteEntry( &p->vCounts, i, x ); return x; }
293static inline int Acb_ObjUpdateLevelD( Acb_Ntk_t * p, int i, int x ) { Vec_IntUpdateEntry( &p->vLevelD, i, x ); return x; }
294static inline int Acb_ObjUpdateLevelR( Acb_Ntk_t * p, int i, int x ) { Vec_IntUpdateEntry( &p->vLevelR, i, x ); return x; }
295static inline int Acb_ObjAddToPathD( Acb_Ntk_t * p, int i, int x ) { Vec_IntAddToEntry( &p->vPathD, i, x ); return x; }
296static inline int Acb_ObjAddToPathR( Acb_Ntk_t * p, int i, int x ) { Vec_IntAddToEntry( &p->vPathR, i, x ); return x; }
297
298static inline int Acb_ObjNtkId( Acb_Ntk_t * p, int i ) { assert(i>0); return Acb_ObjIsBox(p, i) ? Acb_ObjFanin(p, i, Acb_ObjFaninNum(p, i)) : 0; }
299static inline Acb_Ntk_t * Acb_ObjNtk( Acb_Ntk_t * p, int i ) { assert(i>0); return Acb_NtkNtk(p, Acb_ObjNtkId(p, i)); }
300static inline int Acb_ObjIsSeq( Acb_Ntk_t * p, int i ) { assert(i>0); return Acb_ObjIsBox(p, i) ? Acb_ObjNtk(p, i)->fSeq : Acb_TypeIsSeq(Acb_ObjType(p, i)); }
301
302static inline int Acb_ObjRangeId( Acb_Ntk_t * p, int i ) { return Acb_NtkHasObjRanges(p) ? Vec_IntEntry(&p->vObjRange, i) : 0; }
303static inline int Acb_ObjRange( Acb_Ntk_t * p, int i ) { return Abc_Lit2Var( Acb_ObjRangeId(p, i) ); }
304static inline int Acb_ObjLeft( Acb_Ntk_t * p, int i ) { return Acb_NtkRangeLeft(p, Acb_ObjRange(p, i)); }
305static inline int Acb_ObjRight( Acb_Ntk_t * p, int i ) { return Acb_NtkRangeRight(p, Acb_ObjRange(p, i)); }
306static inline int Acb_ObjSigned( Acb_Ntk_t * p, int i ) { return Abc_LitIsCompl(Acb_ObjRangeId(p, i)); }
307static inline int Acb_ObjRangeSize( Acb_Ntk_t * p, int i ) { return Acb_NtkRangeSize(p, Acb_ObjRange(p, i)); }
308static inline void Acb_ObjSetRangeSign( Acb_Ntk_t * p, int i, int x ) { assert(Acb_NtkHasObjRanges(p)); Vec_IntWriteEntry(&p->vObjRange, i, x); }
309static inline void Acb_ObjSetRange( Acb_Ntk_t * p, int i, int x ) { assert(Acb_NtkHasObjRanges(p)); Vec_IntWriteEntry(&p->vObjRange, i, Abc_Var2Lit(x,0)); }
310static inline void Acb_ObjHashRange( Acb_Ntk_t * p, int i, int l, int r ) { Acb_ObjSetRange( p, i, Acb_NtkHashRange(p, l, r) ); }
311static inline int Acb_ObjRangeSign( Acb_Ntk_t * p, int i ) { return Abc_Var2Lit( Acb_ObjRangeSize(p, i), Acb_ObjSigned(p, i) ); }
312
313static inline int Acb_ObjTravId( Acb_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vObjTrav, i); }
314static inline int Acb_ObjTravIdDiff( Acb_Ntk_t * p, int i ) { return p->nObjTravs - Vec_IntEntry(&p->vObjTrav, i); }
315static inline int Acb_ObjIsTravIdCur( Acb_Ntk_t * p, int i ) { return Acb_ObjTravId(p, i) == p->nObjTravs; }
316static inline int Acb_ObjIsTravIdPrev( Acb_Ntk_t * p, int i ) { return Acb_ObjTravId(p, i) == p->nObjTravs-1; }
317static inline int Acb_ObjIsTravIdDiff( Acb_Ntk_t * p, int i, int d ) { return Acb_ObjTravId(p, i) == p->nObjTravs-d; }
318static inline int Acb_ObjSetTravIdCur( Acb_Ntk_t * p, int i ) { int r = Acb_ObjIsTravIdCur(p, i); Vec_IntWriteEntry(&p->vObjTrav, i, p->nObjTravs); return r; }
319static inline int Acb_ObjSetTravIdPrev( Acb_Ntk_t * p, int i ) { int r = Acb_ObjIsTravIdPrev(p, i); Vec_IntWriteEntry(&p->vObjTrav, i, p->nObjTravs-1); return r; }
320static inline int Acb_ObjSetTravIdDiff( Acb_Ntk_t * p, int i, int d ) { int r = Acb_ObjTravIdDiff(p, i); Vec_IntWriteEntry(&p->vObjTrav, i, p->nObjTravs-d); return r; }
321static inline int Acb_NtkTravId( Acb_Ntk_t * p ) { return p->nObjTravs; }
322static inline void Acb_NtkIncTravId( Acb_Ntk_t * p ) { if ( !Acb_NtkHasObjTravs(p) ) Acb_NtkCleanObjTravs(p); p->nObjTravs++; }
323
327
328#define Acb_ManForEachNtk( p, pNtk, i ) \
329 for ( i = 1; (i <= Acb_ManNtkNum(p)) && (((pNtk) = Acb_ManNtk(p, i)), 1); i++ )
330
331#define Acb_NtkForEachPi( p, iObj, i ) \
332 for ( i = 0; (i < Acb_NtkPiNum(p)) && (((iObj) = Acb_NtkCi(p, i)), 1); i++ )
333#define Acb_NtkForEachPo( p, iObj, i ) \
334 for ( i = 0; (i < Acb_NtkPoNum(p)) && (((iObj) = Acb_NtkCo(p, i)), 1); i++ )
335
336#define Acb_NtkForEachCi( p, iObj, i ) \
337 for ( i = 0; (i < Acb_NtkCiNum(p)) && (((iObj) = Acb_NtkCi(p, i)), 1); i++ )
338#define Acb_NtkForEachCo( p, iObj, i ) \
339 for ( i = 0; (i < Acb_NtkCoNum(p)) && (((iObj) = Acb_NtkCo(p, i)), 1); i++ )
340#define Acb_NtkForEachCoDriver( p, iObj, i ) \
341 for ( i = 0; (i < Acb_NtkCoNum(p)) && (((iObj) = Acb_ObjFanin(p, Acb_NtkCo(p, i), 0)), 1); i++ )
342#define Acb_NtkForEachCoAndDriver( p, iObj, iDriver, i ) \
343 for ( i = 0; (i < Acb_NtkCoNum(p)) && (((iObj) = Acb_NtkCo(p, i)), 1) && (((iDriver) = Acb_ObjFanin(p, iObj, 0)), 1); i++ )
344
345#define Acb_NtkForEachCiVec( vVec, p, iObj, i ) \
346 for ( i = 0; (i < Vec_IntSize(vVec)) && (((iObj) = Acb_NtkCi(p, Vec_IntEntry(vVec,i))), 1); i++ )
347#define Acb_NtkForEachCoVec( vVec, p, iObj, i ) \
348 for ( i = 0; (i < Vec_IntSize(vVec)) && (((iObj) = Acb_NtkCo(p, Vec_IntEntry(vVec,i))), 1); i++ )
349#define Acb_NtkForEachCoDriverVec( vVec, p, iObj, i ) \
350 for ( i = 0; (i < Vec_IntSize(vVec)) && (((iObj) = Acb_ObjFanin(p, Acb_NtkCo(p, Vec_IntEntry(vVec,i)), 0)), 1); i++ )
351
352#define Acb_NtkForEachBoxSeq( p, iObj, i ) \
353 for ( i = 0; (i < Acb_NtkSeqNum(p)) && (((iObj) = Acb_NtkBoxSeq(p, i)), 1); i++ )
354#define Acb_NtkForEachCioOrder( p, iObj, i ) \
355 for ( i = 0; (i < Acb_NtkCioOrderNum(p)) && (((iObj) = Acb_NtkCioOrder(p, i)), 1); i++ )
356
357
358#define Acb_NtkForEachObj( p, i ) \
359 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Acb_ObjType(p, i) ) {} else
360#define Acb_NtkForEachObjReverse( p, i ) \
361 for ( i = Vec_StrSize(&p->vObjType)-1; i > 0; i-- ) if ( !Acb_ObjType(p, i) ) {} else
362#define Acb_NtkForEachNode( p, i ) \
363 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Acb_ObjType(p, i) || Acb_ObjIsCio(p, i) ) {} else
364#define Acb_NtkForEachNodeSupp( p, i, nSuppSize ) \
365 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Acb_ObjType(p, i) || Acb_ObjIsCio(p, i) || Acb_ObjFaninNum(p, i) != nSuppSize ) {} else
366#define Acb_NtkForEachNodeReverse( p, i ) \
367 for ( i = Vec_StrSize(&p->vObjType)-1; i > 0; i-- ) if ( !Acb_ObjType(p, i) || Acb_ObjIsCio(p, i) ) {} else
368#define Acb_NtkForEachObjType( p, Type, i ) \
369 for ( i = 1; i < Vec_StrSize(&p->vObjType) && (((Type) = Acb_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
370#define Acb_NtkForEachBox( p, i ) \
371 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Acb_ObjIsBox(p, i) ) {} else
372
373#define Acb_ObjForEachFanin( p, iObj, iFanin, k ) \
374 for ( k = 0; k < Acb_ObjFaninNum(p, iObj) && ((iFanin = Acb_ObjFanin(p, iObj, k)), 1); k++ )
375#define Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k ) \
376 for ( k = 0, pFanins = Acb_ObjFanins(p, iObj); k < pFanins[0] && ((iFanin = pFanins[k+1]), 1); k++ )
377
378#define Acb_ObjForEachFanout( p, iObj, iFanout, k ) \
379 Vec_IntForEachEntry( Vec_WecEntry(&p->vFanouts, iObj), iFanout, k ) if ( !Acb_ObjType(p, iFanout) ) {} else
380
381#define Acb_ObjForEachFon( p, iObj, iFon ) \
382 for ( assert(Acb_ObjIsBox(p, iObj)), iFon = iObj + 1; iFon < Acb_NtkObjNum(p) && Acb_ObjIsFon(p, iFon); iFon++ )
383
387
399static inline int Acb_ObjFonNum( Acb_Ntk_t * p, int iObj )
400{
401 int i, Count = 0;
402 if ( !Acb_ObjIsBox(p, iObj) )
403 return 0;
404 Acb_ObjForEachFon( p, iObj, i )
405 Count++;
406 return Count;
407}
408static inline int Acb_ObjWhatFanin( Acb_Ntk_t * p, int iObj, int iFaninGiven )
409{
410 int k, iFanin, * pFanins;
411 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
412 if ( iFanin == iFaninGiven )
413 return k;
414 return -1;
415}
416static inline void Acb_ObjAddFanin( Acb_Ntk_t * p, int iObj, int iFanin )
417{
418 int * pFanins = Acb_ObjFanins( p, iObj );
419 assert( iFanin > 0 );
420 assert( pFanins[ 1 + pFanins[0] ] == -1 );
421 pFanins[ 1 + pFanins[0]++ ] = iFanin;
422}
423static inline void Acb_ObjDeleteFaninIndex( Acb_Ntk_t * p, int iObj, int iFaninIndex )
424{
425 int i, * pFanins = Acb_ObjFanins( p, iObj );
426 pFanins[0]--;
427 for ( i = iFaninIndex; i < pFanins[0]; i++ )
428 pFanins[ 1 + i ] = pFanins[ 2 + i ];
429 pFanins[ 1 + pFanins[0] ] = -1;
430}
431static inline void Acb_ObjDeleteFanin( Acb_Ntk_t * p, int iObj, int iFanin )
432{
433 int * pFanins = Acb_ObjFanins( p, iObj );
434 int iFaninIndex = Acb_ObjWhatFanin( p, iObj, iFanin );
435 assert( pFanins[ 1 + iFaninIndex ] == iFanin );
436 Acb_ObjDeleteFaninIndex( p, iObj, iFaninIndex );
437}
438static inline void Acb_ObjAddFanins( Acb_Ntk_t * p, int iObj, Vec_Int_t * vFanins )
439{
440 int i, iFanin;
441 if ( vFanins )
442 Vec_IntForEachEntry( vFanins, iFanin, i )
443 Acb_ObjAddFanin( p, iObj, iFanin );
444}
445static inline void Acb_ObjSetNtkId( Acb_Ntk_t * p, int iObj, int iNtk ) // should be called after fanins are added
446{
447 int * pFanins = Acb_ObjFanins( p, iObj );
448 assert( pFanins[ 1 + pFanins[0] ] == -1 );
449 pFanins[ 1 + pFanins[0] ] = iNtk;
450}
451static inline void Acb_ObjRemoveFanins( Acb_Ntk_t * p, int iObj )
452{
453 int i, * pFanins = Acb_ObjFanins( p, iObj );
454 for ( i = 1; i <= pFanins[0]; i++ )
455 {
456 assert( pFanins[i] > 0 );
457 pFanins[i] = -1;
458 }
459 pFanins[0] = 0;
460}
461static inline int Acb_ObjAlloc( Acb_Ntk_t * p, Acb_ObjType_t Type, int nFans, int nFons )
462{
463 int i, nFansReal, CioId = -1, iObj = Vec_StrSize(&p->vObjType);
464 Vec_StrPush( &p->vObjType, (char)Type );
465 if ( Type == ABC_OPER_CI )
466 {
467 assert( nFans == 0 );
468 CioId = Vec_IntSize( &p->vCis );
469 Vec_IntPush( &p->vCis, iObj );
470 nFansReal = 2;
471 }
472 else if ( Type == ABC_OPER_CO )
473 {
474 assert( nFans == 1 );
475 CioId = Vec_IntSize( &p->vCos );
476 Vec_IntPush( &p->vCos, iObj );
477 nFansReal = 2;
478 }
479 else
480 nFansReal = Abc_MaxInt( nFans + Acb_ObjIsBox(p, iObj), p->nFaninMax );
481 // add fins
482 Vec_IntPush( &p->vObjFans, Vec_IntSize(&p->vFanSto) );
483 Vec_IntPush( &p->vFanSto, 0 );
484 for ( i = 0; i < nFansReal; i++ )
485 Vec_IntPush( &p->vFanSto, (CioId >= 0 && i == 1) ? CioId : -1 );
486 // add fons
487 assert( !Acb_ObjIsBox(p, iObj) || nFons > 0 );
488 for ( i = 0; i < nFons; i++ )
489 Acb_ObjAddFanin( p, Acb_ObjAlloc(p, ABC_OPER_FON, 1, 0), iObj );
490 // extend storage
491 if ( Acb_NtkHasObjCopies(p) ) Vec_IntPush(&p->vObjCopy , -1);
492 if ( Acb_NtkHasObjFuncs(p) ) Vec_IntPush(&p->vObjFunc , -1);
493 if ( Acb_NtkHasObjWeights(p)) Vec_IntPush(&p->vObjWeight, 0);
494 if ( Acb_NtkHasObjTruths(p) ) Vec_WrdPush(&p->vObjTruth , 0);
495 if ( Acb_NtkHasObjNames(p) ) Vec_IntPush(&p->vObjName , 0);
496 if ( Acb_NtkHasObjRanges(p) ) Vec_IntPush(&p->vObjRange , 0);
497 if ( Acb_NtkHasObjTravs(p) ) Vec_IntPush(&p->vObjTrav , 0);
498 if ( Acb_NtkHasObjAttrs(p) ) Vec_IntPush(&p->vObjAttr , 0);
499 if ( Acb_NtkHasObjLevelD(p) ) Vec_IntPush(&p->vLevelD , 0);
500 if ( Acb_NtkHasObjLevelR(p) ) Vec_IntPush(&p->vLevelR , 0);
501 if ( Acb_NtkHasObjPathD(p) ) Vec_IntPush(&p->vPathD , 0);
502 if ( Acb_NtkHasObjPathR(p) ) Vec_IntPush(&p->vPathR , 0);
503 if ( Acb_NtkHasObjCounts(p) ) Vec_FltPush(&p->vCounts , 0);
504 if ( Acb_NtkHasObjFanout(p) ) Vec_WecPushLevel(&p->vFanouts);
505 if ( Acb_NtkHasObjCnfs(p) ) Vec_WecPushLevel(&p->vCnfs);
506 if ( p->vQue ) Vec_QueSetPriority( p->vQue, Vec_FltArrayP(&p->vCounts) );
507 return iObj;
508}
509static inline int Acb_ObjDup( Acb_Ntk_t * pNew, Acb_Ntk_t * p, int i )
510{
511 int iObj = Acb_ObjAlloc( pNew, Acb_ObjType(p, i), Acb_ObjFaninNum(p, i), Acb_ObjFonNum(p, i) );
512 Acb_ObjSetCopy( p, i, iObj );
513 return iObj;
514}
515static inline void Acb_ObjDelete( Acb_Ntk_t * p, int iObj )
516{
517 int i;
518 Acb_ObjCleanType( p, iObj );
519 if ( !Acb_ObjIsBox(p, iObj) )
520 return;
521 Acb_ObjForEachFon( p, iObj, i )
522 Acb_ObjCleanType( p, i );
523}
524static inline void Acb_ObjAddFaninFanoutOne( Acb_Ntk_t * p, int iObj, int iFanin )
525{
526 Vec_IntPush( Vec_WecEntry(&p->vFanouts, iFanin), iObj );
527 Acb_ObjAddFanin( p, iObj, iFanin );
528}
529static inline void Acb_ObjAddFaninFanout( Acb_Ntk_t * p, int iObj )
530{
531 int k, iFanin, * pFanins;
532 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
533 Vec_IntPush( Vec_WecEntry(&p->vFanouts, iFanin), iObj );
534}
535static inline void Acb_ObjRemoveFaninFanoutOne( Acb_Ntk_t * p, int iObj, int iFanin )
536{
537 int RetValue = Vec_IntRemove( Vec_WecEntry(&p->vFanouts, iFanin), iObj );
538 assert( RetValue );
539 Acb_ObjDeleteFanin( p, iObj, iFanin );
540}
541static inline void Acb_ObjRemoveFaninFanout( Acb_Ntk_t * p, int iObj )
542{
543 int k, iFanin, * pFanins;
544 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
545 {
546 int RetValue = Vec_IntRemove( Vec_WecEntry(&p->vFanouts, iFanin), iObj );
547 assert( RetValue );
548 }
549}
550static inline void Acb_ObjPatchFanin( Acb_Ntk_t * p, int iObj, int iFanin, int iFaninNew )
551{
552 int i, RetValue, * pFanins = Acb_ObjFanins( p, iObj );
553 assert( iFanin != iFaninNew );
554 for ( i = 0; i < pFanins[0]; i++ )
555 if ( pFanins[ 1 + i ] == iFanin )
556 pFanins[ 1 + i ] = iFaninNew;
557 if ( !Acb_NtkHasObjFanout(p) )
558 return;
559 RetValue = Vec_IntRemove( Vec_WecEntry(&p->vFanouts, iFanin), iObj );
560 assert( RetValue );
561 Vec_IntPush( Vec_WecEntry(&p->vFanouts, iFaninNew), iObj );
562}
563static inline void Acb_NtkCreateFanout( Acb_Ntk_t * p )
564{
565 int iObj;
566 Acb_NtkCleanObjFanout( p );
567 Acb_NtkForEachObj( p, iObj )
568 Acb_ObjAddFaninFanout( p, iObj );
569}
570
582static inline Acb_Ntk_t * Acb_NtkAlloc( Acb_Man_t * p, int NameId, int nCis, int nCos, int nObjs )
583{
584 Acb_Ntk_t * pNew = ABC_CALLOC( Acb_Ntk_t, 1 );
585 assert( nCis >= 0 && nCos >= 0 && nObjs >= 0 );
586 pNew->Id = Vec_PtrSize(&p->vNtks); Vec_PtrPush( &p->vNtks, pNew );
587 pNew->NameId = NameId;
588 pNew->pDesign = p;
589 Vec_IntGrow( &pNew->vCis, nCis );
590 Vec_IntGrow( &pNew->vCos, nCos );
591 Vec_StrGrow( &pNew->vObjType, nObjs+1 ); Vec_StrPush( &pNew->vObjType, (char)ABC_OPER_NONE );
592 Vec_IntGrow( &pNew->vObjFans, nObjs+1 ); Vec_IntPush( &pNew->vObjFans, -1 );
593 Vec_IntGrow( &pNew->vFanSto, 3*nObjs );
594 return pNew;
595}
596static inline void Acb_NtkFree( Acb_Ntk_t * p )
597{
598 // interface
599 Vec_IntErase( &p->vCis );
600 Vec_IntErase( &p->vCos );
601 Vec_IntErase( &p->vOrder );
602 Vec_IntErase( &p->vSeq );
603 // stucture
604 Vec_StrErase( &p->vObjType );
605 Vec_IntErase( &p->vObjFans );
606 Vec_IntErase( &p->vFanSto );
607 // optional
608 Vec_IntErase( &p->vObjCopy );
609 Vec_IntErase( &p->vObjFunc );
610 Vec_IntErase( &p->vObjWeight );
611 Vec_WrdErase( &p->vObjTruth );
612 Vec_IntErase( &p->vObjName );
613 Vec_IntErase( &p->vObjRange );
614 Vec_IntErase( &p->vObjTrav );
615 Vec_IntErase( &p->vObjBits );
616 Vec_IntErase( &p->vObjAttr );
617 Vec_IntErase( &p->vAttrSto );
618 Vec_IntErase( &p->vNtkObjs );
619 Vec_IntErase( &p->vTargets );
620 Vec_IntErase( &p->vLevelD );
621 Vec_IntErase( &p->vLevelR );
622 Vec_IntErase( &p->vPathD );
623 Vec_IntErase( &p->vPathR );
624 Vec_FltErase( &p->vCounts );
625 Vec_WecErase( &p->vFanouts );
626 Vec_WecErase( &p->vCnfs );
627 Vec_StrErase( &p->vCnf );
628 Vec_IntErase( &p->vSuppOld );
629 // other
630 Vec_QueFreeP( &p->vQue );
631 Vec_IntErase( &p->vCover );
632 Vec_IntErase( &p->vArray0 );
633 Vec_IntErase( &p->vArray1 );
634 Vec_IntErase( &p->vArray2 );
635 ABC_FREE( p );
636}
637static inline int Acb_NtkNewStrId( Acb_Ntk_t * pNtk, const char * format, ... )
638{
639 Abc_Nam_t * p = Acb_NtkNam( pNtk );
640 Vec_Str_t * vBuf = Abc_NamBuffer( p );
641 int nAdded, nSize = 1000;
642 va_list args; va_start( args, format );
643 Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nSize );
644 nAdded = vsnprintf( Vec_StrLimit(vBuf), nSize, format, args );
645 if ( nAdded > nSize )
646 {
647 Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nAdded + nSize );
648 nSize = vsnprintf( Vec_StrLimit(vBuf), nAdded, format, args );
649 assert( nSize == nAdded );
650 }
651 va_end( args );
652 return Abc_NamStrFindOrAddLim( p, Vec_StrLimit(vBuf), Vec_StrLimit(vBuf) + nAdded, NULL );
653}
654static inline int Acb_ManNewConstId( Acb_Ntk_t * p, Vec_Str_t * vBits )
655{
656 Vec_Str_t * vOut = Abc_NamBuffer(Acb_NtkNam(p));
657 Vec_StrPrintF( vOut, "%d\'b%s", Vec_StrSize(vBits)-1, Vec_StrArray(vBits) );
658 return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
659}
660static inline int Acb_ManNewConstZero( Acb_Ntk_t * p, int nBits )
661{
662 Vec_Str_t * vOut = Abc_NamBuffer(Acb_NtkNam(p));
663 Vec_StrPrintF( vOut, "%d\'b%0s", nBits, "" );
664 return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
665}
666static inline void Acb_NtkAdd( Acb_Man_t * p, Acb_Ntk_t * pNtk )
667{
668 int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Acb_NtkName(pNtk), &fFound );
669 if ( fFound )
670 printf( "Network with name \"%s\" already exists.\n", Acb_NtkName(pNtk) );
671 else
672 assert( NtkId == pNtk->Id );
673}
674static inline void Acb_NtkUpdate( Acb_Man_t * p, Acb_Ntk_t * pNtk )
675{
676 int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Acb_NtkName(pNtk), &fFound );
677 if ( !fFound )
678 printf( "Network with name \"%s\" does not exist.\n", Acb_NtkName(pNtk) );
679 else
680 {
681 Acb_NtkFree( Acb_ManNtk(p, NtkId) );
682 Vec_PtrWriteEntry( &p->vNtks, NtkId, pNtk );
683 }
684}
685static inline Vec_Int_t * Acb_NtkCollect( Acb_Ntk_t * p )
686{
687 int iObj;
688 Vec_Int_t * vObjs = Vec_IntAlloc( Acb_NtkObjNum(p) );
689 Acb_NtkForEachObj( p, iObj )
690 Vec_IntPush( vObjs, iObj );
691 return vObjs;
692}
693static inline Acb_Ntk_t * Acb_NtkDup( Acb_Man_t * pMan, Acb_Ntk_t * p, Vec_Int_t * vObjs )
694{
695 Acb_Ntk_t * pNew;
696 int i, k, iObj, iObjNew, iFanin;
697 pNew = Acb_NtkAlloc( pMan, Acb_NtkNameId(p), Acb_NtkCiNum(p), Acb_NtkCoNum(p), Vec_IntSize(vObjs) );
698 Acb_NtkCleanObjCopies( p );
699 Vec_IntForEachEntry( vObjs, iObj, i )
700 iObjNew = Acb_ObjDup( pNew, p, iObj );
701 Vec_IntForEachEntry( vObjs, iObj, i )
702 {
703 iObjNew = Acb_ObjCopy( p, iObj );
704 Acb_ObjForEachFanin( p, iObj, iFanin, k )
705 Acb_ObjAddFanin( pNew, iObjNew, Acb_ObjCopy(p, iFanin) );
706 }
707 //Acb_NtkFreeObjCopies( p );
708 assert( Acb_NtkObjNum(pNew) == Acb_NtkObjNumAlloc(pNew) );
709 Acb_NtkSetCopy( p, Acb_NtkId(pNew) );
710 Acb_NtkSetRegNum( pNew, Acb_NtkRegNum(p) );
711 return pNew;
712}
713static inline Acb_Ntk_t * Acb_NtkDupOrder( Acb_Man_t * pMan, Acb_Ntk_t * p, Vec_Int_t*(* pFuncOrder)(Acb_Ntk_t*) )
714{
715 Acb_Ntk_t * pNew;
716 Vec_Int_t * vObjs = pFuncOrder ? pFuncOrder(p) : Acb_NtkCollect(p);
717 if ( vObjs == NULL )
718 return NULL;
719 pNew = Acb_NtkDup( pMan, p, vObjs );
720 Vec_IntFree( vObjs );
721 //Acb_NtkPrepareSeq( pNew );
722 return pNew;
723}
724static inline void Acb_NtkDupAttrs( Acb_Ntk_t * pNew, Acb_Ntk_t * p )
725{
726 int i, iObj;
727 assert( Vec_IntSize(&pNew->vOrder) == 0 );
728 Acb_NtkForEachCioOrder( p, iObj, i )
729 Vec_IntPush( &pNew->vOrder, Acb_ObjCopy(p, iObj) );
730// Vec_IntRemapArray( &p->vObjCopy, &p->vOrder, &pNew->vOrder, Acb_NtkCioOrderNum(p) );
731// Vec_IntRemapArray( &p->vObjCopy, &p->vSeq, &pNew->vSeq, Acb_NtkSeqNum(p) );
732 // transfer object attributes
733 Vec_IntRemapArray( &p->vObjCopy, &p->vObjFunc, &pNew->vObjFunc, Acb_NtkObjNum(pNew) + 1 );
734 Vec_IntRemapArray( &p->vObjCopy, &p->vObjWeight, &pNew->vObjWeight, Acb_NtkObjNum(pNew) + 1 );
735// Vec_WrdRemapArray( &p->vObjCopy, &p->vObjTruth, &pNew->vObjTruth, Acb_NtkObjNum(pNew) + 1 );
736 Vec_IntRemapArray( &p->vObjCopy, &p->vObjName, &pNew->vObjName, Acb_NtkObjNum(pNew) + 1 );
737 Vec_IntRemapArray( &p->vObjCopy, &p->vObjRange, &pNew->vObjRange, Acb_NtkObjNum(pNew) + 1 );
738 Vec_IntRemapArray( &p->vObjCopy, &p->vObjAttr, &pNew->vObjAttr, Acb_NtkObjNum(pNew) + 1 );
739 // duplicate attributes
740 Vec_IntAppend( &pNew->vAttrSto, &p->vAttrSto );
741}
742static inline int Acb_NtkMemory( Acb_Ntk_t * p )
743{
744 int nMem = sizeof(Acb_Ntk_t);
745 // interface
746 nMem += (int)Vec_IntMemory(&p->vCis);
747 nMem += (int)Vec_IntMemory(&p->vCos);
748 nMem += (int)Vec_IntMemory(&p->vOrder);
749 nMem += (int)Vec_IntMemory(&p->vSeq);
750 // stucture
751 nMem += (int)Vec_StrMemory(&p->vObjType);
752 nMem += (int)Vec_IntMemory(&p->vObjFans);
753 nMem += (int)Vec_IntMemory(&p->vFanSto);
754 nMem += (int)Vec_WecMemory(&p->vFanouts);
755 // optional
756 nMem += (int)Vec_IntMemory(&p->vObjCopy );
757 nMem += (int)Vec_IntMemory(&p->vObjFunc );
758 nMem += (int)Vec_IntMemory(&p->vObjWeight );
759 nMem += (int)Vec_WrdMemory(&p->vObjTruth );
760 nMem += (int)Vec_IntMemory(&p->vObjName );
761 nMem += (int)Vec_IntMemory(&p->vObjRange );
762 nMem += (int)Vec_IntMemory(&p->vObjTrav );
763 nMem += (int)Vec_IntMemory(&p->vObjBits );
764 nMem += (int)Vec_IntMemory(&p->vObjAttr );
765 nMem += (int)Vec_IntMemory(&p->vAttrSto );
766 nMem += (int)Vec_IntMemory(&p->vNtkObjs );
767 nMem += (int)Vec_IntMemory(&p->vTargets );
768 // other
769 nMem += (int)Vec_IntMemory(&p->vCover );
770 nMem += (int)Vec_IntMemory(&p->vArray0 );
771 nMem += (int)Vec_IntMemory(&p->vArray1 );
772 nMem += (int)Vec_IntMemory(&p->vArray2 );
773 return nMem;
774}
775static inline void Acb_NtkPrintStats( Acb_Ntk_t * p )
776{
777 printf( "pi =%5d ", Acb_NtkPiNum(p) );
778 printf( "po =%5d ", Acb_NtkPoNum(p) );
779 printf( "ff =%5d ", Acb_NtkRegNum(p) );
780 printf( "node =%5d ", Acb_NtkNodeNum(p) );
781 printf( "box =%5d ", Acb_NtkBoxNum(p) );
782 //printf( "topo =%4s ", Acb_NtkIsTopoOrder(p) ? "yes" : "no" );
783 printf( " %s ", Acb_NtkName(p) );
784 if ( Vec_IntSize(&p->vNtkObjs) )
785 printf( "-> %s", Acb_NtkName(Acb_NtkNtk(p, Vec_IntEntry(&p->vNtkObjs, 0))) );
786 printf( "\n" );
787// Vec_StrIntPrint( &p->vObjType );
788}
789static inline void Acb_NtkPrint( Acb_Ntk_t * p )
790{
791 int i, Type;
792 printf( "Interface (%d):\n", Acb_NtkCioNum(p) );
793 printf( "Objects (%d):\n", Acb_NtkObjNum(p) );
794 Acb_NtkForEachObjType( p, Type, i )
795 {
796 printf( "%6d : ", i );
797 printf( "Type =%3d ", Type );
798 printf( "Fanins = %d ", Acb_ObjFaninNum(p, i) );
799 if ( Acb_NtkHasObjNames(p) && Acb_ObjName(p, i) )
800 printf( "%s", Acb_ObjNameStr(p, i) );
801 printf( "\n" );
802 }
803}
804
816static inline Acb_Man_t * Acb_ManAlloc( char * pFileName, int nNtks, Abc_Nam_t * pStrs, Abc_Nam_t * pFuns, Abc_Nam_t * pMods, Hash_IntMan_t * vHash )
817{
818 Acb_Man_t * pNew = ABC_CALLOC( Acb_Man_t, 1 );
819 pNew->pName = Extra_FileDesignName( pFileName );
820 pNew->pSpec = Abc_UtilStrsav( pFileName );
821 pNew->pStrs = pStrs ? pStrs : Abc_NamStart( 1000, 24 );
822 pNew->pFuns = pFuns ? pFuns : Abc_NamStart( 100, 24 );
823 pNew->pMods = pMods ? pMods : Abc_NamStart( 100, 24 );
824 pNew->vHash = vHash ? vHash : Hash_IntManStart( 1000 );
825 if ( pFuns == NULL )
826 {
827 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b0", NULL);
828 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b1", NULL);
829 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bx", NULL);
830 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bz", NULL);
831 }
832// if ( vHash == NULL )
833// Hash_Int2ManInsert( pNew->vHash, 0, 0, 0 );
834 Vec_PtrGrow( &pNew->vNtks, nNtks+1 ); Vec_PtrPush( &pNew->vNtks, NULL );
835 // set default root module
836 pNew->iRoot = 1;
837 return pNew;
838}
839static inline void Acb_ManDupTypeNames( Acb_Man_t * pNew, Acb_Man_t * p )
840{
841 memcpy( pNew->pTypeNames, p->pTypeNames, sizeof(void *) * ABC_OPER_LAST );
842}
843static inline Acb_Man_t * Acb_ManDup( Acb_Man_t * p, Vec_Int_t*(* pFuncOrder)(Acb_Ntk_t*) )
844{
845 Acb_Ntk_t * pNtk, * pNtkNew; int i;
846 Acb_Man_t * pNew = Acb_ManAlloc( p->pSpec, Acb_ManNtkNum(p), Abc_NamRef(p->pStrs), Abc_NamRef(p->pFuns), Abc_NamStart(100, 24), Hash_IntManRef(p->vHash) );
847 Acb_ManDupTypeNames( pNew, p );
848 Acb_ManForEachNtk( p, pNtk, i )
849 {
850 pNtkNew = Acb_NtkDupOrder( pNew, pNtk, pFuncOrder );
851 Acb_NtkAdd( pNew, pNtkNew );
852 Acb_NtkDupAttrs( pNtkNew, pNtk );
853 }
854// Acb_ManForEachNtk( p, pNtk, i )
855// if ( (pHost = Acb_NtkHostNtk(pNtk)) )
856// Acb_NtkSetHost( Acb_NtkCopyNtk(pNew, pNtk), Acb_NtkCopy(pHost), Acb_ObjCopy(pHost, Acb_NtkHostObj(pNtk)) );
857 pNew->iRoot = Acb_ManNtkNum(pNew);
858 return pNew;
859}
860static inline void Acb_ManFree( Acb_Man_t * p )
861{
862 Acb_Ntk_t * pNtk; int i;
863 Acb_ManForEachNtk( p, pNtk, i )
864 Acb_NtkFree( pNtk );
865 ABC_FREE( p->vNtks.pArray );
866 Abc_NamDeref( p->pStrs );
867 Abc_NamDeref( p->pFuns );
868 Abc_NamDeref( p->pMods );
869 Hash_IntManDeref( p->vHash );
870 Vec_IntErase( &p->vNameMap );
871 Vec_IntErase( &p->vUsed );
872 Vec_IntErase( &p->vNameMap2 );
873 Vec_IntErase( &p->vUsed2 );
874 Vec_StrErase( &p->vOut );
875 Vec_StrErase( &p->vOut2 );
876 ABC_FREE( p->pName );
877 ABC_FREE( p->pSpec );
878 ABC_FREE( p );
879}
880static inline int Acb_ManGetMap( Acb_Man_t * p, int i )
881{
882 return Vec_IntGetEntry(&p->vNameMap, i);
883}
884static inline void Acb_ManSetMap( Acb_Man_t * p, int i, int x )
885{
886 assert( Vec_IntGetEntry(&p->vNameMap, i) == 0 );
887 Vec_IntSetEntry( &p->vNameMap, i, x );
888 Vec_IntPush( &p->vUsed, i );
889}
890static inline void Acb_ManUnsetMap( Acb_Man_t * p, int i )
891{
892 Vec_IntSetEntry( &p->vNameMap, i, 0 );
893}
894static inline void Acb_ManCleanMap( Acb_Man_t * p )
895{
896 int i, Entry;
897 Vec_IntForEachEntry( &p->vUsed, Entry, i )
898 Vec_IntWriteEntry( &p->vNameMap, Entry, 0 );
899 Vec_IntClear( &p->vUsed );
900}
901static inline int Acb_NtkGetMap( Acb_Ntk_t * p, int i ) { return Acb_ManGetMap(p->pDesign, i); }
902static inline void Acb_NtkSetMap( Acb_Ntk_t * p, int i, int x ) { Acb_ManSetMap(p->pDesign, i, x); }
903static inline void Acb_NtkUnsetMap( Acb_Ntk_t * p, int i ) { Acb_ManUnsetMap(p->pDesign, i); }
904static inline void Acb_NtkCleanMap( Acb_Ntk_t * p ) { Acb_ManCleanMap(p->pDesign); }
905
906static inline int Acb_ManGetMap2( Acb_Man_t * p, int i )
907{
908 return Vec_IntGetEntry(&p->vNameMap2, i);
909}
910static inline void Acb_ManSetMap2( Acb_Man_t * p, int i, int x )
911{
912 assert( Vec_IntGetEntry(&p->vNameMap2, i) == 0 );
913 Vec_IntSetEntry( &p->vNameMap2, i, x );
914 Vec_IntPush( &p->vUsed2, i );
915}
916static inline void Acb_ManUnsetMap2( Acb_Man_t * p, int i )
917{
918 Vec_IntSetEntry( &p->vNameMap2, i, 0 );
919}
920static inline void Acb_ManCleanMap2( Acb_Man_t * p )
921{
922 int i, Entry;
923 Vec_IntForEachEntry( &p->vUsed2, Entry, i )
924 Vec_IntWriteEntry( &p->vNameMap2, Entry, 0 );
925 Vec_IntClear( &p->vUsed2 );
926}
927static inline int Acb_NtkGetMap2( Acb_Ntk_t * p, int i ) { return Acb_ManGetMap2(p->pDesign, i); }
928static inline void Acb_NtkSetMap2( Acb_Ntk_t * p, int i, int x ) { Acb_ManSetMap2(p->pDesign, i, x); }
929static inline void Acb_NtkUnsetMap2( Acb_Ntk_t * p, int i ) { Acb_ManUnsetMap2(p->pDesign, i); }
930static inline void Acb_NtkCleanMap2( Acb_Ntk_t * p ) { Acb_ManCleanMap2(p->pDesign); }
931
932static inline int Acb_ManMemory( Acb_Man_t * p )
933{
934 Acb_Ntk_t * pNtk; int i;
935 int nMem = sizeof(Acb_Man_t);
936 nMem += p->pName ? (int)strlen(p->pName) : 0;
937 nMem += p->pSpec ? (int)strlen(p->pSpec) : 0;
938 nMem += Abc_NamMemUsed(p->pStrs);
939 nMem += Abc_NamMemUsed(p->pFuns);
940 nMem += Abc_NamMemUsed(p->pMods);
941 nMem += (int)Vec_IntMemory(&p->vNameMap );
942 nMem += (int)Vec_IntMemory(&p->vUsed );
943 nMem += (int)Vec_StrMemory(&p->vOut );
944 nMem += (int)Vec_StrMemory(&p->vOut2 );
945 nMem += (int)Vec_PtrMemory(&p->vNtks);
946 Acb_ManForEachNtk( p, pNtk, i )
947 nMem += Acb_NtkMemory( pNtk );
948 return nMem;
949}
950static inline int Acb_ManObjNum( Acb_Man_t * p )
951{
952 Acb_Ntk_t * pNtk; int i, Count = 0;
953 Acb_ManForEachNtk( p, pNtk, i )
954 Count += Acb_NtkObjNum(pNtk);
955 return Count;
956}
957static inline int Acb_ManBoxNum( Acb_Man_t * p )
958{
959 Acb_Ntk_t * pNtk; int i, Count = 0;
960 Acb_ManForEachNtk( p, pNtk, i )
961 Count += Acb_NtkBoxNum( pNtk );
962 return Count;
963}
964static inline void Acb_ManBoxNumRec_rec( Acb_Ntk_t * p, int * pCountP, int * pCountU )
965{
966 int iObj, Id = Acb_NtkId(p);
967 if ( pCountP[Id] >= 0 )
968 return;
969 pCountP[Id] = pCountU[Id] = 0;
970 Acb_NtkForEachObj( p, iObj )
971 {
972 if ( Acb_ObjIsBox(p, iObj) )
973 {
974 Acb_ManBoxNumRec_rec( Acb_ObjNtk(p, iObj), pCountP, pCountU );
975 pCountP[Id] += pCountP[Acb_ObjNtkId(p, iObj)];
976 pCountU[Id] += pCountU[Acb_ObjNtkId(p, iObj)] + 1;
977 }
978 else
979 pCountP[Id] += 1;
980 }
981}
982static inline void Acb_ManBoxNumRec( Acb_Man_t * p, int * pnPrims, int * pnUsers )
983{
984 Acb_Ntk_t * pNtk = Acb_ManRoot(p);
985 int * pCountP = ABC_FALLOC( int, Acb_ManNtkNum(p) + 1 );
986 int * pCountU = ABC_FALLOC( int, Acb_ManNtkNum(p) + 1 );
987 Acb_ManBoxNumRec_rec( pNtk, pCountP, pCountU );
988 *pnPrims = pCountP[Acb_NtkId(pNtk)];
989 *pnUsers = pCountU[Acb_NtkId(pNtk)];
990 ABC_FREE( pCountP );
991 ABC_FREE( pCountU );
992}
993static inline void Acb_ManPrintStats( Acb_Man_t * p, int nModules, int fVerbose )
994{
995 Acb_Ntk_t * pNtk; int i, nPrims, nUsers;
996 Acb_Ntk_t * pRoot = Acb_ManRoot( p );
997 Acb_ManBoxNumRec( p, &nPrims, &nUsers );
998 printf( "%-12s : ", Acb_ManName(p) );
999 printf( "pi =%5d ", Acb_NtkCiNum(pRoot) );
1000 printf( "po =%5d ", Acb_NtkCoNum(pRoot) );
1001 printf( "mod =%5d ", Acb_ManNtkNum(p) );
1002 printf( "box =%5d ", nPrims + nUsers );
1003 printf( "prim =%5d ", nPrims );
1004 printf( "user =%5d ", nUsers );
1005 printf( "mem =%6.3f MB", 1.0*Acb_ManMemory(p)/(1<<20) );
1006 printf( "\n" );
1007 Acb_ManForEachNtk( p, pNtk, i )
1008 {
1009 if ( i == nModules+1 )
1010 break;
1011 printf( "Module %5d : ", i );
1012 Acb_NtkPrintStats( pNtk );
1013 }
1014}
1015
1016
1017
1018/*=== acbUtil.c =============================================================*/
1019extern Vec_Int_t * Acb_ObjCollectTfi( Acb_Ntk_t * p, int iObj, int fTerm );
1020extern Vec_Int_t * Acb_ObjCollectTfo( Acb_Ntk_t * p, int iObj, int fTerm );
1021
1022extern Vec_Int_t * Acb_ObjCollectTfiVec( Acb_Ntk_t * p, Vec_Int_t * vObjs );
1023extern Vec_Int_t * Acb_ObjCollectTfoVec( Acb_Ntk_t * p, Vec_Int_t * vObjs );
1024extern int Acb_NtkCountPiBuffers( Acb_Ntk_t * p, Vec_Int_t * vObjs );
1025extern int Acb_NtkCountPoDrivers( Acb_Ntk_t * p, Vec_Int_t * vObjs );
1026extern int Acb_NtkFindMffcSize( Acb_Ntk_t * p, Vec_Int_t * vObjsRefed, Vec_Int_t * vObjsDerefed, int nGates[5] );
1027
1028extern int Acb_ObjComputeLevelD( Acb_Ntk_t * p, int iObj );
1029extern int Acb_NtkComputeLevelD( Acb_Ntk_t * p, Vec_Int_t * vTfo );
1030extern void Acb_NtkUpdateLevelD( Acb_Ntk_t * p, int iObj );
1031extern void Acb_NtkUpdateTiming( Acb_Ntk_t * p, int iObj );
1032
1033extern void Acb_NtkPrintNode( Acb_Ntk_t * p, int iObj );
1034extern int Acb_NtkCreateNode( Acb_Ntk_t * p, word uTruth, Vec_Int_t * vSupp );
1035extern void Acb_NtkUpdateNode( Acb_Ntk_t * p, int Pivot, word uTruth, Vec_Int_t * vSupp );
1036
1037extern Acb_Ntk_t * Acb_VerilogSimpleRead( char * pFileName, char * pFileNameW );
1038
1039ABC_NAMESPACE_HEADER_END
1040
1041
1042#endif
1043
1047
Acb_ObjType_t
Acb_ObjType_t
INCLUDES ///.
Definition abcOper.h:41
ABC_OPER_CI
@ ABC_OPER_CI
Definition abcOper.h:45
ABC_OPER_ARI_ABS
@ ABC_OPER_ARI_ABS
Definition abcOper.h:109
ABC_OPER_SEL_PSEL
@ ABC_OPER_SEL_PSEL
Definition abcOper.h:93
ABC_OPER_BOX
@ ABC_OPER_BOX
Definition abcOper.h:48
ABC_OPER_SEL_NMUX
@ ABC_OPER_SEL_NMUX
Definition abcOper.h:91
ABC_OPER_NONE
@ ABC_OPER_NONE
Definition abcOper.h:42
ABC_OPER_RED_NXOR
@ ABC_OPER_RED_NXOR
Definition abcOper.h:81
ABC_OPER_LAST
@ ABC_OPER_LAST
Definition abcOper.h:157
ABC_OPER_LOGIC_NOT
@ ABC_OPER_LOGIC_NOT
Definition abcOper.h:83
ABC_OPER_RED_AND
@ ABC_OPER_RED_AND
Definition abcOper.h:76
ABC_OPER_SEL_SEL
@ ABC_OPER_SEL_SEL
Definition abcOper.h:92
ABC_OPER_FON
@ ABC_OPER_FON
Definition abcOper.h:47
ABC_OPER_CONCAT
@ ABC_OPER_CONCAT
Definition abcOper.h:147
ABC_OPER_BIT_MUX
@ ABC_OPER_BIT_MUX
Definition abcOper.h:65
ABC_OPER_BIT_INV
@ ABC_OPER_BIT_INV
Definition abcOper.h:56
ABC_OPER_ARI_SQRT
@ ABC_OPER_ARI_SQRT
Definition abcOper.h:108
ABC_OPER_SLICE
@ ABC_OPER_SLICE
Definition abcOper.h:146
ABC_OPER_DFFLAST
@ ABC_OPER_DFFLAST
Definition abcOper.h:144
ABC_OPER_GATE
@ ABC_OPER_GATE
Definition abcOper.h:128
ABC_OPER_BIT_BUF
@ ABC_OPER_BIT_BUF
Definition abcOper.h:55
ABC_OPER_ARI_MIN
@ ABC_OPER_ARI_MIN
Definition abcOper.h:107
ABC_OPER_RAM
@ ABC_OPER_RAM
Definition abcOper.h:132
ABC_OPER_CO
@ ABC_OPER_CO
Definition abcOper.h:46
ABC_FALLOC
#define ABC_FALLOC(type, num)
Definition abc_global.h:266
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition abc_global.h:265
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition abc_namespaces.h:51
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition abc_namespaces.h:50
Acb_NtkUpdateLevelD
void Acb_NtkUpdateLevelD(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:376
Acb_VerilogSimpleRead
Acb_Ntk_t * Acb_VerilogSimpleRead(char *pFileName, char *pFileNameW)
Definition acbFunc.c:622
Acb_Ntk_t
struct Acb_Ntk_t_ Acb_Ntk_t
Definition acb.h:47
Acb_NtkCountPiBuffers
int Acb_NtkCountPiBuffers(Acb_Ntk_t *p, Vec_Int_t *vObjs)
Definition acbUtil.c:139
Acb_NtkForEachCioOrder
#define Acb_NtkForEachCioOrder(p, iObj, i)
Definition acb.h:354
Acb_Man_t
struct Acb_Man_t_ Acb_Man_t
Definition acb.h:48
Acb_NtkUpdateNode
void Acb_NtkUpdateNode(Acb_Ntk_t *p, int Pivot, word uTruth, Vec_Int_t *vSupp)
Definition acbUtil.c:681
Acb_ObjForEachFon
#define Acb_ObjForEachFon(p, iObj, iFon)
Definition acb.h:381
Acb_NtkCreateNode
int Acb_NtkCreateNode(Acb_Ntk_t *p, word uTruth, Vec_Int_t *vSupp)
Definition acbUtil.c:636
Acb_NtkPrintNode
void Acb_NtkPrintNode(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:628
Acb_NtkUpdateTiming
void Acb_NtkUpdateTiming(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:570
Acb_ObjCollectTfi
Vec_Int_t * Acb_ObjCollectTfi(Acb_Ntk_t *p, int iObj, int fTerm)
Definition acbUtil.c:59
Acb_ObjCollectTfoVec
Vec_Int_t * Acb_ObjCollectTfoVec(Acb_Ntk_t *p, Vec_Int_t *vObjs)
Definition acbUtil.c:108
Acb_ObjComputeLevelD
int Acb_ObjComputeLevelD(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:333
Acb_NtkCountPoDrivers
int Acb_NtkCountPoDrivers(Acb_Ntk_t *p, Vec_Int_t *vObjs)
Definition acbUtil.c:146
Acb_ObjCollectTfiVec
Vec_Int_t * Acb_ObjCollectTfiVec(Acb_Ntk_t *p, Vec_Int_t *vObjs)
Definition acbUtil.c:75
Acb_ObjCollectTfo
Vec_Int_t * Acb_ObjCollectTfo(Acb_Ntk_t *p, int iObj, int fTerm)
Definition acbUtil.c:96
Acb_ManForEachNtk
#define Acb_ManForEachNtk(p, pNtk, i)
ITERATORS ///.
Definition acb.h:328
Acb_NtkForEachObj
#define Acb_NtkForEachObj(p, i)
Definition acb.h:358
Acb_ObjForEachFanin
#define Acb_ObjForEachFanin(p, iObj, iFanin, k)
Definition acb.h:373
Acb_Aig_t
typedefABC_NAMESPACE_HEADER_START struct Acb_Aig_t_ Acb_Aig_t
INCLUDES ///.
Definition acb.h:46
Acb_NtkComputeLevelD
int Acb_NtkComputeLevelD(Acb_Ntk_t *p, Vec_Int_t *vTfo)
Definition acbUtil.c:340
Acb_NtkForEachObjType
#define Acb_NtkForEachObjType(p, Type, i)
Definition acb.h:368
Acb_ObjForEachFaninFast
#define Acb_ObjForEachFaninFast(p, iObj, pFanins, iFanin, k)
Definition acb.h:375
Acb_NtkFindMffcSize
int Acb_NtkFindMffcSize(Acb_Ntk_t *p, Vec_Int_t *vObjsRefed, Vec_Int_t *vObjsDerefed, int nGates[5])
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
Vec_Str_t
struct Vec_Str_t_ Vec_Str_t
Definition bblif.c:46
p
Cube * p
Definition exorList.c:222
Extra_FileDesignName
char * Extra_FileDesignName(char *pFileName)
Definition extraUtilFile.c:269
word
unsigned __int64 word
DECLARATIONS ///.
Definition kitPerm.c:36
Acb_Man_t_
Definition acb.h:106
Acb_Man_t_::pMods
Abc_Nam_t * pMods
Definition acb.h:111
Acb_Man_t_::nObjs
int nObjs[ABC_OPER_LAST]
Definition acb.h:118
Acb_Man_t_::iRoot
int iRoot
Definition acb.h:121
Acb_Man_t_::vNameMap2
Vec_Int_t vNameMap2
Definition acb.h:114
Acb_Man_t_::pFuns
Abc_Nam_t * pFuns
Definition acb.h:110
Acb_Man_t_::nOpens
int nOpens
Definition acb.h:124
Acb_Man_t_::pMioLib
void * pMioLib
Definition acb.h:127
Acb_Man_t_::pTypeNames
char * pTypeNames[ABC_OPER_LAST]
Definition acb.h:117
Acb_Man_t_::vUsed2
Vec_Int_t vUsed2
Definition acb.h:116
Acb_Man_t_::vNameMap
Vec_Int_t vNameMap
Definition acb.h:113
Acb_Man_t_::vNtks
Vec_Ptr_t vNtks
Definition acb.h:122
Acb_Man_t_::pSpec
char * pSpec
Definition acb.h:108
Acb_Man_t_::vOut2
Vec_Str_t vOut2
Definition acb.h:126
Acb_Man_t_::pName
char * pName
Definition acb.h:107
Acb_Man_t_::vUsed
Vec_Int_t vUsed
Definition acb.h:115
Acb_Man_t_::pStrs
Abc_Nam_t * pStrs
Definition acb.h:109
Acb_Man_t_::nAnds
int nAnds[ABC_OPER_LAST]
Definition acb.h:119
Acb_Man_t_::vOut
Vec_Str_t vOut
Definition acb.h:125
Acb_Man_t_::vHash
Hash_IntMan_t * vHash
Definition acb.h:112
Acb_Ntk_t_
Definition acb.h:52
Acb_Ntk_t_::vOrder
Vec_Int_t vOrder
Definition acb.h:63
Acb_Ntk_t_::Id
int Id
Definition acb.h:54
Acb_Ntk_t_::vCover
Vec_Int_t vCover
Definition acb.h:98
Acb_Ntk_t_::vObjFans
Vec_Int_t vObjFans
Definition acb.h:72
Acb_Ntk_t_::vObjRange
Vec_Int_t vObjRange
Definition acb.h:80
Acb_Ntk_t_::vObjType
Vec_Str_t vObjType
Definition acb.h:71
Acb_Ntk_t_::vPathD
Vec_Int_t vPathD
Definition acb.h:89
Acb_Ntk_t_::vLevelD
Vec_Int_t vLevelD
Definition acb.h:87
Acb_Ntk_t_::vObjBits
Vec_Int_t vObjBits
Definition acb.h:82
Acb_Ntk_t_::vCounts
Vec_Flt_t vCounts
Definition acb.h:91
Acb_Ntk_t_::fSeq
unsigned fSeq
Definition acb.h:59
Acb_Ntk_t_::vArray1
Vec_Int_t vArray1
Definition acb.h:100
Acb_Ntk_t_::nObjTravs
int nObjTravs
Definition acb.h:67
Acb_Ntk_t_::vCnf
Vec_Str_t vCnf
Definition acb.h:94
Acb_Ntk_t_::vAttrSto
Vec_Int_t vAttrSto
Definition acb.h:84
Acb_Ntk_t_::nRegs
int nRegs
Definition acb.h:65
Acb_Ntk_t_::fComb
unsigned fComb
Definition acb.h:58
Acb_Ntk_t_::vObjTruth
Vec_Wrd_t vObjTruth
Definition acb.h:78
Acb_Ntk_t_::vObjName
Vec_Int_t vObjName
Definition acb.h:79
Acb_Ntk_t_::vObjCopy
Vec_Int_t vObjCopy
Definition acb.h:75
Acb_Ntk_t_::vCnfs
Vec_Wec_t vCnfs
Definition acb.h:93
Acb_Ntk_t_::pDesign
Acb_Man_t * pDesign
Definition acb.h:53
Acb_Ntk_t_::vArray2
Vec_Int_t vArray2
Definition acb.h:101
Acb_Ntk_t_::Mark
unsigned Mark
Definition acb.h:57
Acb_Ntk_t_::vFanSto
Vec_Int_t vFanSto
Definition acb.h:73
Acb_Ntk_t_::vPathR
Vec_Int_t vPathR
Definition acb.h:90
Acb_Ntk_t_::vTargets
Vec_Int_t vTargets
Definition acb.h:86
Acb_Ntk_t_::vCis
Vec_Int_t vCis
Definition acb.h:61
Acb_Ntk_t_::NameId
int NameId
Definition acb.h:55
Acb_Ntk_t_::vSuppOld
Vec_Int_t vSuppOld
Definition acb.h:95
Acb_Ntk_t_::vLevelR
Vec_Int_t vLevelR
Definition acb.h:88
Acb_Ntk_t_::vObjWeight
Vec_Int_t vObjWeight
Definition acb.h:77
Acb_Ntk_t_::nPaths
int nPaths
Definition acb.h:69
Acb_Ntk_t_::vQue
Vec_Que_t * vQue
Definition acb.h:97
Acb_Ntk_t_::vNtkObjs
Vec_Int_t vNtkObjs
Definition acb.h:85
Acb_Ntk_t_::nFaninMax
int nFaninMax
Definition acb.h:66
Acb_Ntk_t_::vObjFunc
Vec_Int_t vObjFunc
Definition acb.h:76
Acb_Ntk_t_::vObjAttr
Vec_Int_t vObjAttr
Definition acb.h:83
Acb_Ntk_t_::iCopy
int iCopy
Definition acb.h:56
Acb_Ntk_t_::vCos
Vec_Int_t vCos
Definition acb.h:62
Acb_Ntk_t_::LevelMax
int LevelMax
Definition acb.h:68
Acb_Ntk_t_::vFanouts
Vec_Wec_t vFanouts
Definition acb.h:92
Acb_Ntk_t_::vArray0
Vec_Int_t vArray0
Definition acb.h:99
Acb_Ntk_t_::vObjTrav
Vec_Int_t vObjTrav
Definition acb.h:81
Acb_Ntk_t_::vSeq
Vec_Int_t vSeq
Definition acb.h:64
Abc_NamStrFind
int Abc_NamStrFind(Abc_Nam_t *p, char *pStr)
Definition utilNam.c:433
Abc_NamStrFindOrAddLim
int Abc_NamStrFindOrAddLim(Abc_Nam_t *p, char *pStr, char *pLim, int *pfFound)
Definition utilNam.c:492
Abc_NamMemUsed
int Abc_NamMemUsed(Abc_Nam_t *p)
Definition utilNam.c:247
Abc_NamStrFindOrAdd
int Abc_NamStrFindOrAdd(Abc_Nam_t *p, char *pStr, int *pfFound)
Definition utilNam.c:453
Abc_NamObjNumMax
int Abc_NamObjNumMax(Abc_Nam_t *p)
Definition utilNam.c:231
Abc_NamStart
Abc_Nam_t * Abc_NamStart(int nObjs, int nAveSize)
FUNCTION DEFINITIONS ///.
Definition utilNam.c:80
Abc_NamBuffer
Vec_Str_t * Abc_NamBuffer(Abc_Nam_t *p)
Definition utilNam.c:571
Abc_NamDeref
void Abc_NamDeref(Abc_Nam_t *p)
Definition utilNam.c:212
Abc_NamRef
Abc_Nam_t * Abc_NamRef(Abc_Nam_t *p)
Definition utilNam.c:195
Abc_NamStr
char * Abc_NamStr(Abc_Nam_t *p, int NameId)
Definition utilNam.c:555
Abc_Nam_t
typedefABC_NAMESPACE_HEADER_START struct Abc_Nam_t_ Abc_Nam_t
INCLUDES ///.
Definition utilNam.h:39
assert
#define assert(ex)
Definition util_old.h:213
memcpy
char * memcpy()
strlen
int strlen()
Vec_Flt_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Flt_t_ Vec_Flt_t
INCLUDES ///.
Definition vecFlt.h:42
Hash_IntMan_t
struct Hash_IntMan_t_ Hash_IntMan_t
Definition vecHash.h:51
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_Que_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Que_t_ Vec_Que_t
INCLUDES ///.
Definition vecQue.h:40
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition vecWec.h:42
Vec_Wrd_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wrd_t_ Vec_Wrd_t
INCLUDES ///.
Definition vecWrd.h:42