abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
nwkSpeedup.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [nwkSpeedup.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Netlist representation.]
8 
9  Synopsis [Global delay optimization using structural choices.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: nwkSpeedup.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "nwk.h"
22 
24 
25 
26 ////////////////////////////////////////////////////////////////////////
27 /// DECLARATIONS ///
28 ////////////////////////////////////////////////////////////////////////
29 
30 ////////////////////////////////////////////////////////////////////////
31 /// FUNCTION DEFINITIONS ///
32 ////////////////////////////////////////////////////////////////////////
33 
34 /**Function*************************************************************
35 
36  Synopsis [Adds strashed nodes for one node.]
37 
38  Description []
39 
40  SideEffects []
41 
42  SeeAlso []
43 
44 ***********************************************************************/
45 int Aig_ManSpeedupNode_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode, Vec_Ptr_t * vNodes )
46 {
47  if ( Aig_ObjIsTravIdCurrent(pAig, pNode) )
48  return 1;
49  if ( Aig_ObjIsCi(pNode) )
50  return 0;
51  assert( Aig_ObjIsNode(pNode) );
52  Aig_ObjSetTravIdCurrent( pAig, pNode );
53  if ( !Aig_ManSpeedupNode_rec( pAig, Aig_ObjFanin0(pNode), vNodes ) )
54  return 0;
55  if ( !Aig_ManSpeedupNode_rec( pAig, Aig_ObjFanin1(pNode), vNodes ) )
56  return 0;
57  Vec_PtrPush( vNodes, pNode );
58  return 1;
59 }
60 
61 /**Function*************************************************************
62 
63  Synopsis [Adds strashed nodes for one node.]
64 
65  Description []
66 
67  SideEffects []
68 
69  SeeAlso []
70 
71 ***********************************************************************/
72 void Aig_ManSpeedupNode( Nwk_Man_t * pNtk, Aig_Man_t * pAig, Nwk_Obj_t * pNode, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vTimes )
73 {
74  Vec_Ptr_t * vNodes;
75  Nwk_Obj_t * pObj, * pObj2;
76  Aig_Obj_t * ppCofs[32], * pAnd, * pTemp;
77  int nCofs, i, k, nSkip;
78 
79  // quit of regulars are the same
80  Vec_PtrForEachEntry( Nwk_Obj_t *, vLeaves, pObj, i )
81  Vec_PtrForEachEntry( Nwk_Obj_t *, vLeaves, pObj2, k )
82  if ( i != k && Aig_Regular((Aig_Obj_t *)pObj->pCopy) == Aig_Regular((Aig_Obj_t *)pObj2->pCopy) )
83  {
84 // printf( "Identical after structural hashing!!!\n" );
85  return;
86  }
87 
88  // collect the AIG nodes
89  vNodes = Vec_PtrAlloc( 100 );
90  Aig_ManIncrementTravId( pAig );
92  Vec_PtrForEachEntry( Nwk_Obj_t *, vLeaves, pObj, i )
93  {
94  pAnd = (Aig_Obj_t *)pObj->pCopy;
95  Aig_ObjSetTravIdCurrent( pAig, Aig_Regular(pAnd) );
96  }
97  // traverse from the root node
98  pAnd = (Aig_Obj_t *)pNode->pCopy;
99  if ( !Aig_ManSpeedupNode_rec( pAig, Aig_Regular(pAnd), vNodes ) )
100  {
101 // printf( "Bad node!!!\n" );
102  Vec_PtrFree( vNodes );
103  return;
104  }
105 
106  // derive cofactors
107  nCofs = (1 << Vec_PtrSize(vTimes));
108  for ( i = 0; i < nCofs; i++ )
109  {
110  Vec_PtrForEachEntry( Nwk_Obj_t *, vLeaves, pObj, k )
111  {
112  pAnd = (Aig_Obj_t *)pObj->pCopy;
113  Aig_Regular(pAnd)->pData = Aig_Regular(pAnd);
114  }
115  Vec_PtrForEachEntry( Nwk_Obj_t *, vTimes, pObj, k )
116  {
117  pAnd = (Aig_Obj_t *)pObj->pCopy;
118  Aig_Regular(pAnd)->pData = Aig_NotCond( Aig_ManConst1(pAig), ((i & (1<<k)) == 0) );
119  }
120  Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pTemp, k )
121  pTemp->pData = Aig_And( pAig, Aig_ObjChild0Copy(pTemp), Aig_ObjChild1Copy(pTemp) );
122  // save the result
123  pAnd = (Aig_Obj_t *)pNode->pCopy;
124  ppCofs[i] = Aig_NotCond( (Aig_Obj_t *)Aig_Regular(pAnd)->pData, Aig_IsComplement(pAnd) );
125  }
126  Vec_PtrFree( vNodes );
127 
128 //Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[0] );
129 //Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[1] );
130 
131  // collect the resulting tree
132  Vec_PtrForEachEntry( Nwk_Obj_t *, vTimes, pObj, k )
133  for ( nSkip = (1<<k), i = 0; i < nCofs; i += 2*nSkip )
134  {
135  pAnd = (Aig_Obj_t *)pObj->pCopy;
136  ppCofs[i] = Aig_Mux( pAig, Aig_Regular(pAnd), ppCofs[i+nSkip], ppCofs[i] );
137  }
138 //Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[0] );
139 
140  // create choice node
141  pAnd = Aig_Regular((Aig_Obj_t *)pNode->pCopy); // repr
142  pTemp = Aig_Regular(ppCofs[0]); // new
143  if ( Aig_ObjEquiv(pAig, pAnd) == NULL && Aig_ObjEquiv(pAig, pTemp) == NULL && !Aig_ObjCheckTfi(pAig, pTemp, pAnd) )
144  pAig->pEquivs[pAnd->Id] = pTemp;
145 }
146 
147 /**Function*************************************************************
148 
149  Synopsis [Determines timing-critical edges of the node.]
150 
151  Description []
152 
153  SideEffects []
154 
155  SeeAlso []
156 
157 ***********************************************************************/
158 unsigned Nwk_ManDelayTraceTCEdges( Nwk_Man_t * pNtk, Nwk_Obj_t * pNode, float tDelta, int fUseLutLib )
159 {
160  int pPinPerm[32];
161  float pPinDelays[32];
162  If_LibLut_t * pLutLib = fUseLutLib? pNtk->pLutLib : NULL;
163  Nwk_Obj_t * pFanin;
164  unsigned uResult = 0;
165  float tRequired, * pDelays;
166  int k;
167  tRequired = Nwk_ObjRequired(pNode);
168  if ( pLutLib == NULL )
169  {
170  Nwk_ObjForEachFanin( pNode, pFanin, k )
171  if ( tRequired < Nwk_ObjArrival(pFanin) + 1.0 + tDelta )
172  uResult |= (1 << k);
173  }
174  else if ( !pLutLib->fVarPinDelays )
175  {
176  pDelays = pLutLib->pLutDelays[Nwk_ObjFaninNum(pNode)];
177  Nwk_ObjForEachFanin( pNode, pFanin, k )
178  if ( tRequired < Nwk_ObjArrival(pFanin) + pDelays[0] + tDelta )
179  uResult |= (1 << k);
180  }
181  else
182  {
183  pDelays = pLutLib->pLutDelays[Nwk_ObjFaninNum(pNode)];
184  Nwk_ManDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
185  Nwk_ObjForEachFanin( pNode, pFanin, k )
186  if ( tRequired < Nwk_ObjArrival(Nwk_ObjFanin(pNode,pPinPerm[k])) + pDelays[k] + tDelta )
187  uResult |= (1 << pPinPerm[k]);
188  }
189  return uResult;
190 }
191 
192 /**Function*************************************************************
193 
194  Synopsis [Adds choices to speed up the network by the given percentage.]
195 
196  Description []
197 
198  SideEffects []
199 
200  SeeAlso []
201 
202 ***********************************************************************/
203 Aig_Man_t * Nwk_ManSpeedup( Nwk_Man_t * pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose )
204 {
205  Aig_Man_t * pAig, * pTemp;
206  Vec_Ptr_t * vTimeCries, * vTimeFanins;
207  Nwk_Obj_t * pNode, * pFanin, * pFanin2;
208  Aig_Obj_t * pAnd;
209  If_LibLut_t * pTempLib = pNtk->pLutLib;
210  Tim_Man_t * pTempTim = NULL;
211  float tDelta, tArrival;
212  int i, k, k2, Counter, CounterRes, nTimeCris;
213  unsigned * puTCEdges;
214  // perform delay trace
215  if ( !fUseLutLib )
216  {
217  pNtk->pLutLib = NULL;
218  if ( pNtk->pManTime )
219  {
220  pTempTim = pNtk->pManTime;
221  pNtk->pManTime = Tim_ManDup( pTempTim, 1 );
222  }
223  }
224  tArrival = Nwk_ManDelayTraceLut( pNtk );
225  tDelta = fUseLutLib ? tArrival*Percentage/100.0 : 1.0;
226  if ( fVerbose )
227  {
228  printf( "Max delay = %.2f. Delta = %.2f. ", tArrival, tDelta );
229  printf( "Using %s model. ", fUseLutLib? "LUT library" : "unit-delay" );
230  if ( fUseLutLib )
231  printf( "Percentage = %d. ", Percentage );
232  printf( "\n" );
233  }
234  // mark the timing critical nodes and edges
235  puTCEdges = ABC_ALLOC( unsigned, Nwk_ManObjNumMax(pNtk) );
236  memset( puTCEdges, 0, sizeof(unsigned) * Nwk_ManObjNumMax(pNtk) );
237  Nwk_ManForEachNode( pNtk, pNode, i )
238  {
239  if ( Nwk_ObjSlack(pNode) >= tDelta )
240  continue;
241  puTCEdges[pNode->Id] = Nwk_ManDelayTraceTCEdges( pNtk, pNode, tDelta, fUseLutLib );
242  }
243  if ( fVerbose )
244  {
245  Counter = CounterRes = 0;
246  Nwk_ManForEachNode( pNtk, pNode, i )
247  {
248  Nwk_ObjForEachFanin( pNode, pFanin, k )
249  if ( !Nwk_ObjIsCi(pFanin) && Nwk_ObjSlack(pFanin) < tDelta )
250  Counter++;
251  CounterRes += Aig_WordCountOnes( puTCEdges[pNode->Id] );
252  }
253  printf( "Edges: Total = %7d. 0-slack = %7d. Critical = %7d. Ratio = %4.2f\n",
254  Nwk_ManGetTotalFanins(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
255  }
256  // start the resulting network
257  pAig = Nwk_ManStrash( pNtk );
258  pAig->pEquivs = ABC_ALLOC( Aig_Obj_t *, 3 * Aig_ManObjNumMax(pAig) );
259  memset( pAig->pEquivs, 0, sizeof(Aig_Obj_t *) * 3 * Aig_ManObjNumMax(pAig) );
260 
261  // collect nodes to be used for resynthesis
262  Counter = CounterRes = 0;
263  vTimeCries = Vec_PtrAlloc( 16 );
264  vTimeFanins = Vec_PtrAlloc( 16 );
265  Nwk_ManForEachNode( pNtk, pNode, i )
266  {
267  if ( Nwk_ObjSlack(pNode) >= tDelta )
268  continue;
269  // count the number of non-PI timing-critical nodes
270  nTimeCris = 0;
271  Nwk_ObjForEachFanin( pNode, pFanin, k )
272  if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
273  nTimeCris++;
274  if ( !fVeryVerbose && nTimeCris == 0 )
275  continue;
276  Counter++;
277  // count the total number of timing critical second-generation nodes
278  Vec_PtrClear( vTimeCries );
279  if ( nTimeCris )
280  {
281  Nwk_ObjForEachFanin( pNode, pFanin, k )
282  if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
283  Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
284  if ( puTCEdges[pFanin->Id] & (1<<k2) )
285  Vec_PtrPushUnique( vTimeCries, pFanin2 );
286  }
287 // if ( !fVeryVerbose && (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
288  if ( (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
289  continue;
290  CounterRes++;
291  // collect second generation nodes
292  Vec_PtrClear( vTimeFanins );
293  Nwk_ObjForEachFanin( pNode, pFanin, k )
294  {
295  if ( Nwk_ObjIsCi(pFanin) )
296  Vec_PtrPushUnique( vTimeFanins, pFanin );
297  else
298  Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
299  Vec_PtrPushUnique( vTimeFanins, pFanin2 );
300  }
301  // print the results
302  if ( fVeryVerbose )
303  {
304  printf( "%5d Node %5d : %d %2d %2d ", Counter, pNode->Id,
305  nTimeCris, Vec_PtrSize(vTimeCries), Vec_PtrSize(vTimeFanins) );
306  Nwk_ObjForEachFanin( pNode, pFanin, k )
307  printf( "%d(%.2f)%s ", pFanin->Id, Nwk_ObjSlack(pFanin), (puTCEdges[pNode->Id] & (1<<k))? "*":"" );
308  printf( "\n" );
309  }
310  // add the node to choices
311  if ( Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree )
312  continue;
313  // order the fanins in the increasing order of criticalily
314  if ( Vec_PtrSize(vTimeCries) > 1 )
315  {
316  pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
317  pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
318  if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
319  {
320  Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
321  Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
322  }
323  }
324  if ( Vec_PtrSize(vTimeCries) > 2 )
325  {
326  pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
327  pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 2 );
328  if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
329  {
330  Vec_PtrWriteEntry( vTimeCries, 1, pFanin2 );
331  Vec_PtrWriteEntry( vTimeCries, 2, pFanin );
332  }
333  pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
334  pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
335  if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
336  {
337  Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
338  Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
339  }
340  }
341  // add choice
342  Aig_ManSpeedupNode( pNtk, pAig, pNode, vTimeFanins, vTimeCries );
343  }
344  Vec_PtrFree( vTimeCries );
345  Vec_PtrFree( vTimeFanins );
346  ABC_FREE( puTCEdges );
347  if ( fVerbose )
348  printf( "Nodes: Total = %7d. 0-slack = %7d. Workable = %7d. Ratio = %4.2f\n",
349  Nwk_ManNodeNum(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
350 
351  // remove invalid choice nodes
352  Aig_ManForEachNode( pAig, pAnd, i )
353  if ( Aig_ObjEquiv(pAig, pAnd) )
354  {
355  if ( Aig_ObjRefs(Aig_ObjEquiv(pAig, pAnd)) > 0 )
356  pAig->pEquivs[pAnd->Id] = NULL;
357  }
358 
359  // put back the library
360  if ( !fUseLutLib )
361  pNtk->pLutLib = pTempLib;
362  if ( pTempTim )
363  {
364  Tim_ManStop( pNtk->pManTime );
365  pNtk->pManTime = pTempTim;
366  }
367 
368  // reconstruct the network
369  pAig = Aig_ManDupDfs( pTemp = pAig );
370  Aig_ManStop( pTemp );
371  // reset levels
372  Aig_ManChoiceLevel( pAig );
373  return pAig;
374 }
375 
376 ////////////////////////////////////////////////////////////////////////
377 /// END OF FILE ///
378 ////////////////////////////////////////////////////////////////////////
379 
380 
382 
char * memset()
static int Nwk_ObjIsCi(Nwk_Obj_t *p)
Definition: nwk.h:146
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition: vecPtr.h:42
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
typedefABC_NAMESPACE_HEADER_START struct Nwk_Obj_t_ Nwk_Obj_t
INCLUDES ///.
Definition: nwk.h:49
Aig_Man_t * Nwk_ManSpeedup(Nwk_Man_t *pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose)
Definition: nwkSpeedup.c:203
static float Nwk_ObjSlack(Nwk_Obj_t *pObj)
Definition: nwk.h:157
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
static int Vec_PtrPushUnique(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:656
static int Aig_ObjIsTravIdCurrent(Aig_Man_t *p, Aig_Obj_t *pObj)
Definition: aig.h:295
void * pData
Definition: aig.h:87
static Aig_Obj_t * Aig_ObjFanin0(Aig_Obj_t *pObj)
Definition: aig.h:308
Aig_Man_t * Aig_ManDupDfs(Aig_Man_t *p)
Definition: aigDup.c:563
static int Aig_IsComplement(Aig_Obj_t *p)
Definition: aig.h:249
static Aig_Obj_t * Aig_Regular(Aig_Obj_t *p)
Definition: aig.h:246
ABC_DLL Aig_Man_t * Nwk_ManStrash(Nwk_Man_t *p)
Definition: nwkStrash.c:99
float pLutDelays[IF_MAX_LUTSIZE+1][IF_MAX_LUTSIZE+1]
Definition: if.h:176
static void Vec_PtrPush(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:606
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
static Aig_Obj_t * Aig_ObjFanin1(Aig_Obj_t *pObj)
Definition: aig.h:309
static int Vec_PtrSize(Vec_Ptr_t *p)
Definition: vecPtr.h:295
static void Aig_ObjSetTravIdCurrent(Aig_Man_t *p, Aig_Obj_t *pObj)
Definition: aig.h:293
static int Nwk_ObjFaninNum(Nwk_Obj_t *p)
Definition: nwk.h:137
Aig_Obj_t * Aig_And(Aig_Man_t *p, Aig_Obj_t *p0, Aig_Obj_t *p1)
Definition: aigOper.c:104
int Aig_ManChoiceLevel(Aig_Man_t *p)
Definition: aigDfs.c:581
void Aig_ManIncrementTravId(Aig_Man_t *p)
DECLARATIONS ///.
Definition: aigUtil.c:44
static int Aig_ObjIsNode(Aig_Obj_t *pObj)
Definition: aig.h:280
static float Nwk_ObjArrival(Nwk_Obj_t *pObj)
Definition: nwk.h:155
static int Aig_WordCountOnes(unsigned uWord)
Definition: aig.h:229
#define Aig_ManForEachNode(p, pObj, i)
Definition: aig.h:413
int fVarPinDelays
Definition: if.h:174
Definition: nwk.h:61
If_LibLut_t * pLutLib
Definition: nwk.h:75
void Aig_ManSpeedupNode(Nwk_Man_t *pNtk, Aig_Man_t *pAig, Nwk_Obj_t *pNode, Vec_Ptr_t *vLeaves, Vec_Ptr_t *vTimes)
Definition: nwkSpeedup.c:72
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
ABC_DLL void Nwk_ManDelayTraceSortPins(Nwk_Obj_t *pNode, int *pPinPerm, float *pPinDelays)
Definition: nwkTiming.c:67
if(last==0)
Definition: sparse_int.h:34
static Aig_Obj_t * Aig_ObjEquiv(Aig_Man_t *p, Aig_Obj_t *pObj)
Definition: aig.h:328
static Aig_Obj_t * Aig_ObjChild1Copy(Aig_Obj_t *pObj)
Definition: aig.h:313
Tim_Man_t * Tim_ManDup(Tim_Man_t *p, int fUnitDelay)
Definition: timMan.c:86
Definition: aig.h:69
static int Counter
void Tim_ManStop(Tim_Man_t *p)
Definition: timMan.c:375
static Aig_Obj_t * Aig_ObjChild0Copy(Aig_Obj_t *pObj)
Definition: aig.h:312
Tim_Man_t * pManTime
Definition: nwk.h:74
static void Vec_PtrWriteEntry(Vec_Ptr_t *p, int i, void *Entry)
Definition: vecPtr.h:396
static int Aig_ManObjNumMax(Aig_Man_t *p)
Definition: aig.h:259
static Aig_Obj_t * Aig_ManConst1(Aig_Man_t *p)
Definition: aig.h:264
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)
Definition: vecPtr.h:362
Aig_Obj_t * Aig_Mux(Aig_Man_t *p, Aig_Obj_t *pC, Aig_Obj_t *p1, Aig_Obj_t *p0)
Definition: aigOper.c:317
static Vec_Ptr_t * Vec_PtrAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecPtr.h:83
unsigned Nwk_ManDelayTraceTCEdges(Nwk_Man_t *pNtk, Nwk_Obj_t *pNode, float tDelta, int fUseLutLib)
Definition: nwkSpeedup.c:158
static Nwk_Obj_t * Nwk_ObjFanin(Nwk_Obj_t *p, int i)
Definition: nwk.h:142
#define Nwk_ObjForEachFanin(pObj, pFanin, i)
Definition: nwk.h:199
static int Nwk_ManObjNumMax(Nwk_Man_t *p)
Definition: nwk.h:129
#define ABC_FREE(obj)
Definition: abc_global.h:232
int Aig_ObjCheckTfi(Aig_Man_t *p, Aig_Obj_t *pNew, Aig_Obj_t *pOld)
Definition: aigRepr.c:435
ABC_DLL float Nwk_ManDelayTraceLut(Nwk_Man_t *pNtk)
Definition: nwkTiming.c:326
ABC_DLL int Nwk_ManGetTotalFanins(Nwk_Man_t *pNtk)
Definition: nwkUtil.c:94
static int Nwk_ManNodeNum(Nwk_Man_t *p)
Definition: nwk.h:127
#define assert(ex)
Definition: util_old.h:213
static void Vec_PtrClear(Vec_Ptr_t *p)
Definition: vecPtr.h:545
typedefABC_NAMESPACE_HEADER_START struct Tim_Man_t_ Tim_Man_t
INCLUDES ///.
Definition: tim.h:92
static float Nwk_ObjRequired(Nwk_Obj_t *pObj)
Definition: nwk.h:156
static int Aig_ObjRefs(Aig_Obj_t *pObj)
Definition: aig.h:300
ABC_NAMESPACE_IMPL_START int Aig_ManSpeedupNode_rec(Aig_Man_t *pAig, Aig_Obj_t *pNode, Vec_Ptr_t *vNodes)
DECLARATIONS ///.
Definition: nwkSpeedup.c:45
static Aig_Obj_t * Aig_NotCond(Aig_Obj_t *p, int c)
Definition: aig.h:248
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition: vecPtr.h:55
static int Aig_ObjIsCi(Aig_Obj_t *pObj)
Definition: aig.h:275
int Id
Definition: aig.h:85
static void Vec_PtrFree(Vec_Ptr_t *p)
Definition: vecPtr.h:223
#define Nwk_ManForEachNode(p, pObj, i)
Definition: nwk.h:192