ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
ioWritePla.c
Go to the documentation of this file.
1
20
21#include "ioAbc.h"
22
23#ifdef ABC_USE_CUDD
24#include "bdd/extrab/extraBdd.h"
25#endif
26
27ABC_NAMESPACE_IMPL_START
28
29
33
37
49int Io_WritePlaOne( FILE * pFile, Abc_Ntk_t * pNtk )
50{
51 ProgressBar * pProgress;
52 Abc_Obj_t * pNode, * pFanin, * pDriver;
53 char * pCubeIn, * pCubeOut, * pCube;
54 int i, k, nProducts, nInputs, nOutputs, nFanins;
55
56 nProducts = 0;
57 Abc_NtkForEachCo( pNtk, pNode, i )
58 {
59 pDriver = Abc_ObjFanin0Ntk( Abc_ObjFanin0(pNode) );
60 if ( !Abc_ObjIsNode(pDriver) )
61 {
62 nProducts++;
63 continue;
64 }
65 if ( Abc_NodeIsConst(pDriver) )
66 {
67 if ( Abc_NodeIsConst1(pDriver) )
68 nProducts++;
69 continue;
70 }
71 nProducts += Abc_SopGetCubeNum((char *)pDriver->pData);
72 }
73
74 // collect the parameters
75 nInputs = Abc_NtkCiNum(pNtk);
76 nOutputs = Abc_NtkCoNum(pNtk);
77 pCubeIn = ABC_ALLOC( char, nInputs + 1 );
78 pCubeOut = ABC_ALLOC( char, nOutputs + 1 );
79 memset( pCubeIn, '-', (size_t)nInputs ); pCubeIn[nInputs] = 0;
80 memset( pCubeOut, '0', (size_t)nOutputs ); pCubeOut[nOutputs] = 0;
81
82 // write the header
83 fprintf( pFile, ".i %d\n", nInputs );
84 fprintf( pFile, ".o %d\n", nOutputs );
85 fprintf( pFile, ".ilb" );
86 Abc_NtkForEachCi( pNtk, pNode, i )
87 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanout0(pNode)) );
88 fprintf( pFile, "\n" );
89 fprintf( pFile, ".ob" );
90 Abc_NtkForEachCo( pNtk, pNode, i )
91 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin0(pNode)) );
92 fprintf( pFile, "\n" );
93 fprintf( pFile, ".p %d\n", nProducts );
94
95 // mark the CI nodes
96 Abc_NtkForEachCi( pNtk, pNode, i )
97 pNode->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)i;
98
99 // write the cubes
100 pProgress = Extra_ProgressBarStart( stdout, nOutputs );
101 Abc_NtkForEachCo( pNtk, pNode, i )
102 {
103 // prepare the output cube
104 if ( i - 1 >= 0 )
105 pCubeOut[i-1] = '0';
106 pCubeOut[i] = '1';
107
108 // consider special cases of nodes
109 pDriver = Abc_ObjFanin0Ntk( Abc_ObjFanin0(pNode) );
110 if ( !Abc_ObjIsNode(pDriver) )
111 {
112 assert( Abc_ObjIsCi(pDriver) );
113 pCubeIn[(int)(ABC_PTRUINT_T)pDriver->pCopy] = '1' - Abc_ObjFaninC0(pNode);
114 fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
115 pCubeIn[(int)(ABC_PTRUINT_T)pDriver->pCopy] = '-';
116 continue;
117 }
118 if ( Abc_NodeIsConst(pDriver) )
119 {
120 if ( Abc_NodeIsConst1(pDriver) )
121 fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
122 continue;
123 }
124
125 // make sure the cover is not complemented
126 assert( !Abc_SopIsComplement( (char *)pDriver->pData ) );
127
128 // write the cubes
129 nFanins = Abc_ObjFaninNum(pDriver);
130 Abc_SopForEachCube( (char *)pDriver->pData, nFanins, pCube )
131 {
132 Abc_ObjForEachFanin( pDriver, pFanin, k )
133 {
134 pFanin = Abc_ObjFanin0Ntk(pFanin);
135 assert( (int)(ABC_PTRUINT_T)pFanin->pCopy < nInputs );
136 pCubeIn[(int)(ABC_PTRUINT_T)pFanin->pCopy] = pCube[k];
137 }
138 fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
139 }
140 // clean the cube for future writing
141 Abc_ObjForEachFanin( pDriver, pFanin, k )
142 {
143 pFanin = Abc_ObjFanin0Ntk(pFanin);
144 assert( Abc_ObjIsCi(pFanin) );
145 pCubeIn[(int)(ABC_PTRUINT_T)pFanin->pCopy] = '-';
146 }
147 Extra_ProgressBarUpdate( pProgress, i, NULL );
148 }
149 Extra_ProgressBarStop( pProgress );
150 fprintf( pFile, ".e\n" );
151
152 // clean the CI nodes
153 Abc_NtkForEachCi( pNtk, pNode, i )
154 pNode->pCopy = NULL;
155 ABC_FREE( pCubeIn );
156 ABC_FREE( pCubeOut );
157 return 1;
158}
159
171int Io_WritePla( Abc_Ntk_t * pNtk, char * pFileName )
172{
173 Abc_Ntk_t * pExdc;
174 FILE * pFile;
175
176 assert( Abc_NtkIsSopNetlist(pNtk) );
177 assert( Abc_NtkLevel(pNtk) == 1 );
178
179 pFile = fopen( pFileName, "w" );
180 if ( pFile == NULL )
181 {
182 fprintf( stdout, "Io_WritePla(): Cannot open the output file.\n" );
183 return 0;
184 }
185 fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
186 // write the network
187 Io_WritePlaOne( pFile, pNtk );
188 // write EXDC network if it exists
189 pExdc = Abc_NtkExdc( pNtk );
190 if ( pExdc )
191 printf( "Io_WritePla: EXDC is not written (warning).\n" );
192 // finalize the file
193 fclose( pFile );
194 return 1;
195}
196
197#ifdef ABC_USE_CUDD
198
210int Io_WriteMoPlaOneInt( FILE * pFile, Abc_Ntk_t * pNtk, DdManager * dd, Vec_Ptr_t * vFuncs )
211{
212 Abc_Obj_t * pNode;
213 DdNode * bOnset, * bOffset, * bCube, * bFunc, * bTemp, * zCover;
214 int i, k, nInputs, nOutputs;
215 int nCubes, fPhase;
216
217 assert( Vec_PtrSize(vFuncs) == Abc_NtkCoNum(pNtk) );
218 assert( dd->size == Abc_NtkCiNum(pNtk) );
219 assert( dd->size <= 1000 );
220
221 // collect the parameters
222 nInputs = Abc_NtkCiNum(pNtk);
223 nOutputs = Abc_NtkCoNum(pNtk);
224 assert( nOutputs > 1 );
225
226 // create extra variables
227 for ( i = 0; i < nOutputs; i++ )
228 Cudd_bddNewVarAtLevel( dd, i );
229 assert( dd->size == nInputs + nOutputs );
230
231 // create ON and OFF sets
232 bOnset = Cudd_ReadLogicZero( dd ); Cudd_Ref(bOnset);
233 bOffset = Cudd_ReadLogicZero( dd ); Cudd_Ref(bOffset);
234 for ( i = 0; i < nOutputs; i++ )
235 {
236 bFunc = (DdNode *)Vec_PtrEntry(vFuncs, i);
237 // create onset
238 bCube = Cudd_bddAnd( dd, Cudd_bddIthVar(dd, nInputs+i), bFunc ); Cudd_Ref(bCube);
239 for ( k = 0; k < nOutputs; k++ )
240 if ( k != i )
241 {
242 bCube = Cudd_bddAnd( dd, bTemp = bCube, Cudd_Not(Cudd_bddIthVar(dd, nInputs+k)) ); Cudd_Ref(bCube);
243 Cudd_RecursiveDeref( dd, bTemp );
244 }
245 bOnset = Cudd_bddOr( dd, bTemp = bOnset, bCube ); Cudd_Ref(bOnset);
246 Cudd_RecursiveDeref( dd, bTemp );
247 Cudd_RecursiveDeref( dd, bCube );
248 // create offset
249 bCube = Cudd_bddAnd( dd, Cudd_bddIthVar(dd, nInputs+i), Cudd_Not(bFunc) ); Cudd_Ref(bCube);
250 bOffset = Cudd_bddOr( dd, bTemp = bOffset, bCube ); Cudd_Ref(bOffset);
251 Cudd_RecursiveDeref( dd, bTemp );
252 Cudd_RecursiveDeref( dd, bCube );
253
254 printf( "Trying %d output.\n", i );
255 printf( "Onset = %d nodes.\n", Cudd_DagSize(bOnset) );
256 printf( "Offset = %d nodes.\n", Cudd_DagSize(bOffset) );
257 }
258
259 Cudd_zddVarsFromBddVars( dd, 2 );
260
261 // derive ISOP
262 {
263 extern int Abc_CountZddCubes( DdManager * dd, DdNode * zCover );
264 DdNode * bCover, * zCover0, * zCover1;
265 int nCubes0, nCubes1;
266 // get the ZDD of the negative polarity
267 bCover = Cudd_zddIsop( dd, bOffset, Cudd_Not(bOnset), &zCover0 );
268 Cudd_Ref( zCover0 );
269 Cudd_Ref( bCover );
270 Cudd_RecursiveDeref( dd, bCover );
271 nCubes0 = Abc_CountZddCubes( dd, zCover0 );
272
273 // get the ZDD of the positive polarity
274 bCover = Cudd_zddIsop( dd, bOnset, Cudd_Not(bOffset), &zCover1 );
275 Cudd_Ref( zCover1 );
276 Cudd_Ref( bCover );
277 Cudd_RecursiveDeref( dd, bCover );
278 nCubes1 = Abc_CountZddCubes( dd, zCover1 );
279
280 // compare the number of cubes
281 if ( nCubes1 <= nCubes0 )
282 { // use positive polarity
283 nCubes = nCubes1;
284 zCover = zCover1;
285 Cudd_RecursiveDerefZdd( dd, zCover0 );
286 fPhase = 1;
287 }
288 else
289 { // use negative polarity
290 nCubes = nCubes0;
291 zCover = zCover0;
292 Cudd_RecursiveDerefZdd( dd, zCover1 );
293 fPhase = 0;
294 }
295 }
296 Cudd_RecursiveDeref( dd, bOnset );
297 Cudd_RecursiveDeref( dd, bOffset );
298 Cudd_RecursiveDerefZdd( dd, zCover );
299 printf( "Cover = %d nodes.\n", Cudd_DagSize(zCover) );
300 printf( "ISOP = %d\n", nCubes );
301
302 // write the header
303 fprintf( pFile, ".i %d\n", nInputs );
304 fprintf( pFile, ".o %d\n", nOutputs );
305 fprintf( pFile, ".ilb" );
306 Abc_NtkForEachCi( pNtk, pNode, i )
307 fprintf( pFile, " %s", Abc_ObjName(pNode) );
308 fprintf( pFile, "\n" );
309 fprintf( pFile, ".ob" );
310 Abc_NtkForEachCo( pNtk, pNode, i )
311 fprintf( pFile, " %s", Abc_ObjName(pNode) );
312 fprintf( pFile, "\n" );
313 fprintf( pFile, ".p %d\n", nCubes );
314
315
316 fprintf( pFile, ".e\n" );
317 return 1;
318}
319
331int Io_WriteMoPlaOneIntMinterms( FILE * pFile, Abc_Ntk_t * pNtk, DdManager * dd, Vec_Ptr_t * vFuncs )
332{
333 int pValues[1000];
334 Abc_Obj_t * pNode;
335 int i, k, nProducts, nInputs, nOutputs;
336 assert( Vec_PtrSize(vFuncs) == Abc_NtkCoNum(pNtk) );
337 assert( dd->size == Abc_NtkCiNum(pNtk) );
338 assert( dd->size <= 1000 );
339
340 // collect the parameters
341 nInputs = Abc_NtkCiNum(pNtk);
342 nOutputs = Abc_NtkCoNum(pNtk);
343 nProducts = (1 << nInputs);
344
345 // write the header
346 fprintf( pFile, ".i %d\n", nInputs );
347 fprintf( pFile, ".o %d\n", nOutputs );
348 fprintf( pFile, ".ilb" );
349 Abc_NtkForEachCi( pNtk, pNode, i )
350 fprintf( pFile, " %s", Abc_ObjName(pNode) );
351 fprintf( pFile, "\n" );
352 fprintf( pFile, ".ob" );
353 Abc_NtkForEachCo( pNtk, pNode, i )
354 fprintf( pFile, " %s", Abc_ObjName(pNode) );
355 fprintf( pFile, "\n" );
356 fprintf( pFile, ".p %d\n", nProducts );
357
358 // iterate through minterms
359 for ( k = 0; k < nProducts; k++ )
360 {
361 for ( i = 0; i < nInputs; i++ )
362 fprintf( pFile, "%c", '0' + (pValues[i] = ((k >> i) & 1)) );
363 fprintf( pFile, " " );
364 for ( i = 0; i < nOutputs; i++ )
365 fprintf( pFile, "%c", '0' + (Cudd_ReadOne(dd) == Cudd_Eval(dd, (DdNode *)Vec_PtrEntry(vFuncs, i), pValues)) );
366 fprintf( pFile, "\n" );
367 }
368
369 fprintf( pFile, ".e\n" );
370 return 1;
371}
372
384int Io_WriteMoPlaOne( FILE * pFile, Abc_Ntk_t * pNtk )
385{
386 int fVerbose = 0;
387 DdManager * dd;
388 DdNode * bFunc;
389 Vec_Ptr_t * vFuncsGlob;
390 Abc_Obj_t * pObj;
391 int i;
392 assert( Abc_NtkIsStrash(pNtk) );
393 dd = (DdManager *)Abc_NtkBuildGlobalBdds( pNtk, 10000000, 1, 1, 0, fVerbose );
394 if ( dd == NULL )
395 return 0;
396 if ( fVerbose )
397 printf( "Shared BDD size = %6d nodes.\n", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
398
399 // complement the global functions
400 vFuncsGlob = Vec_PtrAlloc( Abc_NtkCoNum(pNtk) );
401 Abc_NtkForEachCo( pNtk, pObj, i )
402 Vec_PtrPush( vFuncsGlob, Abc_ObjGlobalBdd(pObj) );
403
404 // consider minterms
405 Io_WriteMoPlaOneIntMinterms( pFile, pNtk, dd, vFuncsGlob );
406 Abc_NtkFreeGlobalBdds( pNtk, 0 );
407
408 // cleanup
409 Vec_PtrForEachEntry( DdNode *, vFuncsGlob, bFunc, i )
410 Cudd_RecursiveDeref( dd, bFunc );
411 Vec_PtrFree( vFuncsGlob );
412 Extra_StopManager( dd );
413 return 1;
414}
415
427int Io_WriteMoPla( Abc_Ntk_t * pNtk, char * pFileName )
428{
429 FILE * pFile;
430 assert( Abc_NtkIsStrash(pNtk) );
431 if ( Abc_NtkCiNum(pNtk) > 16 )
432 {
433 printf( "Cannot write multi-output PLA for more than 16 inputs.\n" );
434 return 0;
435 }
436 pFile = fopen( pFileName, "w" );
437 if ( pFile == NULL )
438 {
439 fprintf( stdout, "Io_WritePla(): Cannot open the output file.\n" );
440 return 0;
441 }
442 fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
443 Io_WriteMoPlaOne( pFile, pNtk );
444 fclose( pFile );
445 return 1;
446}
447
448
449
461int Io_WriteMoPlaOneIntMintermsM( FILE * pFile, Abc_Ntk_t * pNtk, DdManager * dd, DdNode * bFunc, int nMints )
462{
463 Abc_Obj_t * pNode;
464 int * pArray = ABC_CALLOC( int, dd->size );
465 DdNode ** pbMints = Cudd_bddPickArbitraryMinterms( dd, bFunc, dd->vars, dd->size, nMints );
466 int i, k, nInputs = Abc_NtkCiNum(pNtk);
467 assert( dd->size == Abc_NtkCiNum(pNtk) );
468
469 // write the header
470 fprintf( pFile, ".i %d\n", nInputs );
471 fprintf( pFile, ".o %d\n", 1 );
472 fprintf( pFile, ".ilb" );
473 Abc_NtkForEachCi( pNtk, pNode, i )
474 fprintf( pFile, " %s", Abc_ObjName(pNode) );
475 fprintf( pFile, "\n" );
476 fprintf( pFile, ".ob" );
477 fprintf( pFile, " %s", Abc_ObjName(Abc_NtkCo(pNtk, 0)) );
478 fprintf( pFile, "\n" );
479 fprintf( pFile, ".p %d\n", nMints );
480
481 // iterate through minterms
482 for ( k = 0; k < nMints; k++ )
483 {
484 Cudd_BddToCubeArray( dd, pbMints[k], pArray );
485 for ( i = 0; i < Abc_NtkCiNum(pNtk); i++ )
486 if ( pArray[i] == 0 )
487 fprintf( pFile, "%c", '0' );
488 else if ( pArray[i] == 1 )
489 fprintf( pFile, "%c", '1' );
490 else if ( pArray[i] == 2 )
491 fprintf( pFile, "%c", '-' );
492 fprintf( pFile, " " );
493 fprintf( pFile, "%c", '1' );
494 fprintf( pFile, "\n" );
495 }
496 fprintf( pFile, ".e\n" );
497
498 //for ( k = 0; k < nMints; k++ )
499 // Cudd_RecursiveDeref( dd, pbMints[k] );
500 ABC_FREE( pbMints );
501 ABC_FREE( pArray );
502 return 1;
503}
504int Io_WriteMoPlaOneM( FILE * pFile, Abc_Ntk_t * pNtk, int nMints )
505{
506 int fVerbose = 0;
507 DdManager * dd;
508 DdNode * bFunc;
509 Vec_Ptr_t * vFuncsGlob;
510 Abc_Obj_t * pObj;
511 int i;
512 if ( Abc_NtkIsStrash(pNtk) )
513 {
514 assert( Abc_NtkIsStrash(pNtk) );
515 dd = (DdManager *)Abc_NtkBuildGlobalBdds( pNtk, 10000000, 1, 1, 0, fVerbose );
516 if ( dd == NULL )
517 return 0;
518 if ( fVerbose )
519 printf( "Shared BDD size = %6d nodes.\n", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
520
521 // complement the global functions
522 vFuncsGlob = Vec_PtrAlloc( Abc_NtkCoNum(pNtk) );
523 Abc_NtkForEachCo( pNtk, pObj, i )
524 Vec_PtrPush( vFuncsGlob, Abc_ObjGlobalBdd(pObj) );
525
526 // get the output function
527 bFunc = (DdNode *)Vec_PtrEntry(vFuncsGlob, 0);
528 if ( bFunc == Cudd_ReadOne(dd) )
529 printf( "First primary output has constant 1 function.\n" );
530 else if ( Cudd_Not(bFunc) == Cudd_ReadOne(dd) )
531 printf( "First primary output has constant 0 function.\n" );
532 else
533 Io_WriteMoPlaOneIntMintermsM( pFile, pNtk, dd, bFunc, nMints );
534 Abc_NtkFreeGlobalBdds( pNtk, 0 );
535
536 // cleanup
537 Vec_PtrForEachEntry( DdNode *, vFuncsGlob, bFunc, i )
538 Cudd_RecursiveDeref( dd, bFunc );
539 Vec_PtrFree( vFuncsGlob );
540 //Extra_StopManager( dd );
541 Cudd_Quit( dd );
542 }
543 else if ( Abc_NtkIsBddLogic(pNtk) )
544 {
545 DdNode * bFunc = (DdNode *)Abc_ObjFanin0(Abc_NtkCo(pNtk, 0))->pData;
546 dd = (DdManager *)pNtk->pManFunc;
547 if ( dd->size == Abc_NtkCiNum(pNtk) )
548 Io_WriteMoPlaOneIntMintermsM( pFile, pNtk, dd, bFunc, nMints );
549 else
550 {
551 printf( "Cannot write minterms because the size of the manager for local BDDs is not equal to\n" );
552 printf( "the number of primary inputs. (It is likely that the current network is not collapsed.)\n" );
553 }
554 }
555 return 1;
556}
557int Io_WriteMoPlaM( Abc_Ntk_t * pNtk, char * pFileName, int nMints )
558{
559 FILE * pFile;
560 assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsBddLogic(pNtk) );
561 pFile = fopen( pFileName, "w" );
562 if ( pFile == NULL )
563 {
564 fprintf( stdout, "Io_WriteMoPlaM(): Cannot open the output file.\n" );
565 return 0;
566 }
567 fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
568 Io_WriteMoPlaOneM( pFile, pNtk, nMints );
569 fclose( pFile );
570 return 1;
571}
572
573
574#else
575
576int Io_WriteMoPla( Abc_Ntk_t * pNtk, char * pFileName ) { return 1; }
577int Io_WriteMoPlaM( Abc_Ntk_t * pNtk, char * pFileName, int nMints ) { return 1; }
578
579#endif
580
584
585
586ABC_NAMESPACE_IMPL_END
587
Abc_Obj_t
struct Abc_Obj_t_ Abc_Obj_t
Definition abc.h:116
Abc_NtkForEachCo
#define Abc_NtkForEachCo(pNtk, pCo, i)
Definition abc.h:522
Abc_ObjForEachFanin
#define Abc_ObjForEachFanin(pObj, pFanin, i)
Definition abc.h:527
Abc_ObjName
ABC_DLL char * Abc_ObjName(Abc_Obj_t *pNode)
DECLARATIONS ///.
Definition abcNames.c:49
Abc_Ntk_t
struct Abc_Ntk_t_ Abc_Ntk_t
Definition abc.h:115
Abc_NtkFreeGlobalBdds
ABC_DLL void * Abc_NtkFreeGlobalBdds(Abc_Ntk_t *pNtk, int fFreeMan)
Abc_NodeIsConst
ABC_DLL int Abc_NodeIsConst(Abc_Obj_t *pNode)
Definition abcObj.c:867
Abc_NtkLevel
ABC_DLL int Abc_NtkLevel(Abc_Ntk_t *pNtk)
Definition abcDfs.c:1449
Abc_SopForEachCube
#define Abc_SopForEachCube(pSop, nFanins, pCube)
Definition abc.h:538
Abc_NtkBuildGlobalBdds
ABC_DLL void * Abc_NtkBuildGlobalBdds(Abc_Ntk_t *pNtk, int fBddSizeMax, int fDropInternal, int fReorder, int fReverse, int fVerbose)
Abc_NtkForEachCi
#define Abc_NtkForEachCi(pNtk, pCi, i)
Definition abc.h:518
Abc_SopIsComplement
ABC_DLL int Abc_SopIsComplement(char *pSop)
Definition abcSop.c:703
Abc_SopGetCubeNum
ABC_DLL int Abc_SopGetCubeNum(char *pSop)
Definition abcSop.c:537
Abc_NodeIsConst1
ABC_DLL int Abc_NodeIsConst1(Abc_Obj_t *pNode)
Definition abcObj.c:916
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition abc_global.h:264
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition abc_global.h:265
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition abc_namespaces.h:54
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition abc_namespaces.h:55
ProgressBar
ABC_NAMESPACE_IMPL_START typedef char ProgressBar
Definition bbrNtbdd.c:27
Extra_StopManager
void Extra_StopManager(DdManager *dd)
Definition extraBddMisc.c:223
Extra_ProgressBarStop
void Extra_ProgressBarStop(ProgressBar *p)
Definition extraUtilProgress.c:118
Extra_TimeStamp
char * Extra_TimeStamp()
Definition extraUtilFile.c:465
Extra_ProgressBarStart
ProgressBar * Extra_ProgressBarStart(FILE *pFile, int nItemsTotal)
FUNCTION DEFINITIONS ///.
Definition extraUtilProgress.c:62
Io_WritePlaOne
ABC_NAMESPACE_IMPL_START int Io_WritePlaOne(FILE *pFile, Abc_Ntk_t *pNtk)
DECLARATIONS ///.
Definition ioWritePla.c:49
Io_WriteMoPla
int Io_WriteMoPla(Abc_Ntk_t *pNtk, char *pFileName)
Definition ioWritePla.c:576
Io_WritePla
int Io_WritePla(Abc_Ntk_t *pNtk, char *pFileName)
Definition ioWritePla.c:171
Io_WriteMoPlaM
int Io_WriteMoPlaM(Abc_Ntk_t *pNtk, char *pFileName, int nMints)
Definition ioWritePla.c:577
Abc_Ntk_t_::pName
char * pName
Definition abc.h:158
Abc_Ntk_t_::pManFunc
void * pManFunc
Definition abc.h:191
Abc_Obj_t_::pData
void * pData
Definition abc.h:145
Abc_Obj_t_::pCopy
Abc_Obj_t * pCopy
Definition abc.h:148
assert
#define assert(ex)
Definition util_old.h:213
memset
char * memset()
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55