abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
saigSimFast.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [saigSimFast.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Sequential AIG package.]
8 
9  Synopsis [Fast sequential AIG simulator.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: saigSimFast.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "saig.h"
22 
23 #include "base/main/main.h"
24 
25 ABC_NAMESPACE_IMPL_START
26 
27 
28 ////////////////////////////////////////////////////////////////////////
29 /// DECLARATIONS ///
30 ////////////////////////////////////////////////////////////////////////
31 
32 // the AIG manager
33 typedef struct Faig_Man_t_ Faig_Man_t;
34 struct Faig_Man_t_
35 {
36  // parameters
37  int nPis;
38  int nPos;
39  int nCis;
40  int nCos;
41  int nFfs;
42  int nNos;
43  // offsets
44  int nPis1;
45  int nCis1;
46  int nCisNos1;
47  int nCisNosPos1;
48  int nObjs;
49  // allocated data
50  int nWords;
51  int pObjs[0];
52 };
53 
54 static inline int Faig_CheckIdPi( Faig_Man_t * p, int i ) { return i >= 1 && i < p->nPis1; }
55 static inline int Faig_CheckIdLo( Faig_Man_t * p, int i ) { return i >= p->nPis1 && i < p->nCis1; }
56 static inline int Faig_CheckIdNo( Faig_Man_t * p, int i ) { return i >= p->nCis1 && i < p->nCisNos1; }
57 static inline int Faig_CheckIdPo( Faig_Man_t * p, int i ) { return i >= p->nCisNos1 && i < p->nCisNosPos1; }
58 static inline int Faig_CheckIdLi( Faig_Man_t * p, int i ) { return i >= p->nCisNosPos1 && i < p->nObjs; }
59 static inline int Faig_CheckIdCo( Faig_Man_t * p, int i ) { return i >= p->nCisNos1 && i < p->nObjs; }
60 static inline int Faig_CheckIdObj( Faig_Man_t * p, int i ) { return i >= 0 && i < p->nObjs; }
61 
62 static inline int Faig_ObjIdToNumPi( Faig_Man_t * p, int i ) { assert( Faig_CheckIdPi(p,i) ); return i - 1; }
63 static inline int Faig_ObjIdToNumLo( Faig_Man_t * p, int i ) { assert( Faig_CheckIdLo(p,i) ); return i - p->nPis1; }
64 static inline int Faig_ObjIdToNumNo( Faig_Man_t * p, int i ) { assert( Faig_CheckIdNo(p,i) ); return i - p->nCis1; }
65 static inline int Faig_ObjIdToNumPo( Faig_Man_t * p, int i ) { assert( Faig_CheckIdPo(p,i) ); return i - p->nCisNos1; }
66 static inline int Faig_ObjIdToNumLi( Faig_Man_t * p, int i ) { assert( Faig_CheckIdLi(p,i) ); return i - p->nCisNosPos1; }
67 static inline int Faig_ObjIdToNumCo( Faig_Man_t * p, int i ) { assert( Faig_CheckIdCo(p,i) ); return i - p->nCisNos1; }
68 
69 static inline int Faig_ObjLoToLi( Faig_Man_t * p, int i ) { assert( Faig_CheckIdLo(p,i) ); return p->nObjs - (p->nCis1 - i); }
70 static inline int Faig_ObjLiToLo( Faig_Man_t * p, int i ) { assert( Faig_CheckIdLi(p,i) ); return p->nCis1 - (p->nObjs - i); }
71 
72 static inline int Faig_NodeChild0( Faig_Man_t * p, int n ) { return p->pObjs[n<<1]; }
73 static inline int Faig_NodeChild1( Faig_Man_t * p, int n ) { return p->pObjs[(n<<1)+1]; }
74 static inline int Faig_CoChild0( Faig_Man_t * p, int n ) { return p->pObjs[(p->nNos<<1)+n]; }
75 static inline int Faig_ObjFaninC( int iFan ) { return iFan & 1; }
76 static inline int Faig_ObjFanin( int iFan ) { return iFan >> 1; }
77 
78 ////////////////////////////////////////////////////////////////////////
79 /// FUNCTION DEFINITIONS ///
80 ////////////////////////////////////////////////////////////////////////
81 
82 /**Function*************************************************************
83 
84  Synopsis [Checks if the manager is correct.]
85 
86  Description []
87 
88  SideEffects []
89 
90  SeeAlso []
91 
92 ***********************************************************************/
93 int Faig_ManIsCorrect( Aig_Man_t * pAig )
94 {
95  return Aig_ManObjNumMax(pAig) ==
96  1 + Aig_ManCiNum(pAig) + Aig_ManNodeNum(pAig) + Aig_ManCoNum(pAig);
97 }
98 
99 /**Function*************************************************************
100 
101  Synopsis [Creates fast simulation manager.]
102 
103  Description []
104 
105  SideEffects []
106 
107  SeeAlso []
108 
109 ***********************************************************************/
110 Faig_Man_t * Faig_ManAlloc( Aig_Man_t * pAig )
111 {
112  Faig_Man_t * p;
113  int nWords;
114 // assert( Faig_ManIsCorrect(pAig) );
115  nWords = 2 * Aig_ManNodeNum(pAig) + Aig_ManCoNum(pAig);
116  p = (Faig_Man_t *)ABC_ALLOC( char, sizeof(Faig_Man_t) + sizeof(int) * nWords );
117 //printf( "Allocating %7.2f MB.\n", 1.0 * (sizeof(Faig_Man_t) + sizeof(int) * nWords)/(1<<20) );
118  memset( p, 0, sizeof(Faig_Man_t) );
119  p->nPis = Aig_ManCiNum(pAig) - Aig_ManRegNum(pAig);
120  p->nPos = Aig_ManCoNum(pAig) - Aig_ManRegNum(pAig);
121  p->nCis = Aig_ManCiNum(pAig);
122  p->nCos = Aig_ManCoNum(pAig);
123  p->nFfs = Aig_ManRegNum(pAig);
124  p->nNos = Aig_ManNodeNum(pAig);
125  // offsets
126  p->nPis1 = p->nPis + 1;
127  p->nCis1 = p->nCis + 1;
128  p->nCisNos1 = p->nCis + p->nNos + 1;
129  p->nCisNosPos1 = p->nCis + p->nNos + p->nPos + 1;
130  p->nObjs = p->nCis + p->nNos + p->nCos + 1;
131  p->nWords = nWords;
132  return p;
133 }
134 
135 /**Function*************************************************************
136 
137  Synopsis [Creates fast simulation manager.]
138 
139  Description []
140 
141  SideEffects []
142 
143  SeeAlso []
144 
145 ***********************************************************************/
146 Faig_Man_t * Faig_ManCreate( Aig_Man_t * pAig )
147 {
148  Faig_Man_t * p;
149  Aig_Obj_t * pObj;
150  int i, iWord = 0;
151  p = Faig_ManAlloc( pAig );
152  Aig_ManForEachNode( pAig, pObj, i )
153  {
154  p->pObjs[iWord++] = (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj);
155  p->pObjs[iWord++] = (Aig_ObjFaninId1(pObj) << 1) | Aig_ObjFaninC1(pObj);
156  }
157  Aig_ManForEachCo( pAig, pObj, i )
158  p->pObjs[iWord++] = (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj);
159  assert( iWord == p->nWords );
160  return p;
161 }
162 
163 /**Function*************************************************************
164 
165  Synopsis [Simulates one node.]
166 
167  Description []
168 
169  SideEffects []
170 
171  SeeAlso []
172 
173 ***********************************************************************/
174 static inline unsigned Faig_SimulateNode( Faig_Man_t * p, int Id, unsigned * pSimInfo )
175 {
176  int n = Faig_ObjIdToNumNo( p, Id );
177  int iFan0 = Faig_NodeChild0( p, n );
178  int iFan1 = Faig_NodeChild1( p, n );
179  if ( Faig_ObjFaninC(iFan0) && Faig_ObjFaninC(iFan1) )
180  return ~(pSimInfo[Faig_ObjFanin(iFan0)] | pSimInfo[Faig_ObjFanin(iFan1)]);
181  if ( Faig_ObjFaninC(iFan0) && !Faig_ObjFaninC(iFan1) )
182  return (~pSimInfo[Faig_ObjFanin(iFan0)] & pSimInfo[Faig_ObjFanin(iFan1)]);
183  if ( !Faig_ObjFaninC(iFan0) && Faig_ObjFaninC(iFan1) )
184  return (pSimInfo[Faig_ObjFanin(iFan0)] & ~pSimInfo[Faig_ObjFanin(iFan1)]);
185  // if ( !Faig_ObjFaninC(iFan0) && !Faig_ObjFaninC(iFan1) )
186  return (pSimInfo[Faig_ObjFanin(iFan0)] & pSimInfo[Faig_ObjFanin(iFan1)]);
187 }
188 
189 /**Function*************************************************************
190 
191  Synopsis [Simulates one node.]
192 
193  Description []
194 
195  SideEffects []
196 
197  SeeAlso []
198 
199 ***********************************************************************/
200 static inline unsigned Faig_SimulateCo( Faig_Man_t * p, int Id, unsigned * pSimInfo )
201 {
202  int n = Faig_ObjIdToNumCo( p, Id );
203  int iFan0 = Faig_CoChild0( p, n );
204  if ( Faig_ObjFaninC(iFan0) )
205  return ~pSimInfo[Faig_ObjFanin(iFan0)];
206  // if ( !Faig_ObjFaninC(iFan0) )
207  return pSimInfo[Faig_ObjFanin(iFan0)];
208 }
209 
210 /**Function*************************************************************
211 
212  Synopsis []
213 
214  Description []
215 
216  SideEffects []
217 
218  SeeAlso []
219 
220 ***********************************************************************/
221 static inline unsigned Faig_SimulateRandomShift( unsigned uOld )
222 {
223  return (uOld << 16) | ((uOld ^ Aig_ManRandom(0)) & 0xffff);
224 }
225 
226 /**Function*************************************************************
227 
228  Synopsis []
229 
230  Description []
231 
232  SideEffects []
233 
234  SeeAlso []
235 
236 ***********************************************************************/
237 static inline unsigned Faig_SimulateTransferShift( unsigned uOld, unsigned uNew )
238 {
239  return (uOld << 16) | (uNew & 0xffff);
240 }
241 
242 /**Function*************************************************************
243 
244  Synopsis [Simulates the timeframes.]
245 
246  Description []
247 
248  SideEffects []
249 
250  SeeAlso []
251 
252 ***********************************************************************/
253 int * Faig_ManSimulateFrames( Faig_Man_t * p, int nFrames, int nPref, int fTrans )
254 {
255  int * pNumOnes = ABC_CALLOC( int, p->nObjs );
256  unsigned * pSimInfo = ABC_ALLOC( unsigned, p->nObjs );
257  int f, i;
258 //printf( "Allocating %7.2f MB.\n", 1.0 * 4 * p->nObjs/(1<<20) );
259 //printf( "Allocating %7.2f MB.\n", 1.0 * 4 * p->nObjs/(1<<20) );
260  // set constant 1
261  pSimInfo[0] = ~0;
262  for ( f = 0; f < nFrames; f++ )
263  {
264  if ( fTrans )
265  {
266  for ( i = 1; i < p->nPis1; i++ )
267  pSimInfo[i] = f? Faig_SimulateRandomShift( pSimInfo[i] ) : Aig_ManRandom( 0 );
268  for ( ; i < p->nCis1; i++ )
269  pSimInfo[i] = f? Faig_SimulateTransferShift( pSimInfo[i], pSimInfo[Faig_ObjLoToLi(p,i)] ) : 0;
270  }
271  else
272  {
273  for ( i = 1; i < p->nPis1; i++ )
274  pSimInfo[i] = Aig_ManRandom( 0 );
275  for ( ; i < p->nCis1; i++ )
276  pSimInfo[i] = f? pSimInfo[Faig_ObjLoToLi(p,i)] : 0;
277  }
278  for ( ; i < p->nCisNos1; i++ )
279  pSimInfo[i] = Faig_SimulateNode( p, i, pSimInfo );
280  for ( ; i < p->nObjs; i++ )
281  pSimInfo[i] = Faig_SimulateCo( p, i, pSimInfo );
282  if ( f < nPref )
283  continue;
284  if ( fTrans )
285  {
286  for ( i = 0; i < p->nObjs; i++ )
287  pNumOnes[i] += Aig_WordCountOnes( (pSimInfo[i] ^ (pSimInfo[i] >> 16)) & 0xffff );
288  }
289  else
290  {
291  for ( i = 0; i < p->nObjs; i++ )
292  pNumOnes[i] += Aig_WordCountOnes( pSimInfo[i] );
293  }
294  }
295  ABC_FREE( pSimInfo );
296  return pNumOnes;
297 }
298 
299 /**Function*************************************************************
300 
301  Synopsis [Computes switching activity of one node.]
302 
303  Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ]
304 
305  SideEffects []
306 
307  SeeAlso []
308 
309 ***********************************************************************/
310 float Faig_ManComputeSwitching( int nOnes, int nSimWords )
311 {
312  int nTotal = 32 * nSimWords;
313  return (float)2.0 * nOnes / nTotal * (nTotal - nOnes) / nTotal;
314 }
315 
316 /**Function*************************************************************
317 
318  Synopsis [Computes switching activity of one node.]
319 
320  Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ]
321 
322  SideEffects []
323 
324  SeeAlso []
325 
326 ***********************************************************************/
327 float Faig_ManComputeProbOne( int nOnes, int nSimWords )
328 {
329  int nTotal = 32 * nSimWords;
330  return (float)nOnes / nTotal;
331 }
332 
333 /**Function*************************************************************
334 
335  Synopsis []
336 
337  Description []
338 
339  SideEffects []
340 
341  SeeAlso []
342 
343 ***********************************************************************/
344 Vec_Int_t * Faig_ManComputeSwitchProbs4( Aig_Man_t * p, int nFrames, int nPref, int fProbOne )
345 {
346  int fTrans = 1;
347  Faig_Man_t * pAig;
348  Vec_Int_t * vSwitching;
349  int * pProbs;
350  float * pSwitching;
351  int nFramesReal;
352  abctime clk;//, clkTotal = Abc_Clock();
353  if ( fProbOne )
354  fTrans = 0;
355  vSwitching = Vec_IntStart( Aig_ManObjNumMax(p) );
356  pSwitching = (float *)vSwitching->pArray;
357 clk = Abc_Clock();
358  pAig = Faig_ManCreate( p );
359 //ABC_PRT( "\nCreation ", Abc_Clock() - clk );
360  Aig_ManRandom( 1 );
361  // get the number of frames to simulate
362  // if the parameter "seqsimframes" is defined, use it
363  // otherwise, use the given number of frames "nFrames"
364  nFramesReal = nFrames;
365  if ( Abc_FrameReadFlag("seqsimframes") )
366  nFramesReal = atoi( Abc_FrameReadFlag("seqsimframes") );
367  if ( nFramesReal <= nPref )
368  {
369  printf( "The total number of frames (%d) should exceed prefix (%d).\n", nFramesReal, nPref );
370  printf( "Setting the total number of frames to be %d.\n", nFrames );
371  nFramesReal = nFrames;
372  }
373 //printf( "Simulating %d frames.\n", nFramesReal );
374 clk = Abc_Clock();
375  pProbs = Faig_ManSimulateFrames( pAig, nFramesReal, nPref, fTrans );
376 //ABC_PRT( "Simulation", Abc_Clock() - clk );
377 clk = Abc_Clock();
378  if ( fTrans )
379  {
380  Aig_Obj_t * pObj;
381  int i, Counter = 0;
382  pObj = Aig_ManConst1(p);
383  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], (nFramesReal - nPref)/2 );
384  Aig_ManForEachCi( p, pObj, i )
385  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], (nFramesReal - nPref)/2 );
386  Aig_ManForEachNode( p, pObj, i )
387  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], (nFramesReal - nPref)/2 );
388  Aig_ManForEachCo( p, pObj, i )
389  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], (nFramesReal - nPref)/2 );
390  assert( Counter == pAig->nObjs );
391  }
392  else if ( fProbOne )
393  {
394  Aig_Obj_t * pObj;
395  int i, Counter = 0;
396  pObj = Aig_ManConst1(p);
397  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], nFramesReal - nPref );
398  Aig_ManForEachCi( p, pObj, i )
399  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], nFramesReal - nPref );
400  Aig_ManForEachNode( p, pObj, i )
401  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], nFramesReal - nPref );
402  Aig_ManForEachCo( p, pObj, i )
403  pSwitching[pObj->Id] = Faig_ManComputeProbOne( pProbs[Counter++], nFramesReal - nPref );
404  assert( Counter == pAig->nObjs );
405  }
406  else
407  {
408  Aig_Obj_t * pObj;
409  int i, Counter = 0;
410  pObj = Aig_ManConst1(p);
411  pSwitching[pObj->Id] = Faig_ManComputeSwitching( pProbs[Counter++], nFramesReal - nPref );
412  Aig_ManForEachCi( p, pObj, i )
413  pSwitching[pObj->Id] = Faig_ManComputeSwitching( pProbs[Counter++], nFramesReal - nPref );
414  Aig_ManForEachNode( p, pObj, i )
415  pSwitching[pObj->Id] = Faig_ManComputeSwitching( pProbs[Counter++], nFramesReal - nPref );
416  Aig_ManForEachCo( p, pObj, i )
417  pSwitching[pObj->Id] = Faig_ManComputeSwitching( pProbs[Counter++], nFramesReal - nPref );
418  assert( Counter == pAig->nObjs );
419  }
420  ABC_FREE( pProbs );
421  ABC_FREE( pAig );
422 //ABC_PRT( "Switch ", Abc_Clock() - clk );
423 //ABC_PRT( "TOTAL ", Abc_Clock() - clkTotal );
424  return vSwitching;
425 }
426 
427 /**Function*************************************************************
428 
429  Synopsis [Computes probability of switching (or of being 1).]
430 
431  Description []
432 
433  SideEffects []
434 
435  SeeAlso []
436 
437 ***********************************************************************/
438 Vec_Int_t * Saig_ManComputeSwitchProb3s( Aig_Man_t * p, int nFrames, int nPref, int fProbOne )
439 {
440 // return Faig_ManComputeSwitchProbs( p, nFrames, nPref, fProbOne );
441  return NULL;
442 }
443 
444 
445 ////////////////////////////////////////////////////////////////////////
446 /// END OF FILE ///
447 ////////////////////////////////////////////////////////////////////////
448 
449 
450 ABC_NAMESPACE_IMPL_END
451 
memset
char * memset()
Faig_ManComputeSwitchProbs4
Vec_Int_t * Faig_ManComputeSwitchProbs4(Aig_Man_t *p, int nFrames, int nPref, int fProbOne)
Definition: saigSimFast.c:344
Faig_Man_t_::nCos
int nCos
Definition: saigSimFast.c:40
Aig_ObjFaninId0
static int Aig_ObjFaninId0(Aig_Obj_t *pObj)
Definition: aig.h:304
Faig_SimulateTransferShift
static unsigned Faig_SimulateTransferShift(unsigned uOld, unsigned uNew)
Definition: saigSimFast.c:237
Faig_Man_t_::nCisNosPos1
int nCisNosPos1
Definition: saigSimFast.c:47
Aig_Man_t
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Faig_ManComputeSwitching
float Faig_ManComputeSwitching(int nOnes, int nSimWords)
Definition: saigSimFast.c:310
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition: bblif.c:37
Faig_Man_t
typedefABC_NAMESPACE_IMPL_START struct Faig_Man_t_ Faig_Man_t
DECLARATIONS ///.
Definition: saigSimFast.c:33
Faig_ManIsCorrect
int Faig_ManIsCorrect(Aig_Man_t *pAig)
FUNCTION DEFINITIONS ///.
Definition: saigSimFast.c:93
Faig_CheckIdLo
static int Faig_CheckIdLo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:55
Faig_Man_t_::nCis
int nCis
Definition: saigSimFast.c:39
Saig_ManComputeSwitchProb3s
Vec_Int_t * Saig_ManComputeSwitchProb3s(Aig_Man_t *p, int nFrames, int nPref, int fProbOne)
Definition: saigSimFast.c:438
Faig_ManComputeProbOne
float Faig_ManComputeProbOne(int nOnes, int nSimWords)
Definition: saigSimFast.c:327
Faig_CheckIdObj
static int Faig_CheckIdObj(Faig_Man_t *p, int i)
Definition: saigSimFast.c:60
Faig_ObjLoToLi
static int Faig_ObjLoToLi(Faig_Man_t *p, int i)
Definition: saigSimFast.c:69
Aig_ManForEachCi
#define Aig_ManForEachCi(p, pObj, i)
ITERATORS ///.
Definition: aig.h:393
Faig_SimulateCo
static unsigned Faig_SimulateCo(Faig_Man_t *p, int Id, unsigned *pSimInfo)
Definition: saigSimFast.c:200
Aig_ManForEachCo
#define Aig_ManForEachCo(p, pObj, i)
Definition: aig.h:398
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
Faig_ObjLiToLo
static int Faig_ObjLiToLo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:70
Aig_ManRandom
unsigned Aig_ManRandom(int fReset)
Definition: aigUtil.c:1157
Abc_Clock
static abctime Abc_Clock()
Definition: abc_global.h:279
Aig_ObjFaninId1
static int Aig_ObjFaninId1(Aig_Obj_t *pObj)
Definition: aig.h:305
nWords
int nWords
Definition: abcNpn.c:127
Faig_ObjFaninC
static int Faig_ObjFaninC(int iFan)
Definition: saigSimFast.c:75
Aig_ManNodeNum
static int Aig_ManNodeNum(Aig_Man_t *p)
Definition: aig.h:256
Faig_CheckIdLi
static int Faig_CheckIdLi(Faig_Man_t *p, int i)
Definition: saigSimFast.c:58
Faig_ObjIdToNumLo
static int Faig_ObjIdToNumLo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:63
Aig_ManCoNum
static int Aig_ManCoNum(Aig_Man_t *p)
Definition: aig.h:252
Faig_ObjIdToNumCo
static int Faig_ObjIdToNumCo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:67
Vec_IntStart
static Vec_Int_t * Vec_IntStart(int nSize)
Definition: bblif.c:172
Aig_WordCountOnes
static int Aig_WordCountOnes(unsigned uWord)
Definition: aig.h:229
Aig_ManForEachNode
#define Aig_ManForEachNode(p, pObj, i)
Definition: aig.h:413
Faig_SimulateRandomShift
static unsigned Faig_SimulateRandomShift(unsigned uOld)
Definition: saigSimFast.c:221
Faig_Man_t_::nPis
int nPis
Definition: saigSimFast.c:37
Faig_NodeChild0
static int Faig_NodeChild0(Faig_Man_t *p, int n)
Definition: saigSimFast.c:72
Aig_ManCiNum
static int Aig_ManCiNum(Aig_Man_t *p)
Definition: aig.h:251
Faig_Man_t_::nPis1
int nPis1
Definition: saigSimFast.c:44
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
Faig_ObjIdToNumLi
static int Faig_ObjIdToNumLi(Faig_Man_t *p, int i)
Definition: saigSimFast.c:66
Faig_ManAlloc
Faig_Man_t * Faig_ManAlloc(Aig_Man_t *pAig)
Definition: saigSimFast.c:110
Aig_Obj_t_
Definition: aig.h:69
Counter
static int Counter
Definition: extraBddMisc.c:1877
Faig_CheckIdPo
static int Faig_CheckIdPo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:57
Faig_NodeChild1
static int Faig_NodeChild1(Faig_Man_t *p, int n)
Definition: saigSimFast.c:73
Faig_ObjIdToNumNo
static int Faig_ObjIdToNumNo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:64
Aig_ObjFaninC0
static int Aig_ObjFaninC0(Aig_Obj_t *pObj)
Definition: aig.h:306
Faig_Man_t_::pObjs
int pObjs[0]
Definition: saigSimFast.c:51
Aig_ManObjNumMax
static int Aig_ManObjNumMax(Aig_Man_t *p)
Definition: aig.h:259
Aig_ManConst1
static Aig_Obj_t * Aig_ManConst1(Aig_Man_t *p)
Definition: aig.h:264
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
Aig_ManRegNum
static int Aig_ManRegNum(Aig_Man_t *p)
Definition: aig.h:260
Faig_Man_t_::nWords
int nWords
Definition: saigSimFast.c:50
Faig_Man_t_::nObjs
int nObjs
Definition: saigSimFast.c:48
Faig_CheckIdNo
static int Faig_CheckIdNo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:56
Faig_Man_t_
Definition: saigSimFast.c:34
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
Faig_Man_t_::nCis1
int nCis1
Definition: saigSimFast.c:45
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Aig_ObjFaninC1
static int Aig_ObjFaninC1(Aig_Obj_t *pObj)
Definition: aig.h:307
assert
#define assert(ex)
Definition: util_old.h:213
Faig_Man_t_::nNos
int nNos
Definition: saigSimFast.c:42
Faig_ObjFanin
static int Faig_ObjFanin(int iFan)
Definition: saigSimFast.c:76
Abc_FrameReadFlag
ABC_DLL char * Abc_FrameReadFlag(char *pFlag)
Definition: mainFrame.c:64
Faig_CheckIdCo
static int Faig_CheckIdCo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:59
Faig_ObjIdToNumPo
static int Faig_ObjIdToNumPo(Faig_Man_t *p, int i)
Definition: saigSimFast.c:65
Faig_CoChild0
static int Faig_CoChild0(Faig_Man_t *p, int n)
Definition: saigSimFast.c:74
abctime
ABC_INT64_T abctime
Definition: abc_global.h:278
Faig_ManCreate
Faig_Man_t * Faig_ManCreate(Aig_Man_t *pAig)
Definition: saigSimFast.c:146
Aig_Obj_t_::Id
int Id
Definition: aig.h:85
Faig_ManSimulateFrames
int * Faig_ManSimulateFrames(Faig_Man_t *p, int nFrames, int nPref, int fTrans)
Definition: saigSimFast.c:253
Faig_CheckIdPi
static int Faig_CheckIdPi(Faig_Man_t *p, int i)
Definition: saigSimFast.c:54
Faig_Man_t_::nCisNos1
int nCisNos1
Definition: saigSimFast.c:46
nTotal
int nTotal
DECLARATIONS ///.
Definition: cutTruth.c:37
Faig_ObjIdToNumPi
static int Faig_ObjIdToNumPi(Faig_Man_t *p, int i)
Definition: saigSimFast.c:62
Faig_Man_t_::nPos
int nPos
Definition: saigSimFast.c:38
Faig_Man_t_::nFfs
int nFfs
Definition: saigSimFast.c:41
Faig_SimulateNode
static unsigned Faig_SimulateNode(Faig_Man_t *p, int Id, unsigned *pSimInfo)
Definition: saigSimFast.c:174