abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
sclBufSize.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [sclBufSize.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Standard-cell library representation.]
8 
9  Synopsis [Buffering and sizing combined.]
10 
11  Author [Alan Mishchenko, Niklas Een]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - August 24, 2012.]
16 
17  Revision [$Id: sclBufSize.c,v 1.0 2012/08/24 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "sclSize.h"
22 #include "map/mio/mio.h"
23 #include "base/main/main.h"
24 
25 ABC_NAMESPACE_IMPL_START
26 
27 
28 ////////////////////////////////////////////////////////////////////////
29 /// DECLARATIONS ///
30 ////////////////////////////////////////////////////////////////////////
31 
32 typedef struct Bus_Man_t_ Bus_Man_t;
33 struct Bus_Man_t_
34 {
35  // user data
36  SC_BusPars * pPars; // parameters
37  Abc_Ntk_t * pNtk; // user's network
38  SC_Cell * pPiDrive; // PI driver
39  // library
40  SC_Lib * pLib; // cell library
41  SC_Cell * pInv; // base interter (largest/average/???)
42  SC_WireLoad * pWLoadUsed; // name of the used WireLoad model
43  Vec_Flt_t * vWireCaps; // estimated wire loads
44  // internal
45  Vec_Flt_t * vCins; // input cap for fanouts
46  Vec_Flt_t * vETimes; // fanout edge departures
47  Vec_Flt_t * vLoads; // loads for all nodes
48  Vec_Flt_t * vDepts; // departure times
49  Vec_Ptr_t * vFanouts; // fanout array
50 };
51 
52 
53 static inline Bus_Man_t * Bus_SclObjMan( Abc_Obj_t * p ) { return (Bus_Man_t *)p->pNtk->pBSMan; }
54 static inline float Bus_SclObjCin( Abc_Obj_t * p ) { return Vec_FltEntry( Bus_SclObjMan(p)->vCins, Abc_ObjId(p) ); }
55 static inline void Bus_SclObjSetCin( Abc_Obj_t * p, float cap ) { Vec_FltWriteEntry( Bus_SclObjMan(p)->vCins, Abc_ObjId(p), cap ); }
56 static inline float Bus_SclObjETime( Abc_Obj_t * p ) { return Vec_FltEntry( Bus_SclObjMan(p)->vETimes, Abc_ObjId(p) ); }
57 static inline void Bus_SclObjSetETime( Abc_Obj_t * p, float time ) { Vec_FltWriteEntry( Bus_SclObjMan(p)->vETimes, Abc_ObjId(p), time ); }
58 static inline float Bus_SclObjLoad( Abc_Obj_t * p ) { return Vec_FltEntry( Bus_SclObjMan(p)->vLoads, Abc_ObjId(p) ); }
59 static inline void Bus_SclObjSetLoad( Abc_Obj_t * p, float cap ) { Vec_FltWriteEntry( Bus_SclObjMan(p)->vLoads, Abc_ObjId(p), cap ); }
60 static inline float Bus_SclObjDept( Abc_Obj_t * p ) { return Vec_FltEntry( Bus_SclObjMan(p)->vDepts, Abc_ObjId(p) ); }
61 static inline void Bus_SclObjUpdateDept( Abc_Obj_t * p, float time ) { float *q = Vec_FltEntryP( Bus_SclObjMan(p)->vDepts, Abc_ObjId(p) ); if (*q < time) *q = time; }
62 
63 ////////////////////////////////////////////////////////////////////////
64 /// FUNCTION DEFINITIONS ///
65 ////////////////////////////////////////////////////////////////////////
66 
67 /**Function*************************************************************
68 
69  Synopsis []
70 
71  Description []
72 
73  SideEffects []
74 
75  SeeAlso []
76 
77 ***********************************************************************/
78 Bus_Man_t * Bus_ManStart( Abc_Ntk_t * pNtk, SC_Lib * pLib, SC_BusPars * pPars )
79 {
80  Bus_Man_t * p;
81  p = ABC_CALLOC( Bus_Man_t, 1 );
82  p->pPars = pPars;
83  p->pNtk = pNtk;
84  p->pLib = pLib;
85  p->pInv = Abc_SclFindInvertor(pLib, pPars->fAddBufs)->pRepr->pPrev;//->pAve;
86  if ( pPars->fUseWireLoads )
87  {
88  if ( pNtk->pWLoadUsed == NULL )
89  {
90  p->pWLoadUsed = Abc_SclFindWireLoadModel( pLib, Abc_SclGetTotalArea(pNtk) );
91  if ( p->pWLoadUsed )
92  pNtk->pWLoadUsed = Abc_UtilStrsav( p->pWLoadUsed->pName );
93  }
94  else
95  p->pWLoadUsed = Abc_SclFetchWireLoadModel( pLib, pNtk->pWLoadUsed );
96  }
97  if ( p->pWLoadUsed )
98  p->vWireCaps = Abc_SclFindWireCaps( p->pWLoadUsed, Abc_NtkGetFanoutMax(pNtk) );
99  p->vFanouts = Vec_PtrAlloc( 100 );
100  p->vCins = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 );
101  p->vETimes = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 );
102  p->vLoads = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 );
103  p->vDepts = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 );
104  Vec_FltFill( p->vCins, Abc_NtkObjNumMax(pNtk), 0 );
105  Vec_FltFill( p->vETimes, Abc_NtkObjNumMax(pNtk), 0 );
106  Vec_FltFill( p->vLoads, Abc_NtkObjNumMax(pNtk), 0 );
107  Vec_FltFill( p->vDepts, Abc_NtkObjNumMax(pNtk), 0 );
108  pNtk->pBSMan = p;
109  return p;
110 }
111 void Bus_ManStop( Bus_Man_t * p )
112 {
113  Vec_PtrFreeP( &p->vFanouts );
114  Vec_FltFreeP( &p->vWireCaps );
115  Vec_FltFreeP( &p->vCins );
116  Vec_FltFreeP( &p->vETimes );
117  Vec_FltFreeP( &p->vLoads );
118  Vec_FltFreeP( &p->vDepts );
119  ABC_FREE( p );
120 }
121 
122 /**Function*************************************************************
123 
124  Synopsis []
125 
126  Description []
127 
128  SideEffects []
129 
130  SeeAlso []
131 
132 ***********************************************************************/
133 void Bus_ManReadInOutLoads( Bus_Man_t * p )
134 {
135  if ( Abc_FrameReadMaxLoad() )
136  {
137  Abc_Obj_t * pObj; int i;
138  float MaxLoad = Abc_FrameReadMaxLoad();
139  Abc_NtkForEachCo( p->pNtk, pObj, i )
140  Bus_SclObjSetCin( pObj, MaxLoad );
141 // printf( "Default output load is specified (%f ff).\n", MaxLoad );
142  }
143  if ( Abc_FrameReadDrivingCell() )
144  {
145  int iCell = Abc_SclCellFind( p->pLib, Abc_FrameReadDrivingCell() );
146  if ( iCell == -1 )
147  printf( "Cannot find the default PI driving cell (%s) in the library.\n", Abc_FrameReadDrivingCell() );
148  else
149  {
150 // printf( "Default PI driving cell is specified (%s).\n", Abc_FrameReadDrivingCell() );
151  p->pPiDrive = SC_LibCell( p->pLib, iCell );
152  assert( p->pPiDrive != NULL );
153  assert( p->pPiDrive->n_inputs == 1 );
154 // printf( "Default input driving cell is specified (%s).\n", p->pPiDrive->pName );
155  }
156  }
157 }
158 
159 /**Function*************************************************************
160 
161  Synopsis [Compute load and departure times of the node.]
162 
163  Description []
164 
165  SideEffects []
166 
167  SeeAlso []
168 
169 ***********************************************************************/
170 static inline float Abc_NtkComputeEdgeDept( Abc_Obj_t * pFanout, int iFanin, float Slew )
171 {
172  float Load = Bus_SclObjLoad( pFanout );
173  float Dept = Bus_SclObjDept( pFanout );
174  float Edge = Scl_LibPinArrivalEstimate( Abc_SclObjCell(pFanout), iFanin, Slew, Load );
175 //if ( Abc_ObjFaninNum(pFanout) == 0 )
176 //printf( "Edge = %.2f\n", Edge );
177  assert( Edge > 0 );
178  return Dept + Edge;
179 }
180 float Abc_NtkComputeNodeDeparture( Abc_Obj_t * pObj, float Slew )
181 {
182  Abc_Obj_t * pFanout;
183  int i;
184  assert( Bus_SclObjDept(pObj) == 0 );
185  Abc_ObjForEachFanout( pObj, pFanout, i )
186  if ( !Abc_ObjIsCo(pFanout) ) // add required times here
187  Bus_SclObjUpdateDept( pObj, Abc_NtkComputeEdgeDept(pFanout, Abc_NodeFindFanin(pFanout, pObj), Slew) );
188  return Bus_SclObjDept( pObj );
189 }
190 void Abc_NtkComputeFanoutInfo( Abc_Obj_t * pObj, float Slew )
191 {
192  Abc_Obj_t * pFanout;
193  int i;
194  Abc_ObjForEachFanout( pObj, pFanout, i )
195  if ( !Abc_ObjIsCo(pFanout) )
196  {
197  int iFanin = Abc_NodeFindFanin(pFanout, pObj);
198  Bus_SclObjSetETime( pFanout, Abc_NtkComputeEdgeDept(pFanout, iFanin, Slew) );
199  Bus_SclObjSetCin( pFanout, SC_CellPinCap( Abc_SclObjCell(pFanout), iFanin ) );
200  }
201 }
202 float Abc_NtkComputeNodeLoad( Bus_Man_t * p, Abc_Obj_t * pObj )
203 {
204  Abc_Obj_t * pFanout;
205  float Load;
206  int i;
207  assert( Bus_SclObjLoad(pObj) == 0 );
208  Load = Abc_SclFindWireLoad( p->vWireCaps, Abc_ObjFanoutNum(pObj) );
209  Abc_ObjForEachFanout( pObj, pFanout, i )
210  Load += Bus_SclObjCin( pFanout );
211  Bus_SclObjSetLoad( pObj, Load );
212  return Load;
213 }
214 float Abc_NtkComputeFanoutLoad( Bus_Man_t * p, Vec_Ptr_t * vFanouts )
215 {
216  Abc_Obj_t * pFanout;
217  float Load;
218  int i;
219  Load = Abc_SclFindWireLoad( p->vWireCaps, Vec_PtrSize(vFanouts) );
220  Vec_PtrForEachEntry( Abc_Obj_t *, vFanouts, pFanout, i )
221  Load += Bus_SclObjCin( pFanout );
222  return Load;
223 }
224 void Abc_NtkPrintFanoutProfile( Abc_Obj_t * pObj )
225 {
226  Abc_Obj_t * pFanout;
227  int i;
228  printf( "Obj %6d fanouts (%d):\n", Abc_ObjId(pObj), Abc_ObjFanoutNum(pObj) );
229  Abc_ObjForEachFanout( pObj, pFanout, i )
230  {
231  printf( "%3d : time = %7.2f ps load = %7.2f ff ", i, Bus_SclObjETime(pFanout), Bus_SclObjCin(pFanout) );
232  printf( "%s\n", Abc_ObjFaninPhase( pFanout, Abc_NodeFindFanin(pFanout, pObj) ) ? "*" : " " );
233  }
234  printf( "\n" );
235 }
236 void Abc_NtkPrintFanoutProfileVec( Abc_Obj_t * pObj, Vec_Ptr_t * vFanouts )
237 {
238  Abc_Obj_t * pFanout;
239  int i;
240  printf( "Fanout profile (%d):\n", Vec_PtrSize(vFanouts) );
241  Vec_PtrForEachEntry( Abc_Obj_t *, vFanouts, pFanout, i )
242  {
243  printf( "%3d : time = %7.2f ps load = %7.2f ff ", i, Bus_SclObjETime(pFanout), Bus_SclObjCin(pFanout) );
244  if ( pObj->pNtk->vPhases )
245  printf( "%s", (pObj && Abc_ObjFanoutNum(pObj) == Vec_PtrSize(vFanouts) && Abc_ObjFaninPhase( pFanout, Abc_NodeFindFanin(pFanout, pObj) )) ? "*" : " " );
246  printf( "\n" );
247  }
248  printf( "\n" );
249 }
250 
251 /**Function*************************************************************
252 
253  Synopsis [Compare two fanouts by their departure times.]
254 
255  Description []
256 
257  SideEffects []
258 
259  SeeAlso []
260 
261 ***********************************************************************/
262 int Bus_SclCompareFanouts( Abc_Obj_t ** pp1, Abc_Obj_t ** pp2 )
263 {
264  float Espilon = 0;//10; // 10 ps
265  if ( Bus_SclObjETime(*pp1) < Bus_SclObjETime(*pp2) - Espilon )
266  return -1;
267  if ( Bus_SclObjETime(*pp1) > Bus_SclObjETime(*pp2) + Espilon )
268  return 1;
269  if ( Bus_SclObjCin(*pp1) > Bus_SclObjCin(*pp2) )
270  return -1;
271  if ( Bus_SclObjCin(*pp1) < Bus_SclObjCin(*pp2) )
272  return 1;
273  return -1;
274 }
275 void Bus_SclInsertFanout( Vec_Ptr_t * vFanouts, Abc_Obj_t * pObj )
276 {
277  Abc_Obj_t * pCur;
278  int i, k;
279  // compact array
280  for ( i = k = 0; i < Vec_PtrSize(vFanouts); i++ )
281  if ( Vec_PtrEntry(vFanouts, i) != NULL )
282  Vec_PtrWriteEntry( vFanouts, k++, Vec_PtrEntry(vFanouts, i) );
283  Vec_PtrShrink( vFanouts, k );
284  // insert new entry
285  Vec_PtrPush( vFanouts, pObj );
286  for ( i = Vec_PtrSize(vFanouts) - 1; i > 0; i-- )
287  {
288  pCur = (Abc_Obj_t *)Vec_PtrEntry(vFanouts, i-1);
289  pObj = (Abc_Obj_t *)Vec_PtrEntry(vFanouts, i);
290  if ( Bus_SclCompareFanouts( &pCur, &pObj ) == -1 )
291  break;
292  ABC_SWAP( void *, Vec_PtrArray(vFanouts)[i-1], Vec_PtrArray(vFanouts)[i] );
293  }
294 }
295 void Bus_SclCheckSortedFanout( Vec_Ptr_t * vFanouts )
296 {
297  Abc_Obj_t * pObj, * pNext;
298  int i;
299  for ( i = 0; i < Vec_PtrSize(vFanouts) - 1; i++ )
300  {
301  pObj = (Abc_Obj_t *)Vec_PtrEntry(vFanouts, i);
302  pNext = (Abc_Obj_t *)Vec_PtrEntry(vFanouts, i+1);
303  if ( Bus_SclCompareFanouts( &pObj, &pNext ) != -1 )
304  {
305  printf( "Fanouts %d and %d are out of order.\n", i, i+1 );
306  Abc_NtkPrintFanoutProfileVec( NULL, vFanouts );
307  return;
308  }
309  }
310 }
311 
312 /**Function*************************************************************
313 
314  Synopsis []
315 
316  Description []
317 
318  SideEffects []
319 
320  SeeAlso []
321 
322 ***********************************************************************/
323 void Abc_SclOneNodePrint( Bus_Man_t * p, Abc_Obj_t * pObj )
324 {
325  SC_Cell * pCell = Abc_SclObjCell(pObj);
326  printf( "%s%7d : ", (Abc_ObjFaninNum(pObj) == 0) ? " Inv" : "Node", Abc_ObjId(pObj) );
327  printf( "%d/%2d ", Abc_ObjFaninNum(pObj) ? Abc_ObjFaninNum(pObj) : 1, Abc_ObjFanoutNum(pObj) );
328  printf( "%12s ", pCell->pName );
329  printf( "(%2d/%2d) ", pCell->Order, pCell->nGates );
330  printf( "gain =%5d ", (int)(100.0 * Bus_SclObjLoad(pObj) / SC_CellPinCapAve(pCell)) );
331  printf( "dept =%7.0f ps ", Bus_SclObjDept(pObj) );
332  printf( "\n" );
333 }
334 Abc_Obj_t * Abc_SclAddOneInv( Bus_Man_t * p, Abc_Obj_t * pObj, Vec_Ptr_t * vFanouts, float Gain )
335 {
336  SC_Cell * pCellNew;
337  Abc_Obj_t * pFanout, * pInv;
338  float Target = SC_CellPinCap(p->pInv, 0) * Gain;
339  float LoadWirePrev, LoadWireThis, LoadNew, Load = 0;
340  int Limit = Abc_MinInt( p->pPars->nDegree, Vec_PtrSize(vFanouts) );
341  int i, iStop;
342  Bus_SclCheckSortedFanout( vFanouts );
343  Vec_PtrForEachEntryStop( Abc_Obj_t *, vFanouts, pFanout, iStop, Limit )
344  {
345  LoadWirePrev = Abc_SclFindWireLoad( p->vWireCaps, iStop );
346  LoadWireThis = Abc_SclFindWireLoad( p->vWireCaps, iStop+1 );
347  Load += Bus_SclObjCin( pFanout ) - LoadWirePrev + LoadWireThis;
348  if ( Load > Target )
349  {
350  iStop++;
351  break;
352  }
353  }
354  // create inverter
355  if ( p->pPars->fAddBufs )
356  pInv = Abc_NtkCreateNodeBuf( p->pNtk, NULL );
357  else
358  pInv = Abc_NtkCreateNodeInv( p->pNtk, NULL );
359  assert( (int)Abc_ObjId(pInv) == Vec_FltSize(p->vCins) );
360  Vec_FltPush( p->vCins, 0 );
361  Vec_FltPush( p->vETimes, 0 );
362  Vec_FltPush( p->vLoads, 0 );
363  Vec_FltPush( p->vDepts, 0 );
364  Limit = Abc_MinInt( Abc_MaxInt(iStop, 2), Vec_PtrSize(vFanouts) );
365  Vec_PtrForEachEntryStop( Abc_Obj_t *, vFanouts, pFanout, i, Limit )
366  {
367  Vec_PtrWriteEntry( vFanouts, i, NULL );
368  if ( Abc_ObjFaninNum(pFanout) == 0 )
369  Abc_ObjAddFanin( pFanout, pInv );
370  else
371  Abc_ObjPatchFanin( pFanout, pObj, pInv );
372  }
373  // set the gate
374  pCellNew = Abc_SclFindSmallestGate( p->pInv, Load / Gain );
375  Vec_IntSetEntry( p->pNtk->vGates, Abc_ObjId(pInv), pCellNew->Id );
376  // set departure and load
377  Abc_NtkComputeNodeDeparture( pInv, p->pPars->Slew );
378  LoadNew = Abc_NtkComputeNodeLoad( p, pInv );
379  assert( LoadNew - Load < 1 && Load - LoadNew < 1 );
380  // set fanout info for the inverter
381  Bus_SclObjSetCin( pInv, SC_CellPinCap(pCellNew, 0) );
382  Bus_SclObjSetETime( pInv, Abc_NtkComputeEdgeDept(pInv, 0, p->pPars->Slew) );
383  // update phases
384  if ( p->pNtk->vPhases && Abc_SclIsInv(pInv) )
385  Abc_NodeInvUpdateFanPolarity( pInv );
386  return pInv;
387 }
388 void Abc_SclBufSize( Bus_Man_t * p, float Gain )
389 {
390  SC_Cell * pCell, * pCellNew;
391  Abc_Obj_t * pObj, * pFanout;
392  abctime clk = Abc_Clock();
393  int i, k, nObjsOld = Abc_NtkObjNumMax(p->pNtk);
394  float GainGate, GainInv, Load, LoadNew, Cin, DeptMax = 0;
395  GainGate = p->pPars->fAddBufs ? pow( Gain, 2.0 ) : Gain;
396  GainInv = p->pPars->fAddBufs ? pow( Gain, 2.0 ) : Gain;
397  Abc_NtkForEachObjReverse( p->pNtk, pObj, i )
398  {
399  if ( !((Abc_ObjIsNode(pObj) && Abc_ObjFaninNum(pObj) > 0) || (Abc_ObjIsCi(pObj) && p->pPiDrive)) )
400  continue;
401  if ( 2 * nObjsOld < Abc_NtkObjNumMax(p->pNtk) )
402  {
403  printf( "Buffering could not be completed because the gain value (%d) is too low.\n", p->pPars->GainRatio );
404  break;
405  }
406  // compute load
407  Abc_NtkComputeFanoutInfo( pObj, p->pPars->Slew );
408  Load = Abc_NtkComputeNodeLoad( p, pObj );
409  // consider the gate
410  if ( Abc_ObjIsCi(pObj) )
411  {
412  pCell = p->pPiDrive;
413  Cin = SC_CellPinCapAve( pCell );
414  }
415  else
416  {
417  pCell = Abc_SclObjCell( pObj );
418  Cin = SC_CellPinCapAve( pCell->pAve );
419 // Cin = SC_CellPinCapAve( pCell->pRepr->pNext );
420  }
421  // consider upsizing the gate
422  if ( !p->pPars->fSizeOnly && (Abc_ObjFanoutNum(pObj) > p->pPars->nDegree || Load > GainGate * Cin) )
423  {
424  // add one or more inverters
425 // Abc_NtkPrintFanoutProfile( pObj );
426  Abc_NodeCollectFanouts( pObj, p->vFanouts );
427  Vec_PtrSort( p->vFanouts, (int(*)(void))Bus_SclCompareFanouts );
428  do
429  {
430  Abc_Obj_t * pInv;
431  if ( p->pPars->fVeryVerbose )//|| Vec_PtrSize(p->vFanouts) == Abc_ObjFanoutNum(pObj) )
432  Abc_NtkPrintFanoutProfileVec( pObj, p->vFanouts );
433  pInv = Abc_SclAddOneInv( p, pObj, p->vFanouts, GainInv );
434  if ( p->pPars->fVeryVerbose )
435  Abc_SclOneNodePrint( p, pInv );
436  Bus_SclInsertFanout( p->vFanouts, pInv );
437  Load = Abc_NtkComputeFanoutLoad( p, p->vFanouts );
438  }
439  while ( Vec_PtrSize(p->vFanouts) > p->pPars->nDegree || (Vec_PtrSize(p->vFanouts) > 1 && Load > GainGate * Cin) );
440  // update node fanouts
441  Vec_PtrForEachEntry( Abc_Obj_t *, p->vFanouts, pFanout, k )
442  if ( Abc_ObjFaninNum(pFanout) == 0 )
443  Abc_ObjAddFanin( pFanout, pObj );
444  Bus_SclObjSetLoad( pObj, 0 );
445  LoadNew = Abc_NtkComputeNodeLoad( p, pObj );
446  assert( LoadNew - Load < 1 && Load - LoadNew < 1 );
447  }
448  if ( Abc_ObjIsCi(pObj) )
449  continue;
450  Abc_NtkComputeNodeDeparture( pObj, p->pPars->Slew );
451  // create cell
452  pCellNew = Abc_SclFindSmallestGate( pCell, Load / GainGate );
453  Abc_SclObjSetCell( pObj, pCellNew );
454  if ( p->pPars->fVeryVerbose )
455  Abc_SclOneNodePrint( p, pObj );
456  assert( p->pPars->fSizeOnly || Abc_ObjFanoutNum(pObj) <= p->pPars->nDegree );
457  }
458  // compute departure time of the PI
459  if ( i < 0 ) // finished buffering
460  Abc_NtkForEachCi( p->pNtk, pObj, i )
461  {
462  float DeptCur = Abc_NtkComputeNodeDeparture(pObj, p->pPars->Slew);
463  if ( p->pPiDrive )
464  {
465  float Load = Bus_SclObjLoad( pObj );
466  SC_Pair ArrOut, SlewOut, LoadIn = { Load, Load };
467  Scl_LibHandleInputDriver( p->pPiDrive, &LoadIn, &ArrOut, &SlewOut );
468  DeptCur += 0.5 * ArrOut.fall + 0.5 * ArrOut.rise;
469  }
470  DeptMax = Abc_MaxFloat( DeptMax, DeptCur );
471  }
472  if ( p->pPars->fVerbose )
473  {
474  printf( "WireLoads = %d Degree = %d Target slew =%4d ps Gain2 =%5d Buf = %6d Delay =%7.0f ps ",
475  p->pPars->fUseWireLoads, p->pPars->nDegree, p->pPars->Slew, p->pPars->GainRatio,
476  Abc_NtkObjNumMax(p->pNtk) - nObjsOld, DeptMax );
477  Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
478  }
479 }
480 Abc_Ntk_t * Abc_SclBufferingPerform( Abc_Ntk_t * pNtk, SC_Lib * pLib, SC_BusPars * pPars )
481 {
482  Abc_Ntk_t * pNtkNew;
483  Bus_Man_t * p;
484  if ( !Abc_SclCheckNtk( pNtk, 0 ) )
485  return NULL;
486  Abc_SclReportDupFanins( pNtk );
487  Abc_SclMioGates2SclGates( pLib, pNtk );
488  p = Bus_ManStart( pNtk, pLib, pPars );
489  Bus_ManReadInOutLoads( p );
490  Abc_SclBufSize( p, 0.01 * pPars->GainRatio );
491  Bus_ManStop( p );
492  Abc_SclSclGates2MioGates( pLib, pNtk );
493  if ( pNtk->vPhases )
494  Vec_IntFillExtra( pNtk->vPhases, Abc_NtkObjNumMax(pNtk), 0 );
495  pNtkNew = Abc_NtkDupDfs( pNtk );
496  return pNtkNew;
497 }
498 
499 ////////////////////////////////////////////////////////////////////////
500 /// END OF FILE ///
501 ////////////////////////////////////////////////////////////////////////
502 
503 
504 ABC_NAMESPACE_IMPL_END
505 
Abc_FrameReadMaxLoad
ABC_DLL float Abc_FrameReadMaxLoad()
Definition: mainFrame.c:98
Abc_ObjId
static unsigned Abc_ObjId(Abc_Obj_t *pObj)
Definition: abc.h:329
SC_Cell_::pRepr
SC_Cell * pRepr
Definition: sclLib.h:196
Bus_SclObjSetCin
static void Bus_SclObjSetCin(Abc_Obj_t *p, float cap)
Definition: sclBufSize.c:55
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition: vecPtr.h:42
SC_Cell_::nGates
int nGates
Definition: sclLib.h:199
Abc_FrameReadDrivingCell
ABC_DLL char * Abc_FrameReadDrivingCell()
Definition: mainFrame.c:97
Abc_NtkPrintFanoutProfile
void Abc_NtkPrintFanoutProfile(Abc_Obj_t *pObj)
Definition: sclBufSize.c:224
Bus_Man_t_::vWireCaps
Vec_Flt_t * vWireCaps
Definition: sclBufSize.c:43
Abc_SclIsInv
int Abc_SclIsInv(Abc_Obj_t *pObj)
Definition: sclBuffer.c:116
Bus_SclObjCin
static float Bus_SclObjCin(Abc_Obj_t *p)
Definition: sclBufSize.c:54
SC_Cell_
Definition: sclLib.h:181
Abc_ObjIsCi
static int Abc_ObjIsCi(Abc_Obj_t *pObj)
Definition: abc.h:351
Bus_Man_t_::pInv
SC_Cell * pInv
Definition: sclBufSize.c:41
Vec_FltWriteEntry
static void Vec_FltWriteEntry(Vec_Flt_t *p, int i, float Entry)
Definition: vecFlt.h:364
Abc_NtkObjNumMax
static int Abc_NtkObjNumMax(Abc_Ntk_t *pNtk)
Definition: abc.h:284
Vec_FltEntryP
static float * Vec_FltEntryP(Vec_Flt_t *p, int i)
Definition: vecFlt.h:347
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Vec_IntFillExtra
static void Vec_IntFillExtra(Vec_Int_t *p, int nSize, int Fill)
Definition: bblif.c:376
Abc_SclCheckNtk
int Abc_SclCheckNtk(Abc_Ntk_t *p, int fVerbose)
Definition: sclBuffer.c:286
SC_BusPars_::fAddBufs
int fAddBufs
Definition: sclLib.h:96
SC_Cell_::Order
int Order
Definition: sclLib.h:198
Abc_Ntk_t_
Definition: abc.h:153
Abc_ObjFanoutNum
static int Abc_ObjFanoutNum(Abc_Obj_t *pObj)
Definition: abc.h:365
Bus_SclCheckSortedFanout
void Bus_SclCheckSortedFanout(Vec_Ptr_t *vFanouts)
Definition: sclBufSize.c:295
Abc_SclFindWireLoad
float Abc_SclFindWireLoad(Vec_Flt_t *vWireCaps, int nFans)
Definition: sclLoad.c:94
Abc_NodeFindFanin
ABC_DLL int Abc_NodeFindFanin(Abc_Obj_t *pNode, Abc_Obj_t *pFanin)
Definition: abcUtil.c:758
Abc_SclObjSetCell
static void Abc_SclObjSetCell(Abc_Obj_t *p, SC_Cell *pCell)
Definition: sclSize.h:111
Abc_ObjFaninNum
static int Abc_ObjFaninNum(Abc_Obj_t *pObj)
Definition: abc.h:364
Bus_ManReadInOutLoads
void Bus_ManReadInOutLoads(Bus_Man_t *p)
Definition: sclBufSize.c:133
Abc_SclAddOneInv
Abc_Obj_t * Abc_SclAddOneInv(Bus_Man_t *p, Abc_Obj_t *pObj, Vec_Ptr_t *vFanouts, float Gain)
Definition: sclBufSize.c:334
Vec_PtrSort
static void Vec_PtrSort(Vec_Ptr_t *p, int(*Vec_PtrSortCompare)()) ___unused
Definition: vecPtr.h:851
Vec_PtrPush
static void Vec_PtrPush(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:606
Vec_IntSetEntry
static void Vec_IntSetEntry(Vec_Int_t *p, int i, int Entry)
Definition: bblif.c:418
Vec_FltAlloc
static Vec_Flt_t * Vec_FltAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecFlt.h:78
SC_BusPars_
Definition: sclLib.h:90
Abc_Ntk_t_::pBSMan
void * pBSMan
Definition: abc.h:205
Abc_NtkComputeFanoutLoad
float Abc_NtkComputeFanoutLoad(Bus_Man_t *p, Vec_Ptr_t *vFanouts)
Definition: sclBufSize.c:214
Abc_NtkForEachCo
#define Abc_NtkForEachCo(pNtk, pCo, i)
Definition: abc.h:519
SC_CellPinCapAve
static float SC_CellPinCapAve(SC_Cell *p)
Definition: sclLib.h:244
Abc_Clock
static abctime Abc_Clock()
Definition: abc_global.h:279
Abc_NtkComputeEdgeDept
static float Abc_NtkComputeEdgeDept(Abc_Obj_t *pFanout, int iFanin, float Slew)
Definition: sclBufSize.c:170
Abc_MaxInt
static int Abc_MaxInt(int a, int b)
Definition: abc_global.h:238
Vec_PtrSize
static int Vec_PtrSize(Vec_Ptr_t *p)
Definition: vecPtr.h:295
Bus_SclObjETime
static float Bus_SclObjETime(Abc_Obj_t *p)
Definition: sclBufSize.c:56
Bus_Man_t
typedefABC_NAMESPACE_IMPL_START struct Bus_Man_t_ Bus_Man_t
DECLARATIONS ///.
Definition: sclBufSize.c:32
Abc_NtkComputeFanoutInfo
void Abc_NtkComputeFanoutInfo(Abc_Obj_t *pObj, float Slew)
Definition: sclBufSize.c:190
Vec_FltFill
static void Vec_FltFill(Vec_Flt_t *p, int nSize, float Entry)
Definition: vecFlt.h:450
Bus_SclObjDept
static float Bus_SclObjDept(Abc_Obj_t *p)
Definition: sclBufSize.c:60
SC_WireLoad_
Definition: sclLib.h:117
Vec_FltFreeP
static void Vec_FltFreeP(Vec_Flt_t **p)
Definition: vecFlt.h:235
Abc_MaxFloat
static float Abc_MaxFloat(float a, float b)
Definition: abc_global.h:243
Vec_FltPush
static void Vec_FltPush(Vec_Flt_t *p, float Entry)
Definition: vecFlt.h:528
ABC_SWAP
#define ABC_SWAP(Type, a, b)
Definition: abc_global.h:218
Bus_ManStop
void Bus_ManStop(Bus_Man_t *p)
Definition: sclBufSize.c:111
Abc_ObjIsCo
static int Abc_ObjIsCo(Abc_Obj_t *pObj)
Definition: abc.h:352
Abc_ObjAddFanin
ABC_DLL void Abc_ObjAddFanin(Abc_Obj_t *pObj, Abc_Obj_t *pFanin)
Definition: abcFanio.c:84
Abc_SclFindWireCaps
ABC_NAMESPACE_IMPL_START Vec_Flt_t * Abc_SclFindWireCaps(SC_WireLoad *pWL, int nFanoutMax)
DECLARATIONS ///.
Definition: sclLoad.c:45
Abc_SclReportDupFanins
void Abc_SclReportDupFanins(Abc_Ntk_t *pNtk)
FUNCTION DEFINITIONS ///.
Definition: sclBuffer.c:90
Abc_Obj_t_
Definition: abc.h:128
Abc_PrintTime
static void Abc_PrintTime(int level, const char *pStr, abctime time)
Definition: abc_global.h:367
Abc_ObjPatchFanin
ABC_DLL void Abc_ObjPatchFanin(Abc_Obj_t *pObj, Abc_Obj_t *pFaninOld, Abc_Obj_t *pFaninNew)
Definition: abcFanio.c:172
Abc_ObjIsNode
static int Abc_ObjIsNode(Abc_Obj_t *pObj)
Definition: abc.h:355
Abc_SclGetTotalArea
static float Abc_SclGetTotalArea(Abc_Ntk_t *pNtk)
Definition: sclSize.h:446
Abc_SclFindWireLoadModel
SC_WireLoad * Abc_SclFindWireLoadModel(SC_Lib *p, float Area)
Definition: sclLibUtil.c:247
Abc_MinInt
static int Abc_MinInt(int a, int b)
Definition: abc_global.h:239
Abc_SclBufferingPerform
Abc_Ntk_t * Abc_SclBufferingPerform(Abc_Ntk_t *pNtk, SC_Lib *pLib, SC_BusPars *pPars)
Definition: sclBufSize.c:480
SC_BusPars_::fUseWireLoads
int fUseWireLoads
Definition: sclLib.h:98
Abc_SclMioGates2SclGates
void Abc_SclMioGates2SclGates(SC_Lib *pLib, Abc_Ntk_t *p)
DECLARATIONS ///.
Definition: sclUtil.c:47
Abc_NtkComputeNodeDeparture
float Abc_NtkComputeNodeDeparture(Abc_Obj_t *pObj, float Slew)
Definition: sclBufSize.c:180
Abc_SclOneNodePrint
void Abc_SclOneNodePrint(Bus_Man_t *p, Abc_Obj_t *pObj)
Definition: sclBufSize.c:323
Abc_NtkCreateNodeInv
ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeInv(Abc_Ntk_t *pNtk, Abc_Obj_t *pFanin)
Definition: abcObj.c:662
SC_Pair_::rise
float rise
Definition: sclLib.h:65
Bus_Man_t_::vDepts
Vec_Flt_t * vDepts
Definition: sclBufSize.c:48
Bus_Man_t_::vFanouts
Vec_Ptr_t * vFanouts
Definition: sclBufSize.c:49
SC_Pair_::fall
float fall
Definition: sclLib.h:66
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
Abc_NtkCreateNodeBuf
ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeBuf(Abc_Ntk_t *pNtk, Abc_Obj_t *pFanin)
Definition: abcObj.c:692
SC_Cell_::pAve
SC_Cell * pAve
Definition: sclLib.h:197
Bus_SclObjUpdateDept
static void Bus_SclObjUpdateDept(Abc_Obj_t *p, float time)
Definition: sclBufSize.c:61
SC_Cell_::Id
int Id
Definition: sclLib.h:184
Abc_SclFindSmallestGate
SC_Cell * Abc_SclFindSmallestGate(SC_Cell *p, float CinMin)
Definition: sclLibUtil.c:208
Abc_Ntk_t_::vPhases
Vec_Int_t * vPhases
Definition: abc.h:208
SC_Cell_::pName
char * pName
Definition: sclLib.h:183
SC_LibCell
static SC_Cell * SC_LibCell(SC_Lib *p, int i)
Definition: sclLib.h:240
Abc_SclSclGates2MioGates
void Abc_SclSclGates2MioGates(SC_Lib *pLib, Abc_Ntk_t *p)
Definition: sclUtil.c:73
Abc_NtkDupDfs
ABC_DLL Abc_Ntk_t * Abc_NtkDupDfs(Abc_Ntk_t *pNtk)
Definition: abcNtk.c:476
SC_Pair_
Definition: sclLib.h:63
Vec_PtrWriteEntry
static void Vec_PtrWriteEntry(Vec_Ptr_t *p, int i, void *Entry)
Definition: vecPtr.h:396
Bus_SclInsertFanout
void Bus_SclInsertFanout(Vec_Ptr_t *vFanouts, Abc_Obj_t *pObj)
Definition: sclBufSize.c:275
Bus_SclObjLoad
static float Bus_SclObjLoad(Abc_Obj_t *p)
Definition: sclBufSize.c:58
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
Abc_Obj_t_::vFanouts
Vec_Int_t vFanouts
Definition: abc.h:144
Vec_PtrEntry
static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)
Definition: vecPtr.h:362
Abc_NtkPrintFanoutProfileVec
void Abc_NtkPrintFanoutProfileVec(Abc_Obj_t *pObj, Vec_Ptr_t *vFanouts)
Definition: sclBufSize.c:236
Abc_SclBufSize
void Abc_SclBufSize(Bus_Man_t *p, float Gain)
Definition: sclBufSize.c:388
Bus_Man_t_
Definition: sclBufSize.c:33
Abc_Obj_t_::pNtk
Abc_Ntk_t * pNtk
Definition: abc.h:130
Vec_PtrForEachEntryStop
#define Vec_PtrForEachEntryStop(Type, vVec, pEntry, i, Stop)
Definition: vecPtr.h:59
Abc_ObjForEachFanout
#define Abc_ObjForEachFanout(pObj, pFanout, i)
Definition: abc.h:526
Abc_SclFindInvertor
SC_Cell * Abc_SclFindInvertor(SC_Lib *p, int fFindBuff)
Definition: sclLibUtil.c:197
Abc_NtkForEachCi
#define Abc_NtkForEachCi(pNtk, pCi, i)
Definition: abc.h:515
Vec_PtrAlloc
static Vec_Ptr_t * Vec_PtrAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecPtr.h:83
SC_BusPars_::GainRatio
int GainRatio
Definition: sclLib.h:92
SC_CellPinCap
static float SC_CellPinCap(SC_Cell *p, int i)
Definition: sclLib.h:243
Abc_SclCellFind
int Abc_SclCellFind(SC_Lib *p, char *pName)
Definition: sclLibUtil.c:79
Abc_SclFetchWireLoadModel
SC_WireLoad * Abc_SclFetchWireLoadModel(SC_Lib *p, char *pName)
Definition: sclLibUtil.c:230
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
Bus_SclCompareFanouts
int Bus_SclCompareFanouts(Abc_Obj_t **pp1, Abc_Obj_t **pp2)
Definition: sclBufSize.c:262
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Bus_SclObjSetLoad
static void Bus_SclObjSetLoad(Abc_Obj_t *p, float cap)
Definition: sclBufSize.c:59
Vec_Flt_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Flt_t_ Vec_Flt_t
INCLUDES ///.
Definition: vecFlt.h:42
Vec_PtrFreeP
static void Vec_PtrFreeP(Vec_Ptr_t **p)
Definition: vecPtr.h:240
Bus_Man_t_::pPars
SC_BusPars * pPars
Definition: sclBufSize.c:36
Bus_SclObjMan
static Bus_Man_t * Bus_SclObjMan(Abc_Obj_t *p)
Definition: sclBufSize.c:53
Bus_Man_t_::vETimes
Vec_Flt_t * vETimes
Definition: sclBufSize.c:46
assert
#define assert(ex)
Definition: util_old.h:213
SC_Cell_::pPrev
SC_Cell * pPrev
Definition: sclLib.h:195
Bus_SclObjSetETime
static void Bus_SclObjSetETime(Abc_Obj_t *p, float time)
Definition: sclBufSize.c:57
Vec_FltEntry
static float Vec_FltEntry(Vec_Flt_t *p, int i)
Definition: vecFlt.h:342
Abc_NtkGetFanoutMax
ABC_DLL int Abc_NtkGetFanoutMax(Abc_Ntk_t *pNtk)
Definition: abcUtil.c:464
Abc_ObjFaninPhase
static int Abc_ObjFaninPhase(Abc_Obj_t *p, int i)
Definition: abc.h:392
Bus_Man_t_::vLoads
Vec_Flt_t * vLoads
Definition: sclBufSize.c:47
Abc_NtkForEachObjReverse
#define Abc_NtkForEachObjReverse(pNtk, pNode, i)
Definition: abc.h:449
Scl_LibPinArrivalEstimate
static float Scl_LibPinArrivalEstimate(SC_Cell *pCell, int iPin, float Slew, float Load)
Definition: sclLib.h:578
Abc_NodeCollectFanouts
ABC_DLL void Abc_NodeCollectFanouts(Abc_Obj_t *pNode, Vec_Ptr_t *vNodes)
Definition: abcUtil.c:1607
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition: vecPtr.h:55
Bus_ManStart
Bus_Man_t * Bus_ManStart(Abc_Ntk_t *pNtk, SC_Lib *pLib, SC_BusPars *pPars)
FUNCTION DEFINITIONS ///.
Definition: sclBufSize.c:78
abctime
ABC_INT64_T abctime
Definition: abc_global.h:278
Vec_FltSize
static int Vec_FltSize(Vec_Flt_t *p)
Definition: vecFlt.h:294
Vec_PtrShrink
static void Vec_PtrShrink(Vec_Ptr_t *p, int nSizeNew)
Definition: vecPtr.h:528
Abc_UtilStrsav
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
Bus_Man_t_::vCins
Vec_Flt_t * vCins
Definition: sclBufSize.c:45
Abc_NtkComputeNodeLoad
float Abc_NtkComputeNodeLoad(Bus_Man_t *p, Abc_Obj_t *pObj)
Definition: sclBufSize.c:202
Bus_Man_t_::pPiDrive
SC_Cell * pPiDrive
Definition: sclBufSize.c:38
Abc_Ntk_t_::pWLoadUsed
char * pWLoadUsed
Definition: abc.h:209
Bus_Man_t_::pWLoadUsed
SC_WireLoad * pWLoadUsed
Definition: sclBufSize.c:42
Vec_PtrArray
static void ** Vec_PtrArray(Vec_Ptr_t *p)
Definition: vecPtr.h:279
SC_Lib_
Definition: sclLib.h:202
Abc_NodeInvUpdateFanPolarity
void Abc_NodeInvUpdateFanPolarity(Abc_Obj_t *pObj)
Definition: sclBuffer.c:320
Bus_Man_t_::pLib
SC_Lib * pLib
Definition: sclBufSize.c:40
Bus_Man_t_::pNtk
Abc_Ntk_t * pNtk
Definition: sclBufSize.c:37
Abc_SclObjCell
static SC_Cell * Abc_SclObjCell(Abc_Obj_t *p)
Definition: sclSize.h:110
Scl_LibHandleInputDriver
static void Scl_LibHandleInputDriver(SC_Cell *pCell, SC_Pair *pLoadIn, SC_Pair *pArrOut, SC_Pair *pSlewOut)
Definition: sclLib.h:591