1 /**CFile****************************************************************
2
3 FileName [acbUtil.c]
4
5 SystemName [ABC: Logic synthesis and verification system.]
6
7 PackageName [Hierarchical word-level netlist.]
8
9 Synopsis [Various utilities.]
10
11 Author [Alan Mishchenko]
12
13 Affiliation [UC Berkeley]
14
15 Date [Ver. 1.0. Started - July 21, 2015.]
16
17 Revision [$Id: acbUtil.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
18
19 ***********************************************************************/
20
21 #include "acb.h"
22 #include "base/abc/abc.h"
23 #include "base/io/ioAbc.h"
24
25 ABC_NAMESPACE_IMPL_START
26
27 ////////////////////////////////////////////////////////////////////////
28 /// DECLARATIONS ///
29 ////////////////////////////////////////////////////////////////////////
30
31 ////////////////////////////////////////////////////////////////////////
32 /// FUNCTION DEFINITIONS ///
33 ////////////////////////////////////////////////////////////////////////
34
35 /**Function*************************************************************
36
37 Synopsis [Collecting TFI and TFO.]
38
39 Description []
40
41 SideEffects []
42
43 SeeAlso []
44
45 ***********************************************************************/
Acb_ObjCollectTfi_rec(Acb_Ntk_t * p,int iObj,int fTerm)46 void Acb_ObjCollectTfi_rec( Acb_Ntk_t * p, int iObj, int fTerm )
47 {
48 int * pFanin, iFanin, i;
49 if ( Acb_ObjSetTravIdCur(p, iObj) )
50 return;
51 if ( !fTerm && Acb_ObjIsCi(p, iObj) )
52 return;
53 Acb_ObjForEachFaninFast( p, iObj, pFanin, iFanin, i )
54 Acb_ObjCollectTfi_rec( p, iFanin, fTerm );
55 Vec_IntPush( &p->vArray0, iObj );
56 }
Acb_ObjCollectTfi(Acb_Ntk_t * p,int iObj,int fTerm)57 Vec_Int_t * Acb_ObjCollectTfi( Acb_Ntk_t * p, int iObj, int fTerm )
58 {
59 int i, Node;
60 Vec_IntClear( &p->vArray0 );
61 Acb_NtkIncTravId( p );
62 if ( iObj > 0 )
63 {
64 Vec_IntForEachEntry( &p->vSuppOld, Node, i )
65 Acb_ObjCollectTfi_rec( p, Node, fTerm );
66 Acb_ObjCollectTfi_rec( p, iObj, fTerm );
67 }
68 else
69 Acb_NtkForEachCo( p, iObj, i )
70 Acb_ObjCollectTfi_rec( p, iObj, fTerm );
71 return &p->vArray0;
72 }
73
Acb_ObjCollectTfo_rec(Acb_Ntk_t * p,int iObj,int fTerm)74 void Acb_ObjCollectTfo_rec( Acb_Ntk_t * p, int iObj, int fTerm )
75 {
76 int iFanout, i;
77 if ( Acb_ObjSetTravIdCur(p, iObj) )
78 return;
79 if ( !fTerm && Acb_ObjIsCo(p, iObj) )
80 return;
81 Acb_ObjForEachFanout( p, iObj, iFanout, i )
82 Acb_ObjCollectTfo_rec( p, iFanout, fTerm );
83 Vec_IntPush( &p->vArray1, iObj );
84 }
Acb_ObjCollectTfo(Acb_Ntk_t * p,int iObj,int fTerm)85 Vec_Int_t * Acb_ObjCollectTfo( Acb_Ntk_t * p, int iObj, int fTerm )
86 {
87 int i;
88 Vec_IntClear( &p->vArray1 );
89 Acb_NtkIncTravId( p );
90 if ( iObj > 0 )
91 Acb_ObjCollectTfo_rec( p, iObj, fTerm );
92 else
93 Acb_NtkForEachCi( p, iObj, i )
94 Acb_ObjCollectTfo_rec( p, iObj, fTerm );
95 return &p->vArray1;
96 }
97
98 /**Function*************************************************************
99
100 Synopsis [Computing and updating direct and reverse logic level.]
101
102 Description []
103
104 SideEffects []
105
106 SeeAlso []
107
108 ***********************************************************************/
Acb_ObjComputeLevelD(Acb_Ntk_t * p,int iObj)109 int Acb_ObjComputeLevelD( Acb_Ntk_t * p, int iObj )
110 {
111 int * pFanins, iFanin, k, Level = 0;
112 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
113 Level = Abc_MaxInt( Level, Acb_ObjLevelD(p, iFanin) );
114 return Acb_ObjSetLevelD( p, iObj, Level + !Acb_ObjIsCio(p, iObj) );
115 }
Acb_NtkComputeLevelD(Acb_Ntk_t * p,Vec_Int_t * vTfo)116 int Acb_NtkComputeLevelD( Acb_Ntk_t * p, Vec_Int_t * vTfo )
117 {
118 // it is assumed that vTfo contains CO nodes and level of new nodes was already updated
119 int i, iObj, Level = 0;
120 if ( !Acb_NtkHasObjLevelD( p ) )
121 Acb_NtkCleanObjLevelD( p );
122 Vec_IntForEachEntryReverse( vTfo, iObj, i )
123 Acb_ObjComputeLevelD( p, iObj );
124 Acb_NtkForEachCo( p, iObj, i )
125 Level = Abc_MaxInt( Level, Acb_ObjLevelD(p, iObj) );
126 p->LevelMax = Level;
127 return Level;
128 }
129
Acb_ObjComputeLevelR(Acb_Ntk_t * p,int iObj)130 int Acb_ObjComputeLevelR( Acb_Ntk_t * p, int iObj )
131 {
132 int iFanout, k, Level = 0;
133 Acb_ObjForEachFanout( p, iObj, iFanout, k )
134 Level = Abc_MaxInt( Level, Acb_ObjLevelR(p, iFanout) );
135 return Acb_ObjSetLevelR( p, iObj, Level + !Acb_ObjIsCio(p, iObj) );
136 }
Acb_NtkComputeLevelR(Acb_Ntk_t * p,Vec_Int_t * vTfi)137 int Acb_NtkComputeLevelR( Acb_Ntk_t * p, Vec_Int_t * vTfi )
138 {
139 // it is assumed that vTfi contains CI nodes
140 int i, iObj, Level = 0;
141 if ( !Acb_NtkHasObjLevelR( p ) )
142 Acb_NtkCleanObjLevelR( p );
143 Vec_IntForEachEntryReverse( vTfi, iObj, i )
144 Acb_ObjComputeLevelR( p, iObj );
145 Acb_NtkForEachCi( p, iObj, i )
146 Level = Abc_MaxInt( Level, Acb_ObjLevelR(p, iObj) );
147 // assert( p->LevelMax == Level );
148 p->LevelMax = Level;
149 return Level;
150 }
151
Acb_NtkUpdateLevelD(Acb_Ntk_t * p,int Pivot)152 void Acb_NtkUpdateLevelD( Acb_Ntk_t * p, int Pivot )
153 {
154 Vec_Int_t * vTfo = Acb_ObjCollectTfo( p, Pivot, 1 );
155 Acb_NtkComputeLevelD( p, vTfo );
156 }
157
158 /**Function*************************************************************
159
160 Synopsis [Computing and updating direct and reverse path count.]
161
162 Description []
163
164 SideEffects []
165
166 SeeAlso []
167
168 ***********************************************************************/
Acb_ObjSlack(Acb_Ntk_t * p,int iObj)169 int Acb_ObjSlack( Acb_Ntk_t * p, int iObj )
170 {
171 int LevelSum = Acb_ObjLevelD(p, iObj) + Acb_ObjLevelR(p, iObj);
172 assert( !Acb_ObjIsCio(p, iObj) + p->LevelMax >= LevelSum );
173 return !Acb_ObjIsCio(p, iObj) + p->LevelMax - LevelSum;
174 }
175
Acb_ObjComputePathD(Acb_Ntk_t * p,int iObj)176 int Acb_ObjComputePathD( Acb_Ntk_t * p, int iObj )
177 {
178 int * pFanins, iFanin, k, Path = 0;
179 assert( !Acb_ObjIsCi(p, iObj) );
180 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
181 if ( !Acb_ObjSlack(p, iFanin) )
182 Path += Acb_ObjPathD(p, iFanin);
183 return Acb_ObjSetPathD( p, iObj, Path );
184 }
Acb_NtkComputePathsD(Acb_Ntk_t * p,Vec_Int_t * vTfo,int fReverse)185 int Acb_NtkComputePathsD( Acb_Ntk_t * p, Vec_Int_t * vTfo, int fReverse )
186 {
187 int i, iObj, Path = 0;
188 //Vec_IntPrint( vTfo );
189 if ( !Acb_NtkHasObjPathD( p ) )
190 Acb_NtkCleanObjPathD( p );
191 // it is assumed that vTfo contains CI nodes
192 //assert( Acb_ObjSlack(p, Vec_IntEntry(vTfo, 0)) );
193 if ( fReverse )
194 {
195 Vec_IntForEachEntryReverse( vTfo, iObj, i )
196 {
197 if ( Acb_ObjIsCi(p, iObj) )
198 Acb_ObjSetPathD( p, iObj, Acb_ObjSlack(p, iObj) == 0 );
199 else if ( Acb_ObjSlack(p, iObj) )
200 Acb_ObjSetPathD( p, iObj, 0 );
201 else
202 Acb_ObjComputePathD( p, iObj );
203 }
204 }
205 else
206 {
207 Vec_IntForEachEntry( vTfo, iObj, i )
208 {
209 if ( Acb_ObjIsCi(p, iObj) )
210 Acb_ObjSetPathD( p, iObj, Acb_ObjSlack(p, iObj) == 0 );
211 else if ( Acb_ObjSlack(p, iObj) )
212 Acb_ObjSetPathD( p, iObj, 0 );
213 else
214 Acb_ObjComputePathD( p, iObj );
215 }
216 }
217 Acb_NtkForEachCo( p, iObj, i )
218 Path += Acb_ObjPathD(p, iObj);
219 p->nPaths = Path;
220 return Path;
221 }
222
Acb_ObjComputePathR(Acb_Ntk_t * p,int iObj)223 int Acb_ObjComputePathR( Acb_Ntk_t * p, int iObj )
224 {
225 int iFanout, k, Path = 0;
226 assert( !Acb_ObjIsCo(p, iObj) );
227 Acb_ObjForEachFanout( p, iObj, iFanout, k )
228 if ( !Acb_ObjSlack(p, iFanout) )
229 Path += Acb_ObjPathR(p, iFanout);
230 return Acb_ObjSetPathR( p, iObj, Path );
231 }
Acb_NtkComputePathsR(Acb_Ntk_t * p,Vec_Int_t * vTfi,int fReverse)232 int Acb_NtkComputePathsR( Acb_Ntk_t * p, Vec_Int_t * vTfi, int fReverse )
233 {
234 int i, iObj, Path = 0;
235 if ( !Acb_NtkHasObjPathR( p ) )
236 Acb_NtkCleanObjPathR( p );
237 // it is assumed that vTfi contains CO nodes
238 //assert( Acb_ObjSlack(p, Vec_IntEntry(vTfi, 0)) );
239 if ( fReverse )
240 {
241 Vec_IntForEachEntryReverse( vTfi, iObj, i )
242 {
243 if ( Acb_ObjIsCo(p, iObj) )
244 Acb_ObjSetPathR( p, iObj, Acb_ObjSlack(p, iObj) == 0 );
245 else if ( Acb_ObjSlack(p, iObj) )
246 Acb_ObjSetPathR( p, iObj, 0 );
247 else
248 Acb_ObjComputePathR( p, iObj );
249 }
250 }
251 else
252 {
253 Vec_IntForEachEntry( vTfi, iObj, i )
254 {
255 if ( Acb_ObjIsCo(p, iObj) )
256 Acb_ObjSetPathR( p, iObj, Acb_ObjSlack(p, iObj) == 0 );
257 else if ( Acb_ObjSlack(p, iObj) )
258 Acb_ObjSetPathR( p, iObj, 0 );
259 else
260 Acb_ObjComputePathR( p, iObj );
261 }
262 }
263 Acb_NtkForEachCi( p, iObj, i )
264 Path += Acb_ObjPathR(p, iObj);
265 // assert( p->nPaths == Path );
266 p->nPaths = Path;
267 return Path;
268 }
269
Acb_NtkPrintPaths(Acb_Ntk_t * p)270 void Acb_NtkPrintPaths( Acb_Ntk_t * p )
271 {
272 int iObj;
273 Acb_NtkForEachObj( p, iObj )
274 {
275 printf( "Obj = %5d : ", iObj );
276 printf( "LevelD = %5d ", Acb_ObjLevelD(p, iObj) );
277 printf( "LevelR = %5d ", Acb_ObjLevelR(p, iObj) );
278 printf( "PathD = %5d ", Acb_ObjPathD(p, iObj) );
279 printf( "PathR = %5d ", Acb_ObjPathR(p, iObj) );
280 printf( "Paths = %5d ", Acb_ObjPathD(p, iObj) * Acb_ObjPathR(p, iObj) );
281 printf( "\n" );
282 }
283 }
284
Acb_NtkComputePaths(Acb_Ntk_t * p)285 int Acb_NtkComputePaths( Acb_Ntk_t * p )
286 {
287 int LevelD, LevelR;
288 Vec_Int_t * vTfi = Acb_ObjCollectTfi( p, -1, 1 );
289 Vec_Int_t * vTfo = Acb_ObjCollectTfo( p, -1, 1 );
290 Acb_NtkComputeLevelD( p, vTfo );
291 LevelD = p->LevelMax;
292 Acb_NtkComputeLevelR( p, vTfi );
293 LevelR = p->LevelMax;
294 assert( LevelD == LevelR );
295 Acb_NtkComputePathsD( p, vTfo, 1 );
296 Acb_NtkComputePathsR( p, vTfi, 1 );
297 return p->nPaths;
298 }
Abc_NtkComputePaths(Abc_Ntk_t * p)299 void Abc_NtkComputePaths( Abc_Ntk_t * p )
300 {
301 extern Acb_Ntk_t * Acb_NtkFromAbc( Abc_Ntk_t * p );
302 Acb_Ntk_t * pNtk = Acb_NtkFromAbc( p );
303 Acb_NtkCreateFanout( pNtk );
304 Acb_NtkCleanObjCounts( pNtk );
305 printf( "Computed %d paths.\n", Acb_NtkComputePaths(pNtk) );
306 Acb_NtkPrintPaths( pNtk );
307 Acb_ManFree( pNtk->pDesign );
308 }
309
310
311 /**Function*************************************************************
312
313 Synopsis []
314
315 Description []
316
317 SideEffects []
318
319 SeeAlso []
320
321 ***********************************************************************/
Acb_ObjUpdatePriority(Acb_Ntk_t * p,int iObj)322 void Acb_ObjUpdatePriority( Acb_Ntk_t * p, int iObj )
323 {
324 int nPaths;
325 if ( Acb_ObjIsCio(p, iObj) || Acb_ObjLevelD(p, iObj) == 1 )
326 return;
327 if ( p->vQue == NULL )
328 {
329 Acb_NtkCleanObjCounts( p );
330 p->vQue = Vec_QueAlloc( 1000 );
331 Vec_QueSetPriority( p->vQue, Vec_FltArrayP(&p->vCounts) );
332 }
333 nPaths = Acb_ObjPathD(p, iObj) * Acb_ObjPathR(p, iObj);
334 Acb_ObjSetCounts( p, iObj, (float)nPaths );
335 if ( Vec_QueIsMember( p->vQue, iObj ) )
336 {
337 //printf( "Updating object %d with count %d\n", iObj, nPaths );
338 Vec_QueUpdate( p->vQue, iObj );
339 }
340 else if ( nPaths )
341 {
342 //printf( "Adding object %d with count %d\n", iObj, nPaths );
343 Vec_QuePush( p->vQue, iObj );
344 }
345 }
Acb_NtkUpdateTiming(Acb_Ntk_t * p,int iObj)346 void Acb_NtkUpdateTiming( Acb_Ntk_t * p, int iObj )
347 {
348 int i, Entry, LevelMax = p->LevelMax;
349 int LevelD, LevelR, nPaths1, nPaths2;
350 // assuming that direct level of the new nodes (including iObj) is up to date
351 Vec_Int_t * vTfi = Acb_ObjCollectTfi( p, iObj, 1 );
352 Vec_Int_t * vTfo = Acb_ObjCollectTfo( p, iObj, 1 );
353 if ( iObj > 0 )
354 {
355 assert( Vec_IntEntryLast(vTfi) == iObj );
356 assert( Vec_IntEntryLast(vTfo) == iObj );
357 Vec_IntPop( vTfo );
358 }
359 Acb_NtkComputeLevelD( p, vTfo );
360 LevelD = p->LevelMax;
361 Acb_NtkComputeLevelR( p, vTfi );
362 LevelR = p->LevelMax;
363 assert( LevelD == LevelR );
364 if ( iObj > 0 && LevelMax > p->LevelMax ) // reduced level
365 {
366 iObj = -1;
367 vTfi = Acb_ObjCollectTfi( p, -1, 1 );
368 vTfo = Acb_ObjCollectTfo( p, -1, 1 );
369 Vec_QueClear( p->vQue );
370 // add backup here
371 }
372 if ( iObj > 0 )
373 Acb_NtkComputePathsD( p, vTfi, 0 );
374 Acb_NtkComputePathsD( p, vTfo, 1 );
375 nPaths1 = p->nPaths;
376 if ( iObj > 0 )
377 Acb_NtkComputePathsR( p, vTfo, 0 );
378 Acb_NtkComputePathsR( p, vTfi, 1 );
379 nPaths2 = p->nPaths;
380 assert( nPaths1 == nPaths2 );
381 Vec_IntForEachEntry( vTfi, Entry, i )
382 Acb_ObjUpdatePriority( p, Entry );
383 if ( iObj > 0 )
384 Vec_IntForEachEntry( vTfo, Entry, i )
385 Acb_ObjUpdatePriority( p, Entry );
386
387 // printf( "Updating timing for object %d.\n", iObj );
388 // Acb_NtkPrintPaths( p );
389 // while ( (Entry = (int)Vec_QueTopPriority(p->vQue)) > 0 )
390 // printf( "Obj = %5d : Prio = %d.\n", Vec_QuePop(p->vQue), Entry );
391 }
392
393 /**Function*************************************************************
394
395 Synopsis []
396
397 Description []
398
399 SideEffects []
400
401 SeeAlso []
402
403 ***********************************************************************/
Acb_NtkPrintNode(Acb_Ntk_t * p,int iObj)404 void Acb_NtkPrintNode( Acb_Ntk_t * p, int iObj )
405 {
406 int k, iFanin, * pFanins;
407 printf( "Node %5d : ", iObj );
408 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
409 printf( "%d ", iFanin );
410 printf( "LevelD = %d. LevelR = %d.\n", Acb_ObjLevelD(p, iObj), Acb_ObjLevelR(p, iObj) );
411 }
Acb_NtkCreateNode(Acb_Ntk_t * p,word uTruth,Vec_Int_t * vSupp)412 int Acb_NtkCreateNode( Acb_Ntk_t * p, word uTruth, Vec_Int_t * vSupp )
413 {
414 int Pivot = Acb_ObjAlloc( p, ABC_OPER_LUT, Vec_IntSize(vSupp), 0 );
415 Acb_ObjSetTruth( p, Pivot, uTruth );
416 Acb_ObjAddFanins( p, Pivot, vSupp );
417 Acb_ObjAddFaninFanout( p, Pivot );
418 Acb_ObjComputeLevelD( p, Pivot );
419 return Pivot;
420 }
Acb_NtkResetNode(Acb_Ntk_t * p,int Pivot,word uTruth,Vec_Int_t * vSupp)421 void Acb_NtkResetNode( Acb_Ntk_t * p, int Pivot, word uTruth, Vec_Int_t * vSupp )
422 {
423 // remember old fanins
424 int k, iFanin, * pFanins;
425 Vec_Int_t * vFanins = Vec_IntAlloc( 6 );
426 assert( !Acb_ObjIsCio(p, Pivot) );
427 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
428 Vec_IntPush( vFanins, iFanin );
429 // update function
430 Vec_WrdSetEntry( &p->vObjTruth, Pivot, uTruth );
431 Vec_IntErase( Vec_WecEntry(&p->vCnfs, Pivot) );
432 // remove old fanins
433 Acb_ObjRemoveFaninFanout( p, Pivot );
434 Acb_ObjRemoveFanins( p, Pivot );
435 // add new fanins
436 if ( vSupp != NULL )
437 {
438 assert( Acb_ObjFanoutNum(p, Pivot) > 0 );
439 Acb_ObjAddFanins( p, Pivot, vSupp );
440 Acb_ObjAddFaninFanout( p, Pivot );
441 }
442 else if ( Acb_ObjFanoutNum(p, Pivot) == 0 )
443 Acb_ObjCleanType( p, Pivot );
444 // delete dangling fanins
445 Vec_IntForEachEntry( vFanins, iFanin, k )
446 if ( !Acb_ObjIsCio(p, iFanin) && Acb_ObjFanoutNum(p, iFanin) == 0 )
447 Acb_NtkResetNode( p, iFanin, 0, NULL );
448 Vec_IntFree( vFanins );
449 }
Acb_NtkSaveSupport(Acb_Ntk_t * p,int iObj)450 void Acb_NtkSaveSupport( Acb_Ntk_t * p, int iObj )
451 {
452 int k, iFanin, * pFanins;
453 Vec_IntClear( &p->vSuppOld );
454 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
455 Vec_IntPush( &p->vSuppOld, iFanin );
456 }
Acb_NtkUpdateNode(Acb_Ntk_t * p,int Pivot,word uTruth,Vec_Int_t * vSupp)457 void Acb_NtkUpdateNode( Acb_Ntk_t * p, int Pivot, word uTruth, Vec_Int_t * vSupp )
458 {
459 //int Level = Acb_ObjLevelD(p, Pivot);
460 Acb_NtkSaveSupport( p, Pivot );
461 //Acb_NtkPrintNode( p, Pivot );
462 Acb_NtkResetNode( p, Pivot, uTruth, vSupp );
463 Acb_ObjComputeLevelD( p, Pivot );
464 //assert( Level > Acb_ObjLevelD(p, Pivot) );
465 //Acb_NtkPrintNode( p, Pivot );
466 if ( p->vQue == NULL )
467 Acb_NtkUpdateLevelD( p, Pivot );
468 else
469 // Acb_NtkUpdateTiming( p, Pivot );
470 Acb_NtkUpdateTiming( p, -1 );
471 Vec_IntClear( &p->vSuppOld );
472 }
473
474 /**Function*************************************************************
475
476 Synopsis [Derive AIG for one network.]
477
478 Description []
479
480 SideEffects []
481
482 SeeAlso []
483
484 ***********************************************************************/
Acb_NtkFindNodes2_rec(Acb_Ntk_t * p,int iObj,Vec_Int_t * vNodes)485 void Acb_NtkFindNodes2_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vNodes )
486 {
487 int * pFanin, iFanin, i;
488 if ( Acb_ObjSetTravIdCur(p, iObj) )
489 return;
490 if ( Acb_ObjIsCi(p, iObj) )
491 return;
492 Acb_ObjForEachFaninFast( p, iObj, pFanin, iFanin, i )
493 Acb_NtkFindNodes2_rec( p, iFanin, vNodes );
494 assert( !Acb_ObjIsCo(p, iObj) );
495 Vec_IntPush( vNodes, iObj );
496 }
Acb_NtkFindNodes2(Acb_Ntk_t * p)497 Vec_Int_t * Acb_NtkFindNodes2( Acb_Ntk_t * p )
498 {
499 int i, iObj;
500 Vec_Int_t * vNodes = Vec_IntAlloc( 1000 );
501 Acb_NtkIncTravId( p );
502 Acb_NtkForEachCo( p, iObj, i )
503 Acb_NtkFindNodes2_rec( p, Acb_ObjFanin(p, iObj, 0), vNodes );
504 return vNodes;
505 }
Acb_ObjToGia2(Gia_Man_t * pNew,Acb_Ntk_t * p,int iObj,Vec_Int_t * vTemp,int fUseXors)506 int Acb_ObjToGia2( Gia_Man_t * pNew, Acb_Ntk_t * p, int iObj, Vec_Int_t * vTemp, int fUseXors )
507 {
508 //char * pName = Abc_NamStr( p->pDesign->pStrs, Acb_ObjName(p, iObj) );
509 int * pFanin, iFanin, k, Type, Res;
510 assert( !Acb_ObjIsCio(p, iObj) );
511 Vec_IntClear( vTemp );
512 Acb_ObjForEachFaninFast( p, iObj, pFanin, iFanin, k )
513 {
514 assert( Acb_ObjCopy(p, iFanin) >= 0 );
515 Vec_IntPush( vTemp, Acb_ObjCopy(p, iFanin) );
516 }
517 Type = Acb_ObjType( p, iObj );
518 if ( Type == ABC_OPER_CONST_F )
519 return 0;
520 if ( Type == ABC_OPER_CONST_T )
521 return 1;
522 if ( Type == ABC_OPER_BIT_BUF || Type == ABC_OPER_BIT_INV )
523 {
524 Res = fUseXors ? Gia_ManAppendBuf(pNew, Vec_IntEntry(vTemp, 0)) : Vec_IntEntry(vTemp, 0);
525 //Res = Vec_IntEntry(vTemp, 0);
526 return Abc_LitNotCond( Res, Type == ABC_OPER_BIT_INV );
527 }
528 if ( Type == ABC_OPER_BIT_AND || Type == ABC_OPER_BIT_NAND )
529 {
530 Res = 1;
531 Vec_IntForEachEntry( vTemp, iFanin, k )
532 Res = Gia_ManAppendAnd2( pNew, Res, iFanin );
533 return Abc_LitNotCond( Res, Type == ABC_OPER_BIT_NAND );
534 }
535 if ( Type == ABC_OPER_BIT_OR || Type == ABC_OPER_BIT_NOR )
536 {
537 Res = 0;
538 Vec_IntForEachEntry( vTemp, iFanin, k )
539 Res = Gia_ManAppendOr2( pNew, Res, iFanin );
540 return Abc_LitNotCond( Res, Type == ABC_OPER_BIT_NOR );
541 }
542 if ( Type == ABC_OPER_BIT_XOR || Type == ABC_OPER_BIT_NXOR )
543 {
544 Res = 0;
545 Vec_IntForEachEntry( vTemp, iFanin, k )
546 Res = fUseXors ? Gia_ManAppendXorReal2(pNew, Res, iFanin) : Gia_ManAppendXor2(pNew, Res, iFanin);
547 return Abc_LitNotCond( Res, Type == ABC_OPER_BIT_NXOR );
548 }
549 assert( 0 );
550 return -1;
551 }
Acb_NtkToGia2(Acb_Ntk_t * p,int fUseXors,Vec_Int_t * vTargets,int nTargets)552 Gia_Man_t * Acb_NtkToGia2( Acb_Ntk_t * p, int fUseXors, Vec_Int_t * vTargets, int nTargets )
553 {
554 Gia_Man_t * pNew, * pOne;
555 Vec_Int_t * vFanins, * vNodes;
556 int i, iObj;
557 pNew = Gia_ManStart( 2 * Acb_NtkObjNum(p) + 1000 );
558 pNew->pName = Abc_UtilStrsav(Acb_NtkName(p));
559 Acb_NtkCleanObjCopies( p );
560 Acb_NtkForEachCi( p, iObj, i )
561 Acb_ObjSetCopy( p, iObj, Gia_ManAppendCi(pNew) );
562 if ( vTargets )
563 Vec_IntForEachEntry( vTargets, iObj, i )
564 Acb_ObjSetCopy( p, iObj, Gia_ManAppendCi(pNew) );
565 else
566 for ( i = 0; i < nTargets; i++ )
567 Gia_ManAppendCi(pNew);
568 vFanins = Vec_IntAlloc( 4 );
569 vNodes = Acb_NtkFindNodes2( p );
570 Vec_IntForEachEntry( vNodes, iObj, i )
571 if ( Acb_ObjCopy(p, iObj) == -1 ) // skip targets assigned above
572 Acb_ObjSetCopy( p, iObj, Acb_ObjToGia2(pNew, p, iObj, vFanins, fUseXors) );
573 Vec_IntFree( vNodes );
574 Vec_IntFree( vFanins );
575 Acb_NtkForEachCo( p, iObj, i )
576 Gia_ManAppendCo( pNew, Acb_ObjCopy(p, Acb_ObjFanin(p, iObj, 0)) );
577 pNew = Gia_ManCleanup( pOne = pNew );
578 Gia_ManUpdateCopy( &p->vObjCopy, pOne );
579 Gia_ManStop( pOne );
580 return pNew;
581 }
582
583 /**Function*************************************************************
584
585 Synopsis []
586
587 Description []
588
589 SideEffects []
590
591 SeeAlso []
592
593 ***********************************************************************/
Acb_NtkCollectCopies(Acb_Ntk_t * p,Gia_Man_t * pGia,Vec_Ptr_t ** pvNodesR,Vec_Bit_t ** pvPolar)594 Vec_Int_t * Acb_NtkCollectCopies( Acb_Ntk_t * p, Gia_Man_t * pGia, Vec_Ptr_t ** pvNodesR, Vec_Bit_t ** pvPolar )
595 {
596 int i, iObj, iLit, nTargets = Vec_IntSize(&p->vTargets);
597 Vec_Int_t * vObjs = Acb_NtkFindNodes2( p );
598 Vec_Int_t * vNodes = Vec_IntAlloc( Acb_NtkObjNum(p) );
599 Vec_Ptr_t * vNodesR = Vec_PtrStart( Gia_ManObjNum(pGia) );
600 Vec_Bit_t * vDriver = Vec_BitStart( Gia_ManObjNum(pGia) );
601 Vec_Bit_t * vPolar = Vec_BitStart( Gia_ManObjNum(pGia) );
602 Gia_ManForEachCiId( pGia, iObj, i )
603 if ( i < Gia_ManCiNum(pGia) - nTargets )
604 Vec_PtrWriteEntry( vNodesR, iObj, Abc_UtilStrsav(Acb_ObjNameStr(p, Acb_NtkCi(p, i))) );
605 else
606 Vec_PtrWriteEntry( vNodesR, iObj, Abc_UtilStrsav(Acb_ObjNameStr(p, Vec_IntEntry(&p->vTargets, i-(Gia_ManCiNum(pGia) - nTargets)))) );
607 Gia_ManForEachCoId( pGia, iObj, i )
608 {
609 Vec_BitWriteEntry( vDriver, Gia_ObjFaninId0(Gia_ManObj(pGia, iObj), iObj), 1 );
610 Vec_PtrWriteEntry( vNodesR, iObj, Abc_UtilStrsav(Acb_ObjNameStr(p, Acb_NtkCo(p, i))) );
611 Vec_IntPush( vNodes, iObj );
612 }
613 Vec_IntForEachEntry( vObjs, iObj, i )
614 if ( (iLit = Acb_ObjCopy(p, iObj)) >= 0 && Gia_ObjIsAnd(Gia_ManObj(pGia, Abc_Lit2Var(iLit))) )
615 {
616 if ( !Vec_BitEntry(vDriver, Abc_Lit2Var(iLit)) && Vec_PtrEntry(vNodesR, Abc_Lit2Var(iLit)) == NULL )
617 {
618 Vec_PtrWriteEntry( vNodesR, Abc_Lit2Var(iLit), Abc_UtilStrsav(Acb_ObjNameStr(p, iObj)) );
619 Vec_IntPush( vNodes, Abc_Lit2Var(iLit) );
620 Vec_BitWriteEntry( vPolar, Abc_Lit2Var(iLit), Abc_LitIsCompl(iLit) );
621 }
622 }
623 Vec_BitFree( vDriver );
624 Vec_IntFree( vObjs );
625 Vec_IntSort( vNodes, 0 );
626 *pvNodesR = vNodesR;
627 *pvPolar = vPolar;
628 return vNodes;
629 }
Acb_NtkCollectUser(Acb_Ntk_t * p,Vec_Ptr_t * vUser)630 Vec_Int_t * Acb_NtkCollectUser( Acb_Ntk_t * p, Vec_Ptr_t * vUser )
631 {
632 char * pTemp; int i;
633 Vec_Int_t * vRes = Vec_IntAlloc( Vec_PtrSize(vUser) );
634 Vec_Int_t * vMap = Vec_IntStart( Abc_NamObjNumMax(Acb_NtkNam(p)) );
635 Acb_NtkForEachNode( p, i )
636 if ( Acb_ObjName(p, i) > 0 )
637 Vec_IntWriteEntry( vMap, Acb_ObjName(p, i), Acb_ObjCopy(p, i) );
638 Vec_PtrForEachEntry( char *, vUser, pTemp, i )
639 if ( Acb_NtkStrId(p, pTemp) < Vec_IntSize(vMap) )
640 {
641 int iLit = Vec_IntEntry( vMap, Acb_NtkStrId(p, pTemp) );
642 assert( iLit > 0 );
643 //printf( "Obj = %3d Name = %3d Copy = %3d\n", i, Acb_NtkStrId(p, pTemp), iLit );
644 Vec_IntPush( vRes, Abc_Lit2Var(iLit) );
645 }
646 assert( Vec_IntSize(vRes) == Vec_PtrSize(vUser) );
647 Vec_IntFree( vMap );
648 Vec_IntUniqify( vRes );
649 return vRes;
650 }
651
652 /**Function*************************************************************
653
654 Synopsis []
655
656 Description []
657
658 SideEffects []
659
660 SeeAlso []
661
662 ***********************************************************************/
Acb_NtkExtract(char * pFileName0,char * pFileName1,int fUseXors,int fVerbose,Gia_Man_t ** ppGiaF,Gia_Man_t ** ppGiaG,Vec_Int_t ** pvNodes,Vec_Ptr_t ** pvNodesR,Vec_Bit_t ** pvPolar)663 int Acb_NtkExtract( char * pFileName0, char * pFileName1, int fUseXors, int fVerbose,
664 Gia_Man_t ** ppGiaF, Gia_Man_t ** ppGiaG, Vec_Int_t ** pvNodes, Vec_Ptr_t ** pvNodesR, Vec_Bit_t ** pvPolar )
665 {
666 extern Acb_Ntk_t * Acb_VerilogSimpleRead( char * pFileName, char * pFileNameW );
667 Acb_Ntk_t * pNtkF = Acb_VerilogSimpleRead( pFileName0, NULL );
668 Acb_Ntk_t * pNtkG = Acb_VerilogSimpleRead( pFileName1, NULL );
669 int RetValue = -1;
670 if ( pNtkF && pNtkG )
671 {
672 int nTargets = Vec_IntSize(&pNtkF->vTargets);
673 Gia_Man_t * pGiaF = Acb_NtkToGia2( pNtkF, fUseXors, &pNtkF->vTargets, 0 );
674 Gia_Man_t * pGiaG = Acb_NtkToGia2( pNtkG, 0, NULL, nTargets );
675 assert( Acb_NtkCiNum(pNtkF) == Acb_NtkCiNum(pNtkG) );
676 assert( Acb_NtkCoNum(pNtkF) == Acb_NtkCoNum(pNtkG) );
677 *ppGiaF = pGiaF;
678 *ppGiaG = pGiaG;
679 *pvNodes = Acb_NtkCollectCopies( pNtkF, pGiaF, pvNodesR, pvPolar );
680 RetValue = nTargets;
681 }
682 if ( pNtkF ) Acb_ManFree( pNtkF->pDesign );
683 if ( pNtkG ) Acb_ManFree( pNtkG->pDesign );
684 return RetValue;
685 }
686
687 /**Function*************************************************************
688
689 Synopsis []
690
691 Description []
692
693 SideEffects []
694
695 SeeAlso []
696
697 ***********************************************************************/
Abc_NtkCollectCopies(Abc_Ntk_t * p,Gia_Man_t * pGia,Vec_Ptr_t ** pvNodesR,Vec_Bit_t ** pvPolar)698 Vec_Int_t * Abc_NtkCollectCopies( Abc_Ntk_t * p, Gia_Man_t * pGia, Vec_Ptr_t ** pvNodesR, Vec_Bit_t ** pvPolar )
699 {
700 int i, iObj, iLit;
701 Abc_Obj_t * pObj;
702 Vec_Ptr_t * vObjs = Abc_NtkDfs( p, 0 );
703 Vec_Int_t * vNodes = Vec_IntAlloc( Abc_NtkObjNumMax(p) );
704 Vec_Ptr_t * vNodesR = Vec_PtrStart( Gia_ManObjNum(pGia) );
705 Vec_Bit_t * vDriver = Vec_BitStart( Gia_ManObjNum(pGia) );
706 Vec_Bit_t * vPolar = Vec_BitStart( Gia_ManObjNum(pGia) );
707 Gia_ManForEachCiId( pGia, iObj, i )
708 Vec_PtrWriteEntry( vNodesR, iObj, Abc_UtilStrsav(Abc_ObjName(Abc_NtkCi(p, i))) );
709 Gia_ManForEachCoId( pGia, iObj, i )
710 {
711 Vec_BitWriteEntry( vDriver, Gia_ObjFaninId0(Gia_ManObj(pGia, iObj), iObj), 1 );
712 Vec_PtrWriteEntry( vNodesR, iObj, Abc_UtilStrsav(Abc_ObjName(Abc_NtkCo(p, i))) );
713 Vec_IntPush( vNodes, iObj );
714 }
715 Vec_PtrForEachEntry( Abc_Obj_t *, vObjs, pObj, i )
716 if ( (iLit = pObj->iTemp) >= 0 && Gia_ObjIsAnd(Gia_ManObj(pGia, Abc_Lit2Var(iLit))) )
717 {
718 if ( !Vec_BitEntry(vDriver, Abc_Lit2Var(iLit)) && Vec_PtrEntry(vNodesR, Abc_Lit2Var(iLit)) == NULL )
719 {
720 Vec_PtrWriteEntry( vNodesR, Abc_Lit2Var(iLit), Abc_UtilStrsav(Abc_ObjName(pObj)) );
721 Vec_IntPush( vNodes, Abc_Lit2Var(iLit) );
722 Vec_BitWriteEntry( vPolar, Abc_Lit2Var(iLit), Abc_LitIsCompl(iLit) );
723 }
724 }
725 Vec_BitFree( vDriver );
726 Vec_PtrFree( vObjs );
727 Vec_IntSort( vNodes, 0 );
728 *pvNodesR = vNodesR;
729 *pvPolar = vPolar;
730 return vNodes;
731 }
Abc_ObjToGia2(Gia_Man_t * pNew,Abc_Ntk_t * p,Abc_Obj_t * pObj,Vec_Int_t * vTemp,int fUseXors)732 int Abc_ObjToGia2( Gia_Man_t * pNew, Abc_Ntk_t * p, Abc_Obj_t * pObj, Vec_Int_t * vTemp, int fUseXors )
733 {
734 Abc_Obj_t * pFanin; int k;
735 assert( Abc_ObjIsNode(pObj) );
736 Vec_IntClear( vTemp );
737 Abc_ObjForEachFanin( pObj, pFanin, k )
738 {
739 assert( pFanin->iTemp >= 0 );
740 Vec_IntPush( vTemp, pFanin->iTemp );
741 }
742 if ( Abc_ObjFaninNum(pObj) == 0 )
743 return Abc_SopIsConst0( (char*)pObj->pData ) ? 0 : 1;
744 if ( Abc_ObjFaninNum(pObj) == 1 )
745 return Abc_SopIsBuf( (char*)pObj->pData ) ? Vec_IntEntry(vTemp, 0) : Abc_LitNot(Vec_IntEntry(vTemp, 0));
746 if ( Abc_ObjFaninNum(pObj) == 2 ) // nand2
747 return Abc_LitNot( Gia_ManAppendAnd2( pNew, Vec_IntEntry(vTemp, 0), Vec_IntEntry(vTemp, 1) ) );
748 assert( 0 );
749 return -1;
750 }
Abc_NtkToGia2(Abc_Ntk_t * p,int fUseXors)751 Gia_Man_t * Abc_NtkToGia2( Abc_Ntk_t * p, int fUseXors )
752 {
753 Gia_Man_t * pNew, * pOne;
754 Vec_Int_t * vFanins;
755 Vec_Ptr_t * vNodes;
756 Abc_Obj_t * pObj; int i;
757 pNew = Gia_ManStart( 2 * Abc_NtkObjNumMax(p) + 1000 );
758 pNew->pName = Abc_UtilStrsav(Abc_NtkName(p));
759 Abc_NtkForEachObj( p, pObj, i )
760 pObj->iTemp = -1;
761 Abc_NtkForEachCi( p, pObj, i )
762 pObj->iTemp = Gia_ManAppendCi(pNew);
763 vFanins = Vec_IntAlloc( 4 );
764 vNodes = Abc_NtkDfs( p, 0 );
765 Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
766 pObj->iTemp = Abc_ObjToGia2(pNew, p, pObj, vFanins, fUseXors);
767 Vec_PtrFree( vNodes );
768 Vec_IntFree( vFanins );
769 Abc_NtkForEachCo( p, pObj, i )
770 Gia_ManAppendCo( pNew, Abc_ObjFanin0(pObj)->iTemp );
771 pNew = Gia_ManCleanup( pOne = pNew );
772 //Gia_ManUpdateCopy( &p->vObjCopy, pOne );
773 Gia_ManStop( pOne );
774 return pNew;
775 }
Abc_NtkExtract(char * pFileName0,char * pFileName1,int fUseXors,int fVerbose,Gia_Man_t ** ppGiaF,Gia_Man_t ** ppGiaG,Vec_Int_t ** pvNodes,Vec_Ptr_t ** pvNodesR,Vec_Bit_t ** pvPolar)776 int Abc_NtkExtract( char * pFileName0, char * pFileName1, int fUseXors, int fVerbose,
777 Gia_Man_t ** ppGiaF, Gia_Man_t ** ppGiaG, Vec_Int_t ** pvNodes, Vec_Ptr_t ** pvNodesR, Vec_Bit_t ** pvPolar )
778 {
779 Abc_Ntk_t * pNtkF = Io_Read( pFileName0, Io_ReadFileType(pFileName0), 1, 0 );
780 Abc_Ntk_t * pNtkG = Io_Read( pFileName1, Io_ReadFileType(pFileName1), 1, 0 );
781 int RetValue = -1;
782 if ( pNtkF && pNtkG )
783 {
784 Gia_Man_t * pGiaF = Abc_NtkToGia2( pNtkF, fUseXors );
785 Gia_Man_t * pGiaG = Abc_NtkToGia2( pNtkG, 0 );
786 assert( Abc_NtkCiNum(pNtkF) == Abc_NtkCiNum(pNtkG) );
787 assert( Abc_NtkCoNum(pNtkF) == Abc_NtkCoNum(pNtkG) );
788 *ppGiaF = pGiaF;
789 *ppGiaG = pGiaG;
790 *pvNodes = Abc_NtkCollectCopies( pNtkF, pGiaF, pvNodesR, pvPolar );
791 RetValue = 0;
792 }
793 if ( pNtkF ) Abc_NtkDelete( pNtkF );
794 if ( pNtkG ) Abc_NtkDelete( pNtkG );
795 return RetValue;
796 }
797
798 /**Function*************************************************************
799
800 Synopsis []
801
802 Description []
803
804 SideEffects []
805
806 SeeAlso []
807
808 ***********************************************************************/
Acb_NtkPlaces(char * pFileName,Vec_Ptr_t * vNames)809 Vec_Int_t * Acb_NtkPlaces( char * pFileName, Vec_Ptr_t * vNames )
810 {
811 Vec_Int_t * vPlaces; int First = 1, Pos = -1, fComment = 0;
812 char * pTemp, * pBuffer = Extra_FileReadContents( pFileName );
813 char * pLimit = pBuffer + strlen(pBuffer);
814 if ( pBuffer == NULL )
815 return NULL;
816 vPlaces = Vec_IntAlloc( Vec_PtrSize(vNames) );
817 for ( pTemp = pBuffer; *pTemp; pTemp++ )
818 {
819 if ( *pTemp == '\n' )
820 fComment = 0;
821 if ( *pTemp == '/' && *(pTemp + 1) == '/' )
822 fComment = 1;
823 if ( fComment )
824 continue;
825
826 if ( *pTemp == '\n' )
827 Pos = pTemp - pBuffer + 1;
828 else if ( *pTemp == '(' )
829 {
830 if ( First )
831 First = 0;
832 else
833 {
834 char * pToken = strtok( pTemp+1, " \n\r\t," );
835 char * pName; int i;
836 Vec_PtrForEachEntry( char *, vNames, pName, i )
837 if ( !strcmp(pName, pToken) )
838 Vec_IntPushTwo( vPlaces, Pos, i );
839 pTemp = pToken + strlen(pToken);
840 while ( *pTemp == 0 )
841 pTemp++;
842 assert( pTemp < pLimit );
843 }
844 }
845 }
846 assert( Vec_IntSize(vPlaces) == 2*Vec_PtrSize(vNames) );
847 ABC_FREE( pBuffer );
848 return vPlaces;
849 }
Acb_NtkInsert(char * pFileNameIn,char * pFileNameOut,Vec_Ptr_t * vNames,int fNumber)850 void Acb_NtkInsert( char * pFileNameIn, char * pFileNameOut, Vec_Ptr_t * vNames, int fNumber )
851 {
852 int i, k, Prev = 0, Pos, Pos2, iObj;
853 Vec_Int_t * vPlaces;
854 char * pName, * pBuffer;
855 FILE * pFile = fopen( pFileNameOut, "wb" );
856 if ( pFile == NULL )
857 {
858 printf( "Cannot open output file \"%s\".\n", pFileNameOut );
859 return;
860 }
861 pBuffer = Extra_FileReadContents( pFileNameIn );
862 if ( pBuffer == NULL )
863 {
864 fclose( pFile );
865 printf( "Cannot open input file \"%s\".\n", pFileNameIn );
866 return;
867 }
868 vPlaces = Acb_NtkPlaces( pFileNameIn, vNames );
869 Vec_IntForEachEntryDouble( vPlaces, Pos, iObj, i )
870 {
871 for ( k = Prev; k < Pos; k++ )
872 fputc( pBuffer[k], pFile );
873 fprintf( pFile, "// [t_%d = %s] //", iObj, (char *)Vec_PtrEntry(vNames, iObj) );
874 Prev = Pos;
875 }
876 Vec_IntFree( vPlaces );
877 pName = strstr(pBuffer, "endmodule");
878 Pos2 = pName - pBuffer;
879 for ( k = Prev; k < Pos2; k++ )
880 fputc( pBuffer[k], pFile );
881 fprintf( pFile, "\n\n" );
882 fprintf( pFile, " wire " );
883 if ( fNumber )
884 {
885 Vec_PtrForEachEntry( char *, vNames, pName, i )
886 fprintf( pFile, " t_%d%s", i, i==Vec_PtrSize(vNames)-1 ? ";" : "," );
887 }
888 else
889 {
890 Vec_PtrForEachEntry( char *, vNames, pName, i )
891 fprintf( pFile, " t%d_%s%s", i, pName, i==Vec_PtrSize(vNames)-1 ? ";" : "," );
892 }
893 fprintf( pFile, "\n\n" );
894 if ( fNumber )
895 {
896 Vec_PtrForEachEntry( char *, vNames, pName, i )
897 fprintf( pFile, " buf( %s, t_%d );\n", pName, i );
898 }
899 else
900 {
901 Vec_PtrForEachEntry( char *, vNames, pName, i )
902 fprintf( pFile, " buf( %s, t%d_%s );\n", pName, i, pName );
903 }
904 fprintf( pFile, "\n" );
905 for ( k = Pos2; pBuffer[k]; k++ )
906 fputc( pBuffer[k], pFile );
907 ABC_FREE( pBuffer );
908 fclose( pFile );
909 }
910
911 /**Function*************************************************************
912
913 Synopsis []
914
915 Description []
916
917 SideEffects []
918
919 SeeAlso []
920
921 ***********************************************************************/
Acb_NtkRunSim(char * pFileName[4],int nWords,int nBeam,int LevL,int LevU,int fOrder,int fFancy,int fVerbose)922 void Acb_NtkRunSim( char * pFileName[4], int nWords, int nBeam, int LevL, int LevU, int fOrder, int fFancy, int fVerbose )
923 {
924 extern int Gia_Sim4Try( char * pFileName0, char * pFileName1, char * pFileName2, int nWords, int nBeam, int LevL, int LevU, int fOrder, int fFancy, int fVerbose );
925 extern void Acb_NtkRunEco( char * pFileNames[4], int fCheck, int fVerbose );
926 char * pFileNames[4] = { pFileName[2], pFileName[1], NULL, pFileName[2] };
927 if ( Gia_Sim4Try( pFileName[0], pFileName[1], pFileName[2], nWords, nBeam, LevL, LevU, fOrder, fFancy, fVerbose ) )
928 Acb_NtkRunEco( pFileNames, 1, fVerbose );
929 }
930
931
932 ////////////////////////////////////////////////////////////////////////
933 /// END OF FILE ///
934 ////////////////////////////////////////////////////////////////////////
935
936
937 ABC_NAMESPACE_IMPL_END
938
939