abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
giaScript.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [giaScript.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Scalable AIG package.]
8 
9  Synopsis [Various hardcoded scripts.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: giaScript.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "giaAig.h"
22 #include "base/main/main.h"
23 #include "base/cmd/cmd.h"
24 #include "proof/dch/dch.h"
25 #include "opt/dau/dau.h"
26 
27 ABC_NAMESPACE_IMPL_START
28 
29 
30 ////////////////////////////////////////////////////////////////////////
31 /// DECLARATIONS ///
32 ////////////////////////////////////////////////////////////////////////
33 
34 ////////////////////////////////////////////////////////////////////////
35 /// FUNCTION DEFINITIONS ///
36 ////////////////////////////////////////////////////////////////////////
37 
38 /**Function*************************************************************
39 
40  Synopsis [Synthesis script.]
41 
42  Description []
43 
44  SideEffects []
45 
46  SeeAlso []
47 
48 ***********************************************************************/
49 void Gia_ManAigPrintPiLevels( Gia_Man_t * p )
50 {
51  Gia_Obj_t * pObj;
52  int i;
53  Gia_ManForEachPi( p, pObj, i )
54  printf( "%d ", Gia_ObjLevel(p, pObj) );
55  printf( "\n" );
56 }
57 
58 /**Function*************************************************************
59 
60  Synopsis [Synthesis script.]
61 
62  Description []
63 
64  SideEffects []
65 
66  SeeAlso []
67 
68 ***********************************************************************/
69 Gia_Man_t * Gia_ManAigSyn2( Gia_Man_t * pInit, int fOldAlgo, int fCoarsen, int fCutMin, int nRelaxRatio, int fDelayMin, int fVerbose, int fVeryVerbose )
70 {
71  Gia_Man_t * p, * pNew, * pTemp;
72  Jf_Par_t Pars, * pPars = &Pars;
73  if ( fOldAlgo )
74  {
75  Jf_ManSetDefaultPars( pPars );
76  pPars->fCutMin = fCutMin;
77  }
78  else
79  {
80  Lf_ManSetDefaultPars( pPars );
81  pPars->fCutMin = fCutMin;
82  pPars->fCoarsen = fCoarsen;
83  pPars->nRelaxRatio = nRelaxRatio;
84  pPars->nAreaTuner = 1;
85  pPars->nCutNum = 4;
86  }
87  if ( fVerbose ) Gia_ManPrintStats( pInit, NULL );
88  p = Gia_ManDup( pInit );
89  Gia_ManTransferTiming( p, pInit );
90  if ( Gia_ManAndNum(p) == 0 )
91  return p;
92  // delay optimization
93  if ( fDelayMin && p->pManTime == NULL )
94  {
95  int Area0, Area1, Delay0, Delay1;
96  int fCutMin = pPars->fCutMin;
97  int fCoarsen = pPars->fCoarsen;
98  int nRelaxRatio = pPars->nRelaxRatio;
99  pPars->fCutMin = 0;
100  pPars->fCoarsen = 0;
101  pPars->nRelaxRatio = 0;
102  // perform mapping
103  if ( fOldAlgo )
104  Jf_ManPerformMapping( p, pPars );
105  else
106  Lf_ManPerformMapping( p, pPars );
107  Area0 = (int)pPars->Area;
108  Delay0 = (int)pPars->Delay;
109  // perform balancing
110  pNew = Gia_ManPerformDsdBalance( p, 6, 4, 0, 0 );
111  // perform mapping again
112  if ( fOldAlgo )
113  Jf_ManPerformMapping( pNew, pPars );
114  else
115  Lf_ManPerformMapping( pNew, pPars );
116  Area1 = (int)pPars->Area;
117  Delay1 = (int)pPars->Delay;
118  // choose the best result
119  if ( Delay1 < Delay0 - 1 || (Delay1 == Delay0 + 1 && 100.0 * (Area1 - Area0) / Area1 < 3.0) )
120  {
121  Gia_ManStop( p );
122  p = pNew;
123  }
124  else
125  {
126  Gia_ManStop( pNew );
127  Vec_IntFreeP( &p->vMapping );
128  }
129  // reset params
130  pPars->fCutMin = fCutMin;
131  pPars->fCoarsen = fCoarsen;
132  pPars->nRelaxRatio = nRelaxRatio;
133  }
134  // perform balancing
135  pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
136  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
137  Gia_ManStop( p );
138  // perform mapping
139  if ( fOldAlgo )
140  pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
141  else
142  pNew = Lf_ManPerformMapping( pTemp = pNew, pPars );
143  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
144  if ( pTemp != pNew )
145  Gia_ManStop( pTemp );
146  // perform balancing
147  pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
148  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
149  Gia_ManStop( pTemp );
150  return pNew;
151 }
152 Gia_Man_t * Gia_ManAigSyn3( Gia_Man_t * p, int fVerbose, int fVeryVerbose )
153 {
154  Gia_Man_t * pNew, * pTemp;
155  Jf_Par_t Pars, * pPars = &Pars;
156  Jf_ManSetDefaultPars( pPars );
157  pPars->nRelaxRatio = 40;
158  if ( fVerbose ) Gia_ManPrintStats( p, NULL );
159  if ( Gia_ManAndNum(p) == 0 )
160  return Gia_ManDup(p);
161  // perform balancing
162  pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
163  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
164  // perform mapping
165  pPars->nLutSize = 6;
166  pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
167  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
168 // Gia_ManStop( pTemp );
169  // perform balancing
170  pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
171  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
172  Gia_ManStop( pTemp );
173  // perform mapping
174  pPars->nLutSize = 4;
175  pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
176  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
177 // Gia_ManStop( pTemp );
178  // perform balancing
179  pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
180  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
181  Gia_ManStop( pTemp );
182  return pNew;
183 }
184 Gia_Man_t * Gia_ManAigSyn4( Gia_Man_t * p, int fVerbose, int fVeryVerbose )
185 {
186  Gia_Man_t * pNew, * pTemp;
187  Jf_Par_t Pars, * pPars = &Pars;
188  Jf_ManSetDefaultPars( pPars );
189  pPars->nRelaxRatio = 40;
190  if ( fVerbose ) Gia_ManPrintStats( p, NULL );
191  if ( Gia_ManAndNum(p) == 0 )
192  return Gia_ManDup(p);
193 //Gia_ManAigPrintPiLevels( p );
194  // perform balancing
195  pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
196  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
197  // perform mapping
198  pPars->nLutSize = 7;
199  pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
200  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
201 // Gia_ManStop( pTemp );
202  // perform extraction
203  pNew = Gia_ManPerformFx( pTemp = pNew, ABC_INFINITY, 0, 0, fVeryVerbose, 0 );
204  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
205  Gia_ManStop( pTemp );
206  // perform balancing
207  pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
208  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
209  Gia_ManStop( pTemp );
210  // perform mapping
211  pPars->nLutSize = 5;
212  pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
213  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
214 // Gia_ManStop( pTemp );
215  // perform extraction
216  pNew = Gia_ManPerformFx( pTemp = pNew, ABC_INFINITY, 0, 0, fVeryVerbose, 0 );
217  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
218  Gia_ManStop( pTemp );
219  // perform balancing
220  pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
221  if ( fVerbose ) Gia_ManPrintStats( pNew, NULL );
222  Gia_ManStop( pTemp );
223 //Gia_ManAigPrintPiLevels( pNew );
224  return pNew;
225 }
226 
227 /**Function*************************************************************
228 
229  Synopsis [Duplicates the AIG manager.]
230 
231  Description [This duplicator works for AIGs with choices.]
232 
233  SideEffects []
234 
235  SeeAlso []
236 
237 ***********************************************************************/
238 Vec_Ptr_t * Gia_ManOrderPios( Aig_Man_t * p, Gia_Man_t * pOrder )
239 {
240  Vec_Ptr_t * vPios;
241  Gia_Obj_t * pObj;
242  int i;
243  assert( Aig_ManCiNum(p) == Gia_ManCiNum(pOrder) );
244  assert( Aig_ManCoNum(p) == Gia_ManCoNum(pOrder) );
245  vPios = Vec_PtrAlloc( Aig_ManCiNum(p) + Aig_ManCoNum(p) );
246  Gia_ManForEachObj( pOrder, pObj, i )
247  {
248  if ( Gia_ObjIsCi(pObj) )
249  Vec_PtrPush( vPios, Aig_ManCi(p, Gia_ObjCioId(pObj)) );
250  else if ( Gia_ObjIsCo(pObj) )
251  Vec_PtrPush( vPios, Aig_ManCo(p, Gia_ObjCioId(pObj)) );
252  }
253  return vPios;
254 }
255 
256 /**Function*************************************************************
257 
258  Synopsis []
259 
260  Description []
261 
262  SideEffects []
263 
264  SeeAlso []
265 
266 ***********************************************************************/
267 Gia_Man_t * Gia_ManDupFromBarBufs( Gia_Man_t * p )
268 {
269  Vec_Int_t * vBufObjs;
270  Gia_Man_t * pNew;
271  Gia_Obj_t * pObj;
272  int i, k = 0;
273  assert( Gia_ManBufNum(p) > 0 );
274  assert( Gia_ManRegNum(p) == 0 );
275  assert( !Gia_ManHasChoices(p) );
276  pNew = Gia_ManStart( Gia_ManObjNum(p) );
277  pNew->pName = Abc_UtilStrsav( p->pName );
278  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
279  Gia_ManFillValue(p);
280  Gia_ManConst0(p)->Value = 0;
281  Gia_ManForEachCi( p, pObj, i )
282  pObj->Value = Gia_ManAppendCi( pNew );
283  vBufObjs = Vec_IntAlloc( Gia_ManBufNum(p) );
284  for ( i = 0; i < Gia_ManBufNum(p); i++ )
285  Vec_IntPush( vBufObjs, Gia_ManAppendCi(pNew) );
286  Gia_ManForEachAnd( p, pObj, i )
287  {
288  if ( Gia_ObjIsBuf(pObj) )
289  {
290  pObj->Value = Vec_IntEntry( vBufObjs, k );
291  Vec_IntWriteEntry( vBufObjs, k++, Gia_ObjFanin0Copy(pObj) );
292  }
293  else
294  pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
295  }
296  assert( k == Gia_ManBufNum(p) );
297  for ( i = 0; i < Gia_ManBufNum(p); i++ )
298  Gia_ManAppendCo( pNew, Vec_IntEntry(vBufObjs, i) );
299  Vec_IntFree( vBufObjs );
300  Gia_ManForEachCo( p, pObj, i )
301  Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
302  Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
303  return pNew;
304 }
305 Gia_Man_t * Gia_ManDupToBarBufs( Gia_Man_t * p, int nBarBufs )
306 {
307  Gia_Man_t * pNew;
308  Gia_Obj_t * pObj;
309  int nPiReal = Gia_ManCiNum(p) - nBarBufs;
310  int nPoReal = Gia_ManCoNum(p) - nBarBufs;
311  int i, k = 0;
312  assert( Gia_ManBufNum(p) == 0 );
313  assert( Gia_ManRegNum(p) == 0 );
314  assert( Gia_ManHasChoices(p) );
315  pNew = Gia_ManStart( Gia_ManObjNum(p) );
316  pNew->pName = Abc_UtilStrsav( p->pName );
317  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
318  if ( Gia_ManHasChoices(p) )
319  pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(p) );
320  Gia_ManFillValue(p);
321  Gia_ManConst0(p)->Value = 0;
322  for ( i = 0; i < nPiReal; i++ )
323  Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
324  Gia_ManForEachAnd( p, pObj, i )
325  {
326  for ( ; k < nBarBufs; k++ )
327  if ( ~Gia_ObjFanin0(Gia_ManCo(p, k))->Value )
328  Gia_ManCi(p, nPiReal + k)->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p, k)) );
329  else
330  break;
331  pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
332  if ( Gia_ObjSibl(p, Gia_ObjId(p, pObj)) )
333  pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(Gia_ObjSiblObj(p, Gia_ObjId(p, pObj))->Value);
334  }
335  for ( ; k < nBarBufs; k++ )
336  if ( ~Gia_ObjFanin0Copy(Gia_ManCo(p, k)) )
337  Gia_ManCi(p, nPiReal + k)->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p, k)) );
338  assert( k == nBarBufs );
339  for ( i = 0; i < nPoReal; i++ )
340  Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p, nBarBufs+i)) );
341  Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
342  assert( Gia_ManBufNum(pNew) == nBarBufs );
343  assert( Gia_ManCiNum(pNew) == nPiReal );
344  assert( Gia_ManCoNum(pNew) == nPoReal );
345  return pNew;
346 }
347 
348 /**Function*************************************************************
349 
350  Synopsis []
351 
352  Description []
353 
354  SideEffects []
355 
356  SeeAlso []
357 
358 ***********************************************************************/
359 Gia_Man_t * Gia_ManAigSynch2Choices( Gia_Man_t * pGia1, Gia_Man_t * pGia2, Gia_Man_t * pGia3, Dch_Pars_t * pPars )
360 {
361  Aig_Man_t * pMan, * pTemp;
362  Gia_Man_t * pGia, * pMiter;
363  // derive miter
364  Vec_Ptr_t * vPios, * vGias = Vec_PtrAlloc( 3 );
365  if ( pGia3 ) Vec_PtrPush( vGias, pGia3 );
366  if ( pGia2 ) Vec_PtrPush( vGias, pGia2 );
367  if ( pGia1 ) Vec_PtrPush( vGias, pGia1 );
368  pMiter = Gia_ManChoiceMiter( vGias );
369  Vec_PtrFree( vGias );
370  // transform into an AIG
371  pMan = Gia_ManToAigSkip( pMiter, 3 );
372  Gia_ManStop( pMiter );
373  // compute choices
374  pMan = Dch_ComputeChoices( pTemp = pMan, pPars );
375  Aig_ManStop( pTemp );
376  // reconstruct the network
377  vPios = Gia_ManOrderPios( pMan, pGia1 );
378  pMan = Aig_ManDupDfsGuided( pTemp = pMan, vPios );
379  Aig_ManStop( pTemp );
380  Vec_PtrFree( vPios );
381  // convert to GIA
382  pGia = Gia_ManFromAigChoices( pMan );
383  Aig_ManStop( pMan );
384  return pGia;
385 }
386 Gia_Man_t * Gia_ManAigSynch2( Gia_Man_t * pInit, void * pPars0, int nLutSize, int nRelaxRatio )
387 {
388  extern Gia_Man_t * Gia_ManLutBalance( Gia_Man_t * p, int nLutSize, int fUseMuxes, int fRecursive, int fOptArea, int fVerbose );
389  Dch_Pars_t * pParsDch = (Dch_Pars_t *)pPars0;
390  Gia_Man_t * pGia1, * pGia2, * pGia3, * pNew, * pTemp;
391  int fVerbose = pParsDch->fVerbose;
392  Jf_Par_t Pars, * pPars = &Pars;
393  Lf_ManSetDefaultPars( pPars );
394  pPars->fCutMin = 1;
395  pPars->fCoarsen = 1;
396  pPars->nRelaxRatio = nRelaxRatio;
397  pPars->nAreaTuner = 5;
398  pPars->nCutNum = 12;
399  pPars->fVerbose = fVerbose;
400  if ( fVerbose ) Gia_ManPrintStats( pInit, NULL );
401  pGia1 = Gia_ManDup( pInit );
402  if ( Gia_ManAndNum(pGia1) == 0 )
403  {
404  Gia_ManTransferTiming( pGia1, pInit );
405  return pGia1;
406  }
407  if ( pGia1->pManTime && pGia1->vLevels == NULL )
408  Gia_ManLevelWithBoxes( pGia1 );
409  // unmap if mapped
410  if ( Gia_ManHasMapping(pInit) )
411  {
412  Gia_ManTransferMapping( pGia1, pInit );
413  pGia1 = (Gia_Man_t *)Dsm_ManDeriveGia( pTemp = pGia1, 0 );
414  Gia_ManStop( pTemp );
415  }
416  // perform balancing
417  if ( Gia_ManBufNum(pGia1) )
418  pGia2 = Gia_ManAreaBalance( pGia1, 0, ABC_INFINITY, 0, 0 );
419  else
420  {
421  pGia2 = Gia_ManLutBalance( pGia1, nLutSize, 1, 1, 1, 0 );
422  pGia2 = Gia_ManAreaBalance( pTemp = pGia2, 0, ABC_INFINITY, 0, 0 );
423  Gia_ManStop( pTemp );
424  }
425  if ( fVerbose ) Gia_ManPrintStats( pGia2, NULL );
426  // perform mapping
427  pGia2 = Lf_ManPerformMapping( pTemp = pGia2, pPars );
428  if ( fVerbose ) Gia_ManPrintStats( pGia2, NULL );
429  if ( pTemp != pGia2 )
430  Gia_ManStop( pTemp );
431  // perform balancing
432  if ( pParsDch->fLightSynth || Gia_ManBufNum(pGia2) )
433  pGia3 = Gia_ManAreaBalance( pGia2, 0, ABC_INFINITY, 0, 0 );
434  else
435  {
436  assert( Gia_ManBufNum(pGia2) == 0 );
437  pGia2 = Gia_ManAreaBalance( pTemp = pGia2, 0, ABC_INFINITY, 0, 0 );
438  if ( fVerbose ) Gia_ManPrintStats( pGia2, NULL );
439  Gia_ManStop( pTemp );
440  // perform DSD balancing
441  pGia3 = Gia_ManPerformDsdBalance( pGia2, 6, 8, 0, 0 );
442  }
443  if ( fVerbose ) Gia_ManPrintStats( pGia3, NULL );
444  // perform choice computation
445  if ( Gia_ManBufNum(pInit) )
446  {
447  assert( Gia_ManBufNum(pInit) == Gia_ManBufNum(pGia1) );
448  pGia1 = Gia_ManDupFromBarBufs( pTemp = pGia1 );
449  Gia_ManStop( pTemp );
450  assert( Gia_ManBufNum(pInit) == Gia_ManBufNum(pGia2) );
451  pGia2 = Gia_ManDupFromBarBufs( pTemp = pGia2 );
452  Gia_ManStop( pTemp );
453  assert( Gia_ManBufNum(pInit) == Gia_ManBufNum(pGia3) );
454  pGia3 = Gia_ManDupFromBarBufs( pTemp = pGia3 );
455  Gia_ManStop( pTemp );
456  }
457  pNew = Gia_ManAigSynch2Choices( pGia1, pGia2, pGia3, pParsDch );
458  Gia_ManStop( pGia1 );
459  Gia_ManStop( pGia2 );
460  Gia_ManStop( pGia3 );
461  if ( Gia_ManBufNum(pInit) )
462  {
463  pNew = Gia_ManDupToBarBufs( pTemp = pNew, Gia_ManBufNum(pInit) );
464  Gia_ManStop( pTemp );
465  }
466  // copy names
467  ABC_FREE( pNew->pName );
468  ABC_FREE( pNew->pSpec );
469  pNew->pName = Abc_UtilStrsav(pInit->pName);
470  pNew->pSpec = Abc_UtilStrsav(pInit->pSpec);
471  Gia_ManTransferTiming( pNew, pInit );
472  return pNew;
473 }
474 
475 /**Function*************************************************************
476 
477  Synopsis []
478 
479  Description []
480 
481  SideEffects []
482 
483  SeeAlso []
484 
485 ***********************************************************************/
486 void Gia_ManPerformMap( int nAnds, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose )
487 {
488  char Command[200];
489  sprintf( Command, "&unmap; &lf -K %d -C %d -k %s; &save", nLutSize, nCutNum, fMinAve?"-t":"" );
490 // sprintf( Command, "&unmap; &if -K %d -C %d %s; &save", nLutSize, nCutNum, fMinAve?"-t":"" );
491  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
492  if ( fVerbose )
493  {
494  printf( "MAPPING:\n" );
495  printf( "Mapping with &lf -k:\n" );
496  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
497  }
498  sprintf( Command, "&unmap; &lf -K %d -C %d %s; &save", nLutSize, nCutNum, fMinAve?"-t":"" );
499  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
500  if ( fVerbose )
501  {
502  printf( "Mapping with &lf:\n" );
503  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
504  }
505  if ( (nLutSize == 4 && nAnds < 100000) || (nLutSize == 6 && nAnds < 2000) )
506  {
507  sprintf( Command, "&unmap; &if -sz -S %d%d -K %d -C %d %s", nLutSize, nLutSize, 2*nLutSize-1, 2*nCutNum, fMinAve?"-t":"" );
508  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
509  Vec_IntFreeP( &Abc_FrameReadGia(Abc_FrameGetGlobalFrame())->vPacking );
510  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&save" );
511  if ( fVerbose )
512  {
513  printf( "Mapping with &if -sz -S %d%d -K %d -C %d %s:\n", nLutSize, nLutSize, 2*nLutSize-1, 2*nCutNum, fMinAve?"-t":"" );
514  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
515  }
516  }
517  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&load" );
518  if ( fUseMfs )
519  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&put; mfs2 -W 4 -M 500 -C 7000; &get -m" );
520  if ( fVerbose )
521  {
522  printf( "Mapping final:\n" );
523  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
524  }
525 }
526 void Gia_ManPerformRound( int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose )
527 {
528  char Command[200];
529 
530  // perform AIG-based synthesis
531  if ( nAnds < 50000 )
532  {
533  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "" );
534  sprintf( Command, "&dsdb; &dch -C 500; &if -K %d -C %d %s; &save", nLutSize, nCutNum, fMinAve?"-t":"" );
535  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
536  if ( fVerbose )
537  {
538  printf( "Mapping with &dch -C 500; &if -K %d -C %d %s:\n", nLutSize, nCutNum, fMinAve?"-t":"" );
539  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
540  }
541  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
542  }
543 
544  // perform AIG-based synthesis
545  if ( nAnds < 20000 )
546  {
547  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "" );
548  sprintf( Command, "&dsdb; &dch -C 500; &if -K %d -C %d %s; &save", nLutSize, nCutNum, fMinAve?"-t":"" );
549  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
550  if ( fVerbose )
551  {
552  printf( "Mapping with &dch -C 500; &if -K %d -C %d %s:\n", nLutSize, nCutNum, fMinAve?"-t":"" );
553  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
554  }
555  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
556  }
557 
558  // perform first round of mapping
559  Gia_ManPerformMap( nAnds, nLutSize, nCutNum, fMinAve, fUseMfs, fVerbose );
560  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
561 
562  // perform synthesis
563  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&dsdb" );
564 
565  // perform second round of mapping
566  Gia_ManPerformMap( nAnds, nLutSize, nCutNum, fMinAve, fUseMfs, fVerbose );
567  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
568 
569  // perform synthesis
570  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&syn2 -m -R 10; &dsdb" );
571 
572  // prepare for final mapping
573  sprintf( Command, "&blut -a -K %d", nLutSize );
574  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Command );
575 
576  // perform third round of mapping
577  Gia_ManPerformMap( nAnds, nLutSize, nCutNum, fMinAve, fUseMfs, fVerbose );
578 }
579 void Gia_ManPerformFlow( int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose )
580 {
581  // remove comb equivs
582  if ( fIsMapped )
583  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
584 // if ( Abc_FrameReadGia(Abc_FrameGetGlobalFrame())->pManTime )
585 // Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&sweep" );
586 // else
587 // Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&fraig -c" );
588 
589  // perform first round
590  Gia_ManPerformRound( fIsMapped, nAnds, nLevels, nLutSize, nCutNum, fMinAve, fUseMfs, fVerbose );
591 
592  // perform synthesis
593  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st; &sopb" );
594 
595  // perform first round
596  Gia_ManPerformRound( fIsMapped, nAnds, nLevels, nLutSize, nCutNum, fMinAve, fUseMfs, fVerbose );
597 }
598 
599 /**Function*************************************************************
600 
601  Synopsis []
602 
603  Description []
604 
605  SideEffects []
606 
607  SeeAlso []
608 
609 ***********************************************************************/
610 void Gia_ManPerformFlow2( int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fBalance, int fMinAve, int fUseMfs, int fVerbose )
611 {
612  char Comm1[100], Comm2[100], Comm3[100], Comm4[100];
613  sprintf( Comm1, "&synch2 -K %d -C 500; &if -m%s -K %d -C %d; %s &save", nLutSize, fMinAve?"t":"", nLutSize, nCutNum, fUseMfs ? "&put; mfs2 -W 4 -M 500 -C 7000; &get -m;":"" );
614  sprintf( Comm2, "&dch -C 500; &if -m%s -K %d -C %d; %s &save", fMinAve?"t":"", nLutSize, nCutNum+4, fUseMfs ? "&put; mfs2 -W 4 -M 500 -C 7000; &get -m;":"" );
615  sprintf( Comm3, "&synch2 -K %d -C 500; &lf -m%s -E 5 -K %d -C %d; %s &save", nLutSize, fMinAve?"t":"", nLutSize, nCutNum, fUseMfs ? "&put; mfs2 -W 4 -M 500 -C 7000; &get -m;":"" );
616  sprintf( Comm4, "&dch -C 500; &lf -m%sk -E 5 -K %d -C %d; %s &save", fMinAve?"t":"", nLutSize, nCutNum+4, fUseMfs ? "&put; mfs2 -W 4 -M 500 -C 7000; &get -m;":"" );
617 
618  // perform synthesis
619  if ( fVerbose )
620  printf( "Trying synthesis...\n" );
621  if ( fIsMapped )
622  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
623  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm1 );
624  if ( fVerbose )
625  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
626 
627  // perform synthesis
628  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
629  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm2 );
630  if ( fVerbose )
631  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
632 
633  // return the result
634  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&load" );
635  if ( fVerbose )
636  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
637 
638 
639  // perform balancing
640  if ( fBalance )
641  {
642  if ( fVerbose )
643  printf( "Trying SOP balancing...\n" );
644  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st; &sopb -R 10 -C 4" );
645  }
646 
647 
648  // perform synthesis
649  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm3 );
650  if ( fVerbose )
651  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
652 
653  // perform synthesis
654  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
655  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm2 );
656  if ( fVerbose )
657  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
658 
659  // return the result
660  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&load" );
661  if ( fVerbose )
662  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
663  if ( nAnds > 100000 )
664  return;
665 
666 
667  // perform balancing
668  if ( fBalance )
669  {
670  if ( fVerbose )
671  printf( "Trying SOP balancing...\n" );
672  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st; &sopb -R 10" );
673  }
674 
675 
676  // perform synthesis
677  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm3 );
678  if ( fVerbose )
679  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
680 
681  // perform synthesis
682  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
683  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm2 );
684  if ( fVerbose )
685  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
686 
687  // return the result
688  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&load" );
689  if ( fVerbose )
690  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
691  if ( nAnds > 50000 )
692  return;
693 
694 
695  // perform balancing
696  if ( fBalance )
697  {
698  if ( fVerbose )
699  printf( "Trying SOP balancing...\n" );
700  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st; &sopb -R 10" );
701  }
702 
703 
704  // perform synthesis
705  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm3 );
706  if ( fVerbose )
707  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
708 
709  // perform synthesis
710  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&st" );
711  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), Comm2 );
712  if ( fVerbose )
713  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
714 
715  // return the result
716  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&load" );
717  if ( fVerbose )
718  Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "&ps" );
719 }
720 
721 
722 
723 ////////////////////////////////////////////////////////////////////////
724 /// END OF FILE ///
725 ////////////////////////////////////////////////////////////////////////
726 
727 
728 ABC_NAMESPACE_IMPL_END
729 
Gia_ManAppendAnd
static int Gia_ManAppendAnd(Gia_Man_t *p, int iLit0, int iLit1)
Definition: gia.h:592
Abc_FrameReadGia
ABC_DLL Gia_Man_t * Abc_FrameReadGia(Abc_Frame_t *p)
Definition: mainFrame.c:298
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition: vecPtr.h:42
Jf_ManPerformMapping
Gia_Man_t * Jf_ManPerformMapping(Gia_Man_t *pGia, Jf_Par_t *pPars)
Definition: giaJf.c:1712
Lf_ManSetDefaultPars
void Lf_ManSetDefaultPars(Jf_Par_t *pPars)
Definition: giaLf.c:1981
Gia_ObjSiblObj
static Gia_Obj_t * Gia_ObjSiblObj(Gia_Man_t *p, int Id)
Definition: gia.h:894
Gia_ManDup
Gia_Man_t * Gia_ManDup(Gia_Man_t *p)
Definition: giaDup.c:552
Jf_Par_t_::nCutNum
int nCutNum
Definition: gia.h:268
Jf_Par_t_::nLutSize
int nLutSize
Definition: gia.h:267
Gia_ManStop
void Gia_ManStop(Gia_Man_t *p)
Definition: giaMan.c:77
Gia_ManForEachCo
#define Gia_ManForEachCo(p, pObj, i)
Definition: gia.h:1022
Gia_ManPrintStats
void Gia_ManPrintStats(Gia_Man_t *p, Gps_Par_t *pPars)
Definition: giaMan.c:389
Aig_Man_t
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
Gia_ManCi
static Gia_Obj_t * Gia_ManCi(Gia_Man_t *p, int v)
Definition: gia.h:403
Gia_ManAppendCo
static int Gia_ManAppendCo(Gia_Man_t *p, int iLit0)
Definition: gia.h:703
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition: bblif.c:37
Aig_ManStop
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
Cmd_CommandExecute
int Cmd_CommandExecute(void *pAbc, char *pCommandLine)
Gia_Man_t_::pSibls
int * pSibls
Definition: gia.h:123
Gia_ManAigSyn3
Gia_Man_t * Gia_ManAigSyn3(Gia_Man_t *p, int fVerbose, int fVeryVerbose)
Definition: giaScript.c:152
Lf_ManPerformMapping
Gia_Man_t * Lf_ManPerformMapping(Gia_Man_t *pGia, Jf_Par_t *pPars)
Definition: giaLf.c:2193
Gia_ManAppendCi
static int Gia_ManAppendCi(Gia_Man_t *p)
Definition: gia.h:583
Gia_ManLevelWithBoxes
int Gia_ManLevelWithBoxes(Gia_Man_t *p)
Definition: giaTim.c:469
Jf_Par_t_::nAreaTuner
int nAreaTuner
Definition: gia.h:274
Gia_ManLutBalance
Gia_Man_t * Gia_ManLutBalance(Gia_Man_t *p, int nLutSize, int fUseMuxes, int fRecursive, int fOptArea, int fVerbose)
Definition: giaStr.c:1377
Vec_PtrPush
static void Vec_PtrPush(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:606
Gia_ObjIsBuf
static int Gia_ObjIsBuf(Gia_Obj_t *pObj)
Definition: gia.h:427
Gia_ManSetRegNum
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition: giaMan.c:628
Dch_Pars_t
typedefABC_NAMESPACE_HEADER_START struct Dch_Pars_t_ Dch_Pars_t
INCLUDES ///.
Definition: dch.h:43
Gia_ManPerformFx
Gia_Man_t * Gia_ManPerformFx(Gia_Man_t *p, int nNewNodesMax, int LitCountMax, int fReverse, int fVerbose, int fVeryVerbose)
Definition: giaFx.c:451
Gia_ManAigPrintPiLevels
ABC_NAMESPACE_IMPL_START void Gia_ManAigPrintPiLevels(Gia_Man_t *p)
DECLARATIONS ///.
Definition: giaScript.c:49
Gia_ManPerformRound
void Gia_ManPerformRound(int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose)
Definition: giaScript.c:526
Gia_ManDupFromBarBufs
Gia_Man_t * Gia_ManDupFromBarBufs(Gia_Man_t *p)
Definition: giaScript.c:267
Gia_ManPerformDsdBalance
Gia_Man_t * Gia_ManPerformDsdBalance(Gia_Man_t *p, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose)
Definition: giaIf.c:2058
Gia_Obj_t_
Definition: gia.h:75
Gia_ManHasChoices
static int Gia_ManHasChoices(Gia_Man_t *p)
Definition: gia.h:397
Jf_Par_t_::nRelaxRatio
int nRelaxRatio
Definition: gia.h:272
Jf_Par_t_::Delay
word Delay
Definition: gia.h:297
Jf_Par_t_::Area
word Area
Definition: gia.h:298
Gia_ManForEachCi
#define Gia_ManForEachCi(p, pObj, i)
Definition: gia.h:1016
Vec_IntWriteEntry
static void Vec_IntWriteEntry(Vec_Int_t *p, int i, int Entry)
Definition: bblif.c:285
Gia_ManAndNum
static int Gia_ManAndNum(Gia_Man_t *p)
Definition: gia.h:389
Aig_ManCoNum
static int Aig_ManCoNum(Aig_Man_t *p)
Definition: aig.h:252
Gia_ObjLevel
static int Gia_ObjLevel(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:501
Gia_ObjSibl
static int Gia_ObjSibl(Gia_Man_t *p, int Id)
Definition: gia.h:893
Aig_ManDupDfsGuided
Aig_Man_t * Aig_ManDupDfsGuided(Aig_Man_t *p, Vec_Ptr_t *vPios)
Definition: aigDup.c:694
Gia_ObjFanin0
static Gia_Obj_t * Gia_ObjFanin0(Gia_Obj_t *pObj)
Definition: gia.h:454
Gia_Man_t_::pName
char * pName
Definition: gia.h:97
Vec_IntAlloc
static Vec_Int_t * Vec_IntAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: bblif.c:149
Jf_Par_t_
Definition: gia.h:265
Gia_ObjFanin1Copy
static int Gia_ObjFanin1Copy(Gia_Obj_t *pObj)
Definition: gia.h:482
Gia_ManPerformMap
void Gia_ManPerformMap(int nAnds, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose)
Definition: giaScript.c:486
Aig_ManCi
static Aig_Obj_t * Aig_ManCi(Aig_Man_t *p, int i)
Definition: aig.h:266
Jf_ManSetDefaultPars
void Jf_ManSetDefaultPars(Jf_Par_t *pPars)
Definition: giaJf.c:1679
Gia_ManAppendBuf
static int Gia_ManAppendBuf(Gia_Man_t *p, int iLit)
Definition: gia.h:694
Vec_IntEntry
static int Vec_IntEntry(Vec_Int_t *p, int i)
Definition: bblif.c:268
Aig_ManCiNum
static int Aig_ManCiNum(Aig_Man_t *p)
Definition: aig.h:251
Gia_ManAigSyn2
Gia_Man_t * Gia_ManAigSyn2(Gia_Man_t *pInit, int fOldAlgo, int fCoarsen, int fCutMin, int nRelaxRatio, int fDelayMin, int fVerbose, int fVeryVerbose)
Definition: giaScript.c:69
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
Abc_FrameGetGlobalFrame
void * Abc_FrameGetGlobalFrame()
Definition: mainFrame.c:593
Gia_Man_t_::pSpec
char * pSpec
Definition: gia.h:98
Gia_ManStart
Gia_Man_t * Gia_ManStart(int nObjsMax)
DECLARATIONS ///.
Definition: giaMan.c:52
Gia_ManForEachAnd
#define Gia_ManForEachAnd(p, pObj, i)
Definition: gia.h:1002
Gia_ManOrderPios
Vec_Ptr_t * Gia_ManOrderPios(Aig_Man_t *p, Gia_Man_t *pOrder)
Definition: giaScript.c:238
Vec_IntPush
static void Vec_IntPush(Vec_Int_t *p, int Entry)
Definition: bblif.c:468
sprintf
char * sprintf()
Gia_Man_t_::pManTime
void * pManTime
Definition: gia.h:165
Gia_ObjId
static int Gia_ObjId(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:410
Gia_ManFillValue
void Gia_ManFillValue(Gia_Man_t *p)
Definition: giaUtil.c:328
Gia_ManPerformFlow2
void Gia_ManPerformFlow2(int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fBalance, int fMinAve, int fUseMfs, int fVerbose)
Definition: giaScript.c:610
Gia_ManTransferTiming
void Gia_ManTransferTiming(Gia_Man_t *p, Gia_Man_t *pGia)
Definition: giaIf.c:1912
Vec_IntFreeP
static void Vec_IntFreeP(Vec_Int_t **p)
Definition: vecInt.h:289
Gia_ManForEachPi
#define Gia_ManForEachPi(p, pObj, i)
Definition: gia.h:1034
Gia_ManChoiceMiter
Gia_Man_t * Gia_ManChoiceMiter(Vec_Ptr_t *vGias)
Definition: giaDup.c:2574
Gia_ObjFanin0Copy
static int Gia_ObjFanin0Copy(Gia_Obj_t *pObj)
Definition: gia.h:481
Gia_ObjIsCo
static int Gia_ObjIsCo(Gia_Obj_t *pObj)
Definition: gia.h:421
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
Aig_ManCo
static Aig_Obj_t * Aig_ManCo(Aig_Man_t *p, int i)
Definition: aig.h:267
Gia_ManCiNum
static int Gia_ManCiNum(Gia_Man_t *p)
Definition: gia.h:383
Gia_ManCo
static Gia_Obj_t * Gia_ManCo(Gia_Man_t *p, int v)
Definition: gia.h:404
Gia_ManHasMapping
static int Gia_ManHasMapping(Gia_Man_t *p)
Definition: gia.h:951
Gia_ManAigSynch2Choices
Gia_Man_t * Gia_ManAigSynch2Choices(Gia_Man_t *pGia1, Gia_Man_t *pGia2, Gia_Man_t *pGia3, Dch_Pars_t *pPars)
Definition: giaScript.c:359
Vec_PtrAlloc
static Vec_Ptr_t * Vec_PtrAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: vecPtr.h:83
Dsm_ManDeriveGia
void * Dsm_ManDeriveGia(void *p, int fUseMuxes)
Definition: dauGia.c:471
Gia_ManToAigSkip
Aig_Man_t * Gia_ManToAigSkip(Gia_Man_t *p, int nOutDelta)
Definition: giaAig.c:324
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
Gia_Man_t_
Definition: gia.h:95
Gia_ManBufNum
static int Gia_ManBufNum(Gia_Man_t *p)
Definition: gia.h:392
Gia_ManForEachObj
#define Gia_ManForEachObj(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: gia.h:984
Jf_Par_t_::fCutMin
int fCutMin
Definition: gia.h:282
Gia_ManConst0
static Gia_Obj_t * Gia_ManConst0(Gia_Man_t *p)
Definition: gia.h:400
Abc_Lit2Var
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Gia_Man_t_::fVerbose
int fVerbose
Definition: gia.h:174
ABC_INFINITY
#define ABC_INFINITY
MACRO DEFINITIONS ///.
Definition: abc_global.h:216
Gia_ManTransferMapping
void Gia_ManTransferMapping(Gia_Man_t *p, Gia_Man_t *pGia)
Definition: giaIf.c:1855
assert
#define assert(ex)
Definition: util_old.h:213
Gia_Obj_t_::Value
unsigned Value
Definition: gia.h:87
Gia_Man_t_::vLevels
Vec_Int_t * vLevels
Definition: gia.h:115
Dch_ComputeChoices
Aig_Man_t * Dch_ComputeChoices(Aig_Man_t *pAig, Dch_Pars_t *pPars)
Definition: dchCore.c:89
Gia_ManAreaBalance
Gia_Man_t * Gia_ManAreaBalance(Gia_Man_t *p, int fSimpleAnd, int nNewNodesMax, int fVerbose, int fVeryVerbose)
Definition: giaBalAig.c:968
Gia_Man_t_::vMapping
Vec_Int_t * vMapping
Definition: gia.h:131
Vec_IntFree
static void Vec_IntFree(Vec_Int_t *p)
Definition: bblif.c:235
Gia_ManAigSynch2
Gia_Man_t * Gia_ManAigSynch2(Gia_Man_t *pInit, void *pPars0, int nLutSize, int nRelaxRatio)
Definition: giaScript.c:386
Gia_ObjIsCi
static int Gia_ObjIsCi(Gia_Obj_t *pObj)
Definition: gia.h:420
Abc_UtilStrsav
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
Gia_ManPerformFlow
void Gia_ManPerformFlow(int fIsMapped, int nAnds, int nLevels, int nLutSize, int nCutNum, int fMinAve, int fUseMfs, int fVerbose)
Definition: giaScript.c:579
Gia_ManAigSyn4
Gia_Man_t * Gia_ManAigSyn4(Gia_Man_t *p, int fVerbose, int fVeryVerbose)
Definition: giaScript.c:184
Gia_ManDupToBarBufs
Gia_Man_t * Gia_ManDupToBarBufs(Gia_Man_t *p, int nBarBufs)
Definition: giaScript.c:305
Gia_ObjCioId
static int Gia_ObjCioId(Gia_Obj_t *pObj)
Definition: gia.h:411
Gia_ManObjNum
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
Jf_Par_t_::fVerbose
int fVerbose
Definition: gia.h:291
Gia_ManFromAigChoices
Gia_Man_t * Gia_ManFromAigChoices(Aig_Man_t *p)
Definition: giaAig.c:132
Vec_PtrFree
static void Vec_PtrFree(Vec_Ptr_t *p)
Definition: vecPtr.h:223
Jf_Par_t_::fCoarsen
int fCoarsen
Definition: gia.h:281
Gia_ManCoNum
static int Gia_ManCoNum(Gia_Man_t *p)
Definition: gia.h:384
Gia_ManRegNum
static int Gia_ManRegNum(Gia_Man_t *p)
Definition: gia.h:387