abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
amapMerge.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [amapMerge.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Technology mapper for standard cells.]
8 
9  Synopsis [Computing cuts for the node.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: amapMerge.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "amapInt.h"
22 
23 ABC_NAMESPACE_IMPL_START
24 
25 
26 ////////////////////////////////////////////////////////////////////////
27 /// DECLARATIONS ///
28 ////////////////////////////////////////////////////////////////////////
29 
30 ////////////////////////////////////////////////////////////////////////
31 /// FUNCTION DEFINITIONS ///
32 ////////////////////////////////////////////////////////////////////////
33 
34 /**Function*************************************************************
35 
36  Synopsis [Creates new cut and adds it to storage.]
37 
38  Description []
39 
40  SideEffects []
41 
42  SeeAlso []
43 
44 ***********************************************************************/
45 Amap_Cut_t * Amap_ManSetupPis( Amap_Man_t * p )
46 {
47  Amap_Obj_t * pObj;
48  Amap_Cut_t * pCut;
49  int i, nBytes = sizeof(Amap_Cut_t) + sizeof(int);
50  char * pBuffer = ABC_ALLOC( char, Amap_ManPiNum(p) * nBytes );
51  Amap_ManForEachPi( p, pObj, i )
52  {
53  pCut = (Amap_Cut_t *)( pBuffer + i*nBytes );
54  pCut->iMat = 0;
55  pCut->fInv = 0;
56  pCut->nFans = 1;
57  pCut->Fans[0] = Abc_Var2Lit( pObj->Id, 0 );
58  pObj->pData = pCut;
59  pObj->nCuts = 1;
60  pObj->EstRefs = (float)1.0;
61  }
62  return (Amap_Cut_t *)pBuffer;
63 }
64 
65 /**Function*************************************************************
66 
67  Synopsis [Creates new cut and adds it to storage.]
68 
69  Description []
70 
71  SideEffects []
72 
73  SeeAlso []
74 
75 ***********************************************************************/
76 Amap_Cut_t * Amap_ManCutStore( Amap_Man_t * p, Amap_Cut_t * pCut, int fCompl )
77 {
78  Amap_Cut_t * pNew;
79  int iFan, nBytes = sizeof(Amap_Cut_t) + sizeof(int) * pCut->nFans + sizeof(Amap_Cut_t *);
80  pNew = (Amap_Cut_t *)Aig_MmFlexEntryFetch( p->pMemTemp, nBytes );
81  pNew->iMat = pCut->iMat;
82  pNew->fInv = pCut->fInv ^ fCompl;
83  pNew->nFans = pCut->nFans;
84  memcpy( pNew->Fans, pCut->Fans, sizeof(int) * pCut->nFans );
85  // add it to storage
86  iFan = Abc_Var2Lit( pNew->iMat, pNew->fInv );
87  if ( p->ppCutsTemp[ iFan ] == NULL )
88  Vec_IntPushOrder( p->vTemp, iFan );
89  *Amap_ManCutNextP( pNew ) = p->ppCutsTemp[ iFan ];
90  p->ppCutsTemp[ iFan ] = pNew;
91  return pNew;
92 }
93 
94 /**Function*************************************************************
95 
96  Synopsis [Creates new cut and adds it to storage.]
97 
98  Description []
99 
100  SideEffects []
101 
102  SeeAlso []
103 
104 ***********************************************************************/
105 Amap_Cut_t * Amap_ManCutCreate( Amap_Man_t * p,
106  Amap_Cut_t * pCut0, Amap_Cut_t * pCut1, int iMat )
107 {
108  Amap_Cut_t * pCut;
109  int i, nSize = pCut0->nFans + pCut1->nFans;
110  int nBytes = sizeof(Amap_Cut_t) + sizeof(int) * nSize + sizeof(Amap_Cut_t *);
111  assert( pCut0->iMat >= pCut1->iMat );
112  pCut = (Amap_Cut_t *)Aig_MmFlexEntryFetch( p->pMemTemp, nBytes );
113  pCut->iMat = iMat;
114  pCut->fInv = 0;
115  pCut->nFans = nSize;
116  for ( i = 0; i < (int)pCut0->nFans; i++ )
117  pCut->Fans[i] = pCut0->Fans[i];
118  for ( i = 0; i < (int)pCut1->nFans; i++ )
119  pCut->Fans[pCut0->nFans+i] = pCut1->Fans[i];
120  // add it to storage
121  if ( p->ppCutsTemp[ pCut->iMat ] == NULL )
122  Vec_IntPushOrder( p->vTemp, pCut->iMat );
123  *Amap_ManCutNextP( pCut ) = p->ppCutsTemp[ pCut->iMat ];
124  p->ppCutsTemp[ pCut->iMat ] = pCut;
125  return pCut;
126 }
127 
128 /**Function*************************************************************
129 
130  Synopsis [Creates new cut and adds it to storage.]
131 
132  Description []
133 
134  SideEffects []
135 
136  SeeAlso []
137 
138 ***********************************************************************/
139 Amap_Cut_t * Amap_ManCutCreate3( Amap_Man_t * p,
140  Amap_Cut_t * pCut0, Amap_Cut_t * pCut1, Amap_Cut_t * pCut2, int iMat )
141 {
142  Amap_Cut_t * pCut;
143  int i, nSize = pCut0->nFans + pCut1->nFans + pCut2->nFans;
144  int nBytes = sizeof(Amap_Cut_t) + sizeof(int) * nSize + sizeof(Amap_Cut_t *);
145  pCut = (Amap_Cut_t *)Aig_MmFlexEntryFetch( p->pMemTemp, nBytes );
146  pCut->iMat = iMat;
147  pCut->fInv = 0;
148  pCut->nFans = nSize;
149  for ( i = 0; i < (int)pCut0->nFans; i++ )
150  pCut->Fans[i] = pCut0->Fans[i];
151  for ( i = 0; i < (int)pCut1->nFans; i++ )
152  pCut->Fans[pCut0->nFans+i] = pCut1->Fans[i];
153  for ( i = 0; i < (int)pCut2->nFans; i++ )
154  pCut->Fans[pCut0->nFans+pCut1->nFans+i] = pCut2->Fans[i];
155  // add it to storage
156  if ( p->ppCutsTemp[ pCut->iMat ] == NULL )
157  Vec_IntPushOrder( p->vTemp, pCut->iMat );
158  *Amap_ManCutNextP( pCut ) = p->ppCutsTemp[ pCut->iMat ];
159  p->ppCutsTemp[ pCut->iMat ] = pCut;
160  return pCut;
161 }
162 
163 /**Function*************************************************************
164 
165  Synopsis [Removes cuts from the temporary storage.]
166 
167  Description []
168 
169  SideEffects []
170 
171  SeeAlso []
172 
173 ***********************************************************************/
174 void Amap_ManCutSaveStored( Amap_Man_t * p, Amap_Obj_t * pNode )
175 {
176  int nMaxCuts = p->pPars->nCutsMax;
177  int * pBuffer;
178  Amap_Cut_t * pNext, * pCut;
179  int i, nWords, Entry, nCuts, nCuts2;
180  assert( pNode->pData == NULL );
181  // count memory needed
182  nCuts = 1;
183  nWords = 2;
184  Vec_IntForEachEntry( p->vTemp, Entry, i )
185  {
186  for ( pCut = p->ppCutsTemp[Entry]; pCut; pCut = *Amap_ManCutNextP(pCut) )
187  {
188  nCuts++;
189  if ( nCuts < nMaxCuts )
190  nWords += pCut->nFans + 1;
191  }
192  }
193  p->nBytesUsed += 4*nWords;
194  // allocate memory
195  pBuffer = (int *)Aig_MmFlexEntryFetch( p->pMemCuts, 4*nWords );
196  pNext = (Amap_Cut_t *)pBuffer;
197  // add the first cut
198  pNext->iMat = 0;
199  pNext->fInv = 0;
200  pNext->nFans = 1;
201  pNext->Fans[0] = Abc_Var2Lit(pNode->Id, 0);
202  pNext = (Amap_Cut_t *)(pBuffer + 2);
203  // add other cuts
204  nCuts2 = 1;
205  Vec_IntForEachEntry( p->vTemp, Entry, i )
206  {
207  for ( pCut = p->ppCutsTemp[Entry]; pCut; pCut = *Amap_ManCutNextP(pCut) )
208  {
209  nCuts2++;
210  if ( nCuts2 < nMaxCuts )
211  {
212  memcpy( pNext, pCut, sizeof(int) * (pCut->nFans + 1) );
213  pNext = (Amap_Cut_t *)((int *)pNext + pCut->nFans + 1);
214  }
215  }
216  p->ppCutsTemp[Entry] = NULL;
217  }
218  assert( nCuts == nCuts2 );
219  assert( (int *)pNext - pBuffer == nWords );
220  // restore the storage
221  Vec_IntClear( p->vTemp );
222  Aig_MmFlexRestart( p->pMemTemp );
223  for ( i = 0; i < 2*p->pLib->nNodes; i++ )
224  if ( p->ppCutsTemp[i] != NULL )
225  printf( "Amap_ManCutSaveStored(): Error!\n" );
226  pNode->pData = (Amap_Cut_t *)pBuffer;
227  pNode->nCuts = Abc_MinInt( nCuts, nMaxCuts-1 );
228  assert( nCuts < (1<<20) );
229 // printf("%d ", nCuts );
230  // verify cuts
231  pCut = NULL;
232  Amap_NodeForEachCut( pNode, pNext, i )
233 // for ( i = 0, pNext = (Amap_Cut_t *)pNode->pData; i < (int)pNode->nCuts;
234 // i++, pNext = Amap_ManCutNext(pNext) )
235  {
236  if ( i == nMaxCuts )
237  break;
238  assert( pCut == NULL || pCut->iMat <= pNext->iMat );
239  pCut = pNext;
240  }
241 }
242 
243 /**Function*************************************************************
244 
245  Synopsis [Returns the number of possible new cuts.]
246 
247  Description []
248 
249  SideEffects []
250 
251  SeeAlso []
252 
253 ***********************************************************************/
254 int Amap_ManMergeCountCuts( Amap_Man_t * p, Amap_Obj_t * pNode )
255 {
256  Amap_Obj_t * pFanin0 = Amap_ObjFanin0( p, pNode );
257  Amap_Obj_t * pFanin1 = Amap_ObjFanin1( p, pNode );
258  Amap_Cut_t * pCut0, * pCut1;
259  int Entry, c0, c1, iCompl0, iCompl1, iFan0, iFan1;
260  int Counter = 1;
261  Amap_NodeForEachCut( pFanin0, pCut0, c0 )
262  Amap_NodeForEachCut( pFanin1, pCut1, c1 )
263  {
264  iCompl0 = pCut0->fInv ^ Amap_ObjFaninC0(pNode);
265  iCompl1 = pCut1->fInv ^ Amap_ObjFaninC1(pNode);
266  iFan0 = !pCut0->iMat? 0: Abc_Var2Lit( pCut0->iMat, iCompl0 );
267  iFan1 = !pCut1->iMat? 0: Abc_Var2Lit( pCut1->iMat, iCompl1 );
268  Entry = Amap_LibFindNode( p->pLib, iFan0, iFan1, pNode->Type == AMAP_OBJ_XOR );
269  Counter += ( Entry >=0 );
270 // if ( Entry >=0 )
271 // printf( "Full: %d + %d = %d\n", iFan0, iFan1, Entry );
272  }
273  return Counter;
274 }
275 
276 /**Function*************************************************************
277 
278  Synopsis [Print cuts.]
279 
280  Description []
281 
282  SideEffects []
283 
284  SeeAlso []
285 
286 ***********************************************************************/
287 void Amap_ManPrintCuts( Amap_Obj_t * pNode )
288 {
289  Amap_Cut_t * pCut;
290  int c, i;
291  printf( "NODE %5d : Type = ", pNode->Id );
292  if ( pNode->Type == AMAP_OBJ_AND )
293  printf( "AND" );
294  else if ( pNode->Type == AMAP_OBJ_XOR )
295  printf( "XOR" );
296  else if ( pNode->Type == AMAP_OBJ_MUX )
297  printf( "MUX" );
298  printf( " Cuts = %d\n", pNode->nCuts );
299  Amap_NodeForEachCut( pNode, pCut, c )
300  {
301  printf( "%3d : Mat= %3d Inv=%d ", c, pCut->iMat, pCut->fInv );
302  for ( i = 0; i < (int)pCut->nFans; i++ )
303  printf( "%d%c ", Abc_Lit2Var(pCut->Fans[i]), Abc_LitIsCompl(pCut->Fans[i])?'-':'+' );
304  printf( "\n" );
305  }
306 }
307 
308 /**Function*************************************************************
309 
310  Synopsis [Derives cuts for one node.]
311 
312  Description []
313 
314  SideEffects []
315 
316  SeeAlso []
317 
318 ***********************************************************************/
319 void Amap_ManMergeNodeChoice( Amap_Man_t * p, Amap_Obj_t * pNode )
320 {
321  Amap_Obj_t * pTemp;
322  Amap_Cut_t * pCut;
323  int c;
324  // go through the nodes of the choice node
325  for ( pTemp = pNode; pTemp; pTemp = Amap_ObjChoice(p, pTemp) )
326  {
327  Amap_NodeForEachCut( pTemp, pCut, c )
328  {
329  if (!pCut) break; // mikelee added; abort when pCut is NULL
330  if ( pCut->iMat )
331  Amap_ManCutStore( p, pCut, pNode->fPhase ^ pTemp->fPhase );
332  }
333  pTemp->pData = NULL;
334  }
335  Amap_ManCutSaveStored( p, pNode );
336 
337 // Amap_ManPrintCuts( pNode );
338 }
339 
340 /**Function*************************************************************
341 
342  Synopsis [Derives cuts for one node.]
343 
344  Description []
345 
346  SideEffects []
347 
348  SeeAlso []
349 
350 ***********************************************************************/
351 int Amap_ManFindCut( Amap_Obj_t * pNode, Amap_Obj_t * pFanin, int fComplFanin, int Val, Vec_Ptr_t * vCuts )
352 {
353  Amap_Cut_t * pCut;
354  int c, iCompl, iFan;
355  Vec_PtrClear( vCuts );
356  Amap_NodeForEachCut( pFanin, pCut, c )
357  {
358  iCompl = pCut->fInv ^ fComplFanin;
359  iFan = !pCut->iMat? 0: Abc_Var2Lit( pCut->iMat, iCompl );
360  if ( iFan == Val )
361  Vec_PtrPush( vCuts, pCut );
362  }
363  return Vec_PtrSize(vCuts) == 0;
364 }
365 
366 /**Function*************************************************************
367 
368  Synopsis [Derives cuts for one node.]
369 
370  Description []
371 
372  SideEffects []
373 
374  SeeAlso []
375 
376 ***********************************************************************/
377 void Amap_ManMergeNodeCutsMux( Amap_Man_t * p, Amap_Obj_t * pNode )
378 {
379  Vec_Int_t * vRules = p->pLib->vRules3;
380  Amap_Obj_t * pFanin0 = Amap_ObjFanin0( p, pNode );
381  Amap_Obj_t * pFanin1 = Amap_ObjFanin1( p, pNode );
382  Amap_Obj_t * pFanin2 = Amap_ObjFanin2( p, pNode );
383  int fComplFanin0 = Amap_ObjFaninC0( pNode );
384  int fComplFanin1 = Amap_ObjFaninC1( pNode );
385  int fComplFanin2 = Amap_ObjFaninC2( pNode );
386  Amap_Cut_t * pCut0, * pCut1, * pCut2;
387  int x, c0, c1, c2;
388  assert( pNode->pData == NULL );
389  assert( pNode->Type == AMAP_OBJ_MUX );
390  assert( pNode->fRepr == 0 );
391  // go through the rules
392  for ( x = 0; x < Vec_IntSize(vRules); x += 4 )
393  {
394  if ( Amap_ManFindCut( pNode, pFanin0, fComplFanin0, Vec_IntEntry(vRules, x), p->vCuts0 ) )
395  continue;
396  if ( Amap_ManFindCut( pNode, pFanin1, fComplFanin1, Vec_IntEntry(vRules, x+1), p->vCuts1 ) )
397  continue;
398  if ( Amap_ManFindCut( pNode, pFanin2, fComplFanin2, Vec_IntEntry(vRules, x+2), p->vCuts2 ) )
399  continue;
400  Vec_PtrForEachEntry( Amap_Cut_t *, p->vCuts0, pCut0, c0 )
401  Vec_PtrForEachEntry( Amap_Cut_t *, p->vCuts1, pCut1, c1 )
402  Vec_PtrForEachEntry( Amap_Cut_t *, p->vCuts2, pCut2, c2 )
403  {
404  Amap_Nod_t * pNod = Amap_LibNod( p->pLib, Vec_IntEntry(vRules, x+3) );
405  if ( pNod->pSets == NULL )
406  continue;
407  // complement literals
408  if ( pCut0->nFans == 1 && (pCut0->fInv ^ fComplFanin0) )
409  pCut0->Fans[0] = Abc_LitNot(pCut0->Fans[0]);
410  if ( pCut1->nFans == 1 && (pCut1->fInv ^ fComplFanin1) )
411  pCut1->Fans[0] = Abc_LitNot(pCut1->Fans[0]);
412  if ( pCut2->nFans == 1 && (pCut2->fInv ^ fComplFanin2) )
413  pCut2->Fans[0] = Abc_LitNot(pCut2->Fans[0]);
414  // create new cut
415  Amap_ManCutCreate3( p, pCut0, pCut1, pCut2, Vec_IntEntry(vRules, x+3) );
416  // uncomplement literals
417  if ( pCut0->nFans == 1 && (pCut0->fInv ^ fComplFanin0) )
418  pCut0->Fans[0] = Abc_LitNot(pCut0->Fans[0]);
419  if ( pCut1->nFans == 1 && (pCut1->fInv ^ fComplFanin1) )
420  pCut1->Fans[0] = Abc_LitNot(pCut1->Fans[0]);
421  if ( pCut2->nFans == 1 && (pCut2->fInv ^ fComplFanin2) )
422  pCut2->Fans[0] = Abc_LitNot(pCut2->Fans[0]);
423  }
424  }
425  Amap_ManCutSaveStored( p, pNode );
426  p->nCutsUsed += pNode->nCuts;
427  p->nCutsTried3 += pFanin0->nCuts * pFanin1->nCuts * pFanin2->nCuts;
428 
429 // Amap_ManPrintCuts( pNode );
430 }
431 
432 /**Function*************************************************************
433 
434  Synopsis [Derives cuts for one node.]
435 
436  Description []
437 
438  SideEffects []
439 
440  SeeAlso []
441 
442 ***********************************************************************/
443 void Amap_ManMergeNodeCuts( Amap_Man_t * p, Amap_Obj_t * pNode )
444 {
445  Amap_Obj_t * pFanin0 = Amap_ObjFanin0( p, pNode );
446  Amap_Obj_t * pFanin1 = Amap_ObjFanin1( p, pNode );
447  Amap_Cut_t * pCut0, * pCut1;
448  int ** pRules, Entry, i, k, c, iCompl0, iCompl1, iFan0, iFan1;
449  assert( pNode->pData == NULL );
450  if ( pNode->Type == AMAP_OBJ_MUX )
451  {
452  Amap_ManMergeNodeCutsMux( p, pNode );
453  return;
454  }
455  assert( pNode->Type != AMAP_OBJ_MUX );
456  pRules = (pNode->Type == AMAP_OBJ_AND)? p->pLib->pRules: p->pLib->pRulesX;
457  Amap_NodeForEachCut( pFanin0, pCut0, c )
458  {
459  iCompl0 = pCut0->fInv ^ Amap_ObjFaninC0(pNode);
460  iFan0 = !pCut0->iMat? 0: Abc_Var2Lit( pCut0->iMat, iCompl0 );
461  // complement literals
462  if ( pCut0->nFans == 1 && iCompl0 )
463  pCut0->Fans[0] = Abc_LitNot(pCut0->Fans[0]);
464  // label resulting sets
465  for ( i = 0; (Entry = pRules[iFan0][i]); i++ )
466  p->pMatsTemp[Entry & 0xffff] = (Entry >> 16);
467  // iterate through the cuts
468  Amap_NodeForEachCut( pFanin1, pCut1, k )
469  {
470  iCompl1 = pCut1->fInv ^ Amap_ObjFaninC1(pNode);
471  iFan1 = !pCut1->iMat? 0: Abc_Var2Lit( pCut1->iMat, iCompl1 );
472  if ( p->pMatsTemp[iFan1] == 0 )
473  continue;
474  // complement literals
475  if ( pCut1->nFans == 1 && iCompl1 )
476  pCut1->Fans[0] = Abc_LitNot(pCut1->Fans[0]);
477  // create new cut
478  if ( iFan0 >= iFan1 )
479  Amap_ManCutCreate( p, pCut0, pCut1, p->pMatsTemp[iFan1] );
480  else
481  Amap_ManCutCreate( p, pCut1, pCut0, p->pMatsTemp[iFan1] );
482  // uncomplement literals
483  if ( pCut1->nFans == 1 && iCompl1 )
484  pCut1->Fans[0] = Abc_LitNot(pCut1->Fans[0]);
485  }
486  // uncomplement literals
487  if ( pCut0->nFans == 1 && iCompl0 )
488  pCut0->Fans[0] = Abc_LitNot(pCut0->Fans[0]);
489  // label resulting sets
490  for ( i = 0; (Entry = pRules[iFan0][i]); i++ )
491  p->pMatsTemp[Entry & 0xffff] = 0;
492  }
493  Amap_ManCutSaveStored( p, pNode );
494  p->nCutsUsed += pNode->nCuts;
495  p->nCutsTried += pFanin0->nCuts * pFanin1->nCuts;
496 // assert( (int)pNode->nCuts == Amap_ManMergeCountCuts(p, pNode) );
497  if ( pNode->fRepr )
498  Amap_ManMergeNodeChoice( p, pNode );
499 
500 // Amap_ManPrintCuts( pNode );
501 }
502 
503 /**Function*************************************************************
504 
505  Synopsis [Derives cuts for all nodes.]
506 
507  Description []
508 
509  SideEffects []
510 
511  SeeAlso []
512 
513 ***********************************************************************/
514 void Amap_ManMerge( Amap_Man_t * p )
515 {
516  Amap_Obj_t * pObj;
517  int i;
518  abctime clk = Abc_Clock();
519  p->pCutsPi = Amap_ManSetupPis( p );
520  Amap_ManForEachNode( p, pObj, i )
521  Amap_ManMergeNodeCuts( p, pObj );
522  if ( p->pPars->fVerbose )
523  {
524  printf( "AIG object is %d bytes. ", (int)sizeof(Amap_Obj_t) );
525  printf( "Internal AIG = %5.2f MB. Cuts = %5.2f MB. CutsMax = %d.\n",
526  1.0*Amap_ManObjNum(p)*sizeof(Amap_Obj_t)/(1<<20), 1.0*p->nBytesUsed/(1<<20), p->pPars->nCutsMax );
527  printf( "Node =%6d. Try =%9d. Try3 =%10d. Used =%7d. R =%6.2f. ",
528  Amap_ManNodeNum(p), p->nCutsTried, p->nCutsTried3, p->nCutsUsed,
529  1.0*p->nCutsUsed/Amap_ManNodeNum(p) );
530 ABC_PRT( "Time ", Abc_Clock() - clk );
531  }
532 }
533 
534 
535 ////////////////////////////////////////////////////////////////////////
536 /// END OF FILE ///
537 ////////////////////////////////////////////////////////////////////////
538 
539 
540 ABC_NAMESPACE_IMPL_END
541 
Amap_ManMerge
void Amap_ManMerge(Amap_Man_t *p)
Definition: amapMerge.c:514
Vec_IntPushOrder
static void Vec_IntPushOrder(Vec_Int_t *p, int Entry)
Definition: vecInt.h:751
Amap_Man_t_::vTemp
Vec_Int_t * vTemp
Definition: amapInt.h:99
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition: vecPtr.h:42
Amap_ManMergeNodeCuts
void Amap_ManMergeNodeCuts(Amap_Man_t *p, Amap_Obj_t *pNode)
Definition: amapMerge.c:443
Amap_ObjFaninC2
static int Amap_ObjFaninC2(Amap_Obj_t *pObj)
Definition: amapInt.h:253
Amap_Obj_t_::EstRefs
float EstRefs
Definition: amapInt.h:216
Amap_ManPiNum
static int Amap_ManPiNum(Amap_Man_t *p)
Definition: amapInt.h:226
Aig_MmFlexRestart
void Aig_MmFlexRestart(Aig_MmFlex_t *p)
Definition: aigMem.c:411
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Amap_ManCutCreate3
Amap_Cut_t * Amap_ManCutCreate3(Amap_Man_t *p, Amap_Cut_t *pCut0, Amap_Cut_t *pCut1, Amap_Cut_t *pCut2, int iMat)
Definition: amapMerge.c:139
Amap_Man_t_::nCutsTried3
int nCutsTried3
Definition: amapInt.h:109
Amap_Man_t_::pMemCuts
Aig_MmFlex_t * pMemCuts
Definition: amapInt.h:90
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition: bblif.c:37
Amap_NodeForEachCut
#define Amap_NodeForEachCut(pNode, pCut, i)
Definition: amapInt.h:300
Amap_Man_t_::vCuts0
Vec_Ptr_t * vCuts0
Definition: amapInt.h:103
Amap_ObjFanin0
static Amap_Obj_t * Amap_ObjFanin0(Amap_Man_t *p, Amap_Obj_t *pObj)
Definition: amapInt.h:248
Abc_Var2Lit
static int Abc_Var2Lit(int Var, int fCompl)
Definition: abc_global.h:263
Aig_MmFlexEntryFetch
char * Aig_MmFlexEntryFetch(Aig_MmFlex_t *p, int nBytes)
Definition: aigMem.c:366
Amap_Obj_t_::Id
unsigned Id
Definition: amapInt.h:201
memcpy
char * memcpy()
Amap_Cut_t_
Definition: amapInt.h:183
Vec_PtrPush
static void Vec_PtrPush(Vec_Ptr_t *p, void *Entry)
Definition: vecPtr.h:606
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
Amap_ManCutStore
Amap_Cut_t * Amap_ManCutStore(Amap_Man_t *p, Amap_Cut_t *pCut, int fCompl)
Definition: amapMerge.c:76
Amap_Man_t_::nCutsUsed
int nCutsUsed
Definition: amapInt.h:107
Amap_ManForEachPi
#define Amap_ManForEachPi(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: amapInt.h:280
Abc_Clock
static abctime Abc_Clock()
Definition: abc_global.h:279
Vec_PtrSize
static int Vec_PtrSize(Vec_Ptr_t *p)
Definition: vecPtr.h:295
nWords
int nWords
Definition: abcNpn.c:127
Amap_ManForEachNode
#define Amap_ManForEachNode(p, pObj, i)
Definition: amapInt.h:289
Amap_Man_t_::ppCutsTemp
Amap_Cut_t ** ppCutsTemp
Definition: amapInt.h:101
Amap_Par_t_::fVerbose
int fVerbose
Definition: amap.h:55
Abc_MinInt
static int Abc_MinInt(int a, int b)
Definition: abc_global.h:239
Abc_LitIsCompl
static int Abc_LitIsCompl(int Lit)
Definition: abc_global.h:265
Amap_Obj_t_::pData
void * pData
Definition: amapInt.h:212
Amap_ManMergeNodeCutsMux
void Amap_ManMergeNodeCutsMux(Amap_Man_t *p, Amap_Obj_t *pNode)
Definition: amapMerge.c:377
Amap_Man_t_::pLib
Amap_Lib_t * pLib
Definition: amapInt.h:79
Amap_ManMergeNodeChoice
void Amap_ManMergeNodeChoice(Amap_Man_t *p, Amap_Obj_t *pNode)
Definition: amapMerge.c:319
Vec_IntEntry
static int Vec_IntEntry(Vec_Int_t *p, int i)
Definition: bblif.c:268
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
Amap_Obj_t_::nCuts
unsigned nCuts
Definition: amapInt.h:207
Amap_Obj_t_::Type
unsigned Type
Definition: amapInt.h:200
Amap_Obj_t_::fPhase
unsigned fPhase
Definition: amapInt.h:203
Amap_Man_t_
Definition: amapInt.h:75
Counter
static int Counter
Definition: extraBddMisc.c:1877
Amap_Cut_t_::fInv
unsigned fInv
Definition: amapInt.h:186
Amap_Man_t_::vCuts2
Vec_Ptr_t * vCuts2
Definition: amapInt.h:105
Amap_Man_t_::nBytesUsed
int nBytesUsed
Definition: amapInt.h:110
Amap_Obj_t_::fRepr
unsigned fRepr
Definition: amapInt.h:204
Amap_ObjChoice
static Amap_Obj_t * Amap_ObjChoice(Amap_Man_t *p, Amap_Obj_t *pObj)
Definition: amapInt.h:258
Amap_ManMergeCountCuts
int Amap_ManMergeCountCuts(Amap_Man_t *p, Amap_Obj_t *pNode)
Definition: amapMerge.c:254
Amap_ManNodeNum
static int Amap_ManNodeNum(Amap_Man_t *p)
Definition: amapInt.h:232
Amap_ManObjNum
static int Amap_ManObjNum(Amap_Man_t *p)
Definition: amapInt.h:231
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
Amap_ManFindCut
int Amap_ManFindCut(Amap_Obj_t *pNode, Amap_Obj_t *pFanin, int fComplFanin, int Val, Vec_Ptr_t *vCuts)
Definition: amapMerge.c:351
Amap_Cut_t_::nFans
unsigned nFans
Definition: amapInt.h:187
Abc_LitNot
static int Abc_LitNot(int Lit)
Definition: abc_global.h:266
Amap_ManCutSaveStored
void Amap_ManCutSaveStored(Amap_Man_t *p, Amap_Obj_t *pNode)
Definition: amapMerge.c:174
Amap_ObjFaninC1
static int Amap_ObjFaninC1(Amap_Obj_t *pObj)
Definition: amapInt.h:252
Vec_IntSize
static int Vec_IntSize(Vec_Int_t *p)
Definition: bblif.c:252
Amap_ObjFanin1
static Amap_Obj_t * Amap_ObjFanin1(Amap_Man_t *p, Amap_Obj_t *pObj)
Definition: amapInt.h:249
Amap_Nod_t_::pSets
Amap_Set_t * pSets
Definition: amapInt.h:181
Amap_Obj_t_
Definition: amapInt.h:198
Amap_Man_t_::nCutsTried
int nCutsTried
Definition: amapInt.h:108
Amap_ManSetupPis
ABC_NAMESPACE_IMPL_START Amap_Cut_t * Amap_ManSetupPis(Amap_Man_t *p)
DECLARATIONS ///.
Definition: amapMerge.c:45
Amap_Man_t_::pPars
Amap_Par_t * pPars
Definition: amapInt.h:78
Amap_Cut_t_::iMat
unsigned iMat
Definition: amapInt.h:185
ABC_PRT
#define ABC_PRT(a, t)
Definition: abc_global.h:220
Amap_Nod_t_
Definition: amapInt.h:172
Amap_Cut_t
struct Amap_Cut_t_ Amap_Cut_t
Definition: amapInt.h:72
Amap_ManPrintCuts
void Amap_ManPrintCuts(Amap_Obj_t *pNode)
Definition: amapMerge.c:287
Amap_Man_t_::pMatsTemp
int * pMatsTemp
Definition: amapInt.h:100
Abc_Lit2Var
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
Amap_ManCutCreate
Amap_Cut_t * Amap_ManCutCreate(Amap_Man_t *p, Amap_Cut_t *pCut0, Amap_Cut_t *pCut1, int iMat)
Definition: amapMerge.c:105
Amap_ObjFanin2
static Amap_Obj_t * Amap_ObjFanin2(Amap_Man_t *p, Amap_Obj_t *pObj)
Definition: amapInt.h:250
assert
#define assert(ex)
Definition: util_old.h:213
Vec_PtrClear
static void Vec_PtrClear(Vec_Ptr_t *p)
Definition: vecPtr.h:545
Amap_Man_t_::pMemTemp
Aig_MmFlex_t * pMemTemp
Definition: amapInt.h:92
Amap_ObjFaninC0
static int Amap_ObjFaninC0(Amap_Obj_t *pObj)
Definition: amapInt.h:251
Amap_Par_t_::nCutsMax
int nCutsMax
Definition: amap.h:49
Amap_LibFindNode
int Amap_LibFindNode(Amap_Lib_t *pLib, int iFan0, int iFan1, int fXor)
Definition: amapUniq.c:90
Amap_LibNod
static Amap_Nod_t * Amap_LibNod(Amap_Lib_t *p, int i)
Definition: amapInt.h:264
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition: vecPtr.h:55
Amap_Man_t_::vCuts1
Vec_Ptr_t * vCuts1
Definition: amapInt.h:104
Vec_IntClear
static void Vec_IntClear(Vec_Int_t *p)
Definition: bblif.c:452
abctime
ABC_INT64_T abctime
Definition: abc_global.h:278
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition: vecInt.h:54
Amap_Man_t_::pCutsPi
Amap_Cut_t * pCutsPi
Definition: amapInt.h:102
Amap_Cut_t_::Fans
int Fans[0]
Definition: amapInt.h:188
Amap_ManCutNextP
static Amap_Cut_t ** Amap_ManCutNextP(Amap_Cut_t *pCut)
Definition: amapInt.h:270