ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Classes | Macros | Typedefs | Functions
covInt.h File Reference
#include "base/abc/abc.h"
Include dependency graph for covInt.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  Min_Man_t_
 
struct  Min_Cube_t_
 

Macros

#define Min_CoverForEachCube(pCover, pCube)
 
#define Min_CoverForEachCubeSafe(pCover, pCube, pCube2)
 
#define Min_CoverForEachCubePrev(pCover, pCube, ppPrev)
 

Typedefs

typedef typedefABC_NAMESPACE_HEADER_START struct Min_Man_t_ Min_Man_t
 DECLARATIONS ///.
 
typedef struct Min_Cube_t_ Min_Cube_t
 

Functions

void Min_EsopMinimize (Min_Man_t *p)
 FUNCTION DEFINITIONS ///.
 
void Min_EsopAddCube (Min_Man_t *p, Min_Cube_t *pCube)
 
void Min_SopMinimize (Min_Man_t *p)
 FUNCTION DEFINITIONS ///.
 
void Min_SopAddCube (Min_Man_t *p, Min_Cube_t *pCube)
 
Min_Man_t * Min_ManAlloc (int nVars)
 DECLARATIONS ///.
 
void Min_ManClean (Min_Man_t *p, int nSupp)
 
void Min_ManFree (Min_Man_t *p)
 
void Min_CoverCreate (Vec_Str_t *vCover, Min_Cube_t *pCover, char Type)
 
void Min_CubeWrite (FILE *pFile, Min_Cube_t *pCube)
 
void Min_CoverWrite (FILE *pFile, Min_Cube_t *pCover)
 
void Min_CoverWriteStore (FILE *pFile, Min_Man_t *p)
 
void Min_CoverWriteFile (Min_Cube_t *pCover, char *pName, int fEsop)
 
void Min_CoverCheck (Min_Man_t *p)
 
int Min_CubeCheck (Min_Cube_t *pCube)
 
Min_Cube_t * Min_CoverCollect (Min_Man_t *p, int nSuppSize)
 
void Min_CoverExpand (Min_Man_t *p, Min_Cube_t *pCover)
 
int Min_CoverSuppVarNum (Min_Man_t *p, Min_Cube_t *pCover)
 

Macro Definition Documentation

◆ Min_CoverForEachCube

#define Min_CoverForEachCube ( pCover,
pCube )
Value:
for ( pCube = pCover; \
pCube; \
pCube = pCube->pNext )

Definition at line 65 of file covInt.h.

65#define Min_CoverForEachCube( pCover, pCube ) \
66 for ( pCube = pCover; \
67 pCube; \
68 pCube = pCube->pNext )

◆ Min_CoverForEachCubePrev

#define Min_CoverForEachCubePrev ( pCover,
pCube,
ppPrev )
Value:
for ( pCube = pCover, \
ppPrev = &(pCover); \
pCube; \
ppPrev = &pCube->pNext, \
pCube = pCube->pNext )

Definition at line 75 of file covInt.h.

75#define Min_CoverForEachCubePrev( pCover, pCube, ppPrev ) \
76 for ( pCube = pCover, \
77 ppPrev = &(pCover); \
78 pCube; \
79 ppPrev = &pCube->pNext, \
80 pCube = pCube->pNext )

◆ Min_CoverForEachCubeSafe

#define Min_CoverForEachCubeSafe ( pCover,
pCube,
pCube2 )
Value:
for ( pCube = pCover, \
pCube2 = pCube? pCube->pNext: NULL; \
pCube; \
pCube = pCube2, \
pCube2 = pCube? pCube->pNext: NULL )

Definition at line 69 of file covInt.h.

69#define Min_CoverForEachCubeSafe( pCover, pCube, pCube2 ) \
70 for ( pCube = pCover, \
71 pCube2 = pCube? pCube->pNext: NULL; \
72 pCube; \
73 pCube = pCube2, \
74 pCube2 = pCube? pCube->pNext: NULL )

Typedef Documentation

◆ Min_Cube_t

typedef struct Min_Cube_t_ Min_Cube_t

Definition at line 35 of file covInt.h.

◆ Min_Man_t

typedef typedefABC_NAMESPACE_HEADER_START struct Min_Man_t_ Min_Man_t

DECLARATIONS ///.

CFile****************************************************************

FileName [covInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Mapping into network of SOPs/ESOPs.]

Synopsis [Internal declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id
covInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 34 of file covInt.h.

Function Documentation

◆ Min_CoverCheck()

void Min_CoverCheck ( Min_Man_t * p)
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 223 of file covMinUtil.c.

224{
225 Min_Cube_t * pCube;
226 int i;
227 for ( i = 0; i <= p->nVars; i++ )
228 Min_CoverForEachCube( p->ppStore[i], pCube )
229 assert( i == (int)pCube->nLits );
230}
Min_Cube_t
struct Min_Cube_t_ Min_Cube_t
Definition covInt.h:35
Min_CoverForEachCube
#define Min_CoverForEachCube(pCover, pCube)
Definition covInt.h:65
p
Cube * p
Definition exorList.c:222
Min_Cube_t_::nLits
unsigned nLits
Definition covInt.h:59
assert
#define assert(ex)
Definition util_old.h:213

◆ Min_CoverCollect()

Min_Cube_t * Min_CoverCollect ( Min_Man_t * p,
int nSuppSize )
extern

Function*************************************************************

Synopsis [Converts the cover from the sorted structure.]

Description []

SideEffects []

SeeAlso []

Definition at line 264 of file covMinUtil.c.

265{
266 Min_Cube_t * pCov = NULL, ** ppTail = &pCov;
267 Min_Cube_t * pCube, * pCube2;
268 int i;
269 for ( i = 0; i <= nSuppSize; i++ )
270 {
271 Min_CoverForEachCubeSafe( p->ppStore[i], pCube, pCube2 )
272 {
273 assert( i == (int)pCube->nLits );
274 *ppTail = pCube;
275 ppTail = &pCube->pNext;
276 assert( pCube->uData[0] ); // not a bubble
277 }
278 }
279 *ppTail = NULL;
280 return pCov;
281}
Min_CoverForEachCubeSafe
#define Min_CoverForEachCubeSafe(pCover, pCube, pCube2)
Definition covInt.h:69
Min_Cube_t_::uData
unsigned uData[1]
Definition covInt.h:60
Min_Cube_t_::pNext
Min_Cube_t * pNext
Definition covInt.h:56
Here is the caller graph for this function:

◆ Min_CoverCreate()

void Min_CoverCreate ( Vec_Str_t * vCover,
Min_Cube_t * pCover,
char Type )
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 85 of file covMinUtil.c.

86{
87 Min_Cube_t * pCube;
88 assert( pCover != NULL );
89 Vec_StrClear( vCover );
90 Min_CoverForEachCube( pCover, pCube )
91 Min_CubeCreate( vCover, pCube, Type );
92 Vec_StrPush( vCover, 0 );
93}
Min_CubeCreate
ABC_NAMESPACE_IMPL_START void Min_CubeCreate(Vec_Str_t *vCover, Min_Cube_t *pCube, char Type)
DECLARATIONS ///.
Definition covMinUtil.c:45
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_CoverExpand()

void Min_CoverExpand ( Min_Man_t * p,
Min_Cube_t * pCover )
extern

Function*************************************************************

Synopsis [Sorts the cover in the increasing number of literals.]

Description []

SideEffects []

SeeAlso []

Definition at line 294 of file covMinUtil.c.

295{
296 Min_Cube_t * pCube, * pCube2;
297 Min_ManClean( p, p->nVars );
298 Min_CoverForEachCubeSafe( pCover, pCube, pCube2 )
299 {
300 pCube->pNext = p->ppStore[pCube->nLits];
301 p->ppStore[pCube->nLits] = pCube;
302 p->nCubes++;
303 }
304}
Min_ManClean
void Min_ManClean(Min_Man_t *p, int nSupp)
Definition covMinMan.c:83
Here is the call graph for this function:

◆ Min_CoverSuppVarNum()

int Min_CoverSuppVarNum ( Min_Man_t * p,
Min_Cube_t * pCover )
extern

Function*************************************************************

Synopsis [Sorts the cover in the increasing number of literals.]

Description []

SideEffects []

SeeAlso []

Definition at line 317 of file covMinUtil.c.

318{
319 Min_Cube_t * pCube;
320 int i, Counter;
321 if ( pCover == NULL )
322 return 0;
323 // clean the cube
324 for ( i = 0; i < (int)pCover->nWords; i++ )
325 p->pTemp->uData[i] = ~((unsigned)0);
326 // add the bit data
327 Min_CoverForEachCube( pCover, pCube )
328 for ( i = 0; i < (int)pCover->nWords; i++ )
329 p->pTemp->uData[i] &= pCube->uData[i];
330 // count the vars
331 Counter = 0;
332 for ( i = 0; i < (int)pCover->nVars; i++ )
333 Counter += ( Min_CubeGetVar(p->pTemp, i) != 3 );
334 return Counter;
335}
Min_Cube_t_::nVars
unsigned nVars
Definition covInt.h:57
Min_Cube_t_::nWords
unsigned nWords
Definition covInt.h:58

◆ Min_CoverWrite()

void Min_CoverWrite ( FILE * pFile,
Min_Cube_t * pCover )
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 140 of file covMinUtil.c.

141{
142 Min_Cube_t * pCube;
143 Min_CoverForEachCube( pCover, pCube )
144 Min_CubeWrite( pFile, pCube );
145 printf( "\n" );
146}
Min_CubeWrite
void Min_CubeWrite(FILE *pFile, Min_Cube_t *pCube)
Definition covMinUtil.c:106
Here is the call graph for this function:

◆ Min_CoverWriteFile()

void Min_CoverWriteFile ( Min_Cube_t * pCover,
char * pName,
int fEsop )
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 190 of file covMinUtil.c.

191{
192 char Buffer[1000];
193 Min_Cube_t * pCube;
194 FILE * pFile;
195 int i;
196 sprintf( Buffer, "%s.%s", pName, fEsop? "esop" : "pla" );
197 for ( i = strlen(Buffer) - 1; i >= 0; i-- )
198 if ( Buffer[i] == '<' || Buffer[i] == '>' )
199 Buffer[i] = '_';
200 pFile = fopen( Buffer, "w" );
201 fprintf( pFile, "# %s cover for output %s generated by ABC on %s\n", fEsop? "ESOP":"SOP", pName, Extra_TimeStamp() );
202 fprintf( pFile, ".i %d\n", pCover? pCover->nVars : 0 );
203 fprintf( pFile, ".o %d\n", 1 );
204 fprintf( pFile, ".p %d\n", Min_CoverCountCubes(pCover) );
205 if ( fEsop ) fprintf( pFile, ".type esop\n" );
206 Min_CoverForEachCube( pCover, pCube )
207 Min_CubeWrite( pFile, pCube );
208 fprintf( pFile, ".e\n" );
209 fclose( pFile );
210}
Extra_TimeStamp
char * Extra_TimeStamp()
Definition extraUtilFile.c:465
strlen
int strlen()
sprintf
char * sprintf()
Here is the call graph for this function:

◆ Min_CoverWriteStore()

void Min_CoverWriteStore ( FILE * pFile,
Min_Man_t * p )
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 159 of file covMinUtil.c.

160{
161 Min_Cube_t * pCube;
162 int i;
163 for ( i = 0; i <= p->nVars; i++ )
164 {
165 Min_CoverForEachCube( p->ppStore[i], pCube )
166 {
167 printf( "%2d : ", i );
168 if ( pCube == p->pBubble )
169 {
170 printf( "Bubble\n" );
171 continue;
172 }
173 Min_CubeWrite( pFile, pCube );
174 }
175 }
176 printf( "\n" );
177}
Here is the call graph for this function:

◆ Min_CubeCheck()

int Min_CubeCheck ( Min_Cube_t * pCube)
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 244 of file covMinUtil.c.

245{
246 int i;
247 for ( i = 0; i < (int)pCube->nVars; i++ )
248 if ( Min_CubeGetVar( pCube, i ) == 0 )
249 return 0;
250 return 1;
251}
Here is the caller graph for this function:

◆ Min_CubeWrite()

void Min_CubeWrite ( FILE * pFile,
Min_Cube_t * pCube )
extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 106 of file covMinUtil.c.

107{
108 int i;
109 assert( (int)pCube->nLits == Min_CubeCountLits(pCube) );
110 for ( i = 0; i < (int)pCube->nVars; i++ )
111 if ( Min_CubeHasBit(pCube, i*2) )
112 {
113 if ( Min_CubeHasBit(pCube, i*2+1) )
114 fprintf( pFile, "-" );
115 else
116 fprintf( pFile, "0" );
117 }
118 else
119 {
120 if ( Min_CubeHasBit(pCube, i*2+1) )
121 fprintf( pFile, "1" );
122 else
123 fprintf( pFile, "?" );
124 }
125 fprintf( pFile, " 1\n" );
126// fprintf( pFile, " %d\n", pCube->nLits );
127}
Here is the caller graph for this function:

◆ Min_EsopAddCube()

void Min_EsopAddCube ( Min_Man_t * p,
Min_Cube_t * pCube )
extern

Function*************************************************************

Synopsis [Adds the cube to storage.]

Description []

SideEffects []

SeeAlso []

Definition at line 291 of file covMinEsop.c.

292{
293 assert( pCube != p->pBubble );
294 assert( (int)pCube->nLits == Min_CubeCountLits(pCube) );
295 while ( Min_EsopAddCubeInt( p, pCube ) );
296}
Min_EsopAddCubeInt
int Min_EsopAddCubeInt(Min_Man_t *p, Min_Cube_t *pCube)
Definition covMinEsop.c:220
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_EsopMinimize()

void Min_EsopMinimize ( Min_Man_t * p)
extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file covMinEsop.c.

48{
49 int nCubesInit, nCubesOld, nIter;
50 if ( p->nCubes < 3 )
51 return;
52 nIter = 0;
53 nCubesInit = p->nCubes;
54 do {
55 nCubesOld = p->nCubes;
56 Min_EsopRewrite( p );
57 nIter++;
58 }
59 while ( 100.0*(nCubesOld - p->nCubes)/nCubesOld > 3.0 );
60
61// printf( "%d:%d->%d ", nIter, nCubesInit, p->nCubes );
62}
Here is the caller graph for this function:

◆ Min_ManAlloc()

Min_Man_t * Min_ManAlloc ( int nVars)
extern

DECLARATIONS ///.

CFile****************************************************************

FileName [covMinMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Mapping into network of SOPs/ESOPs.]

Synopsis [SOP manipulation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id
covMinMan.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Starts the minimization manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file covMinMan.c.

46{
47 Min_Man_t * pMan;
48 // start the manager
49 pMan = ABC_ALLOC( Min_Man_t, 1 );
50 memset( pMan, 0, sizeof(Min_Man_t) );
51 pMan->nVars = nVars;
52 pMan->nWords = Abc_BitWordNum( nVars * 2 );
53 pMan->pMemMan = Extra_MmFixedStart( sizeof(Min_Cube_t) + sizeof(unsigned) * (pMan->nWords - 1) );
54 // allocate storage for the temporary cover
55 pMan->ppStore = ABC_ALLOC( Min_Cube_t *, pMan->nVars + 1 );
56 // create tautology cubes
57 Min_ManClean( pMan, nVars );
58 pMan->pOne0 = Min_CubeAlloc( pMan );
59 pMan->pOne1 = Min_CubeAlloc( pMan );
60 pMan->pTemp = Min_CubeAlloc( pMan );
61 pMan->pBubble = Min_CubeAlloc( pMan ); pMan->pBubble->uData[0] = 0;
62 // create trivial cubes
63 Min_ManClean( pMan, 1 );
64 pMan->pTriv0[0] = Min_CubeAllocVar( pMan, 0, 0 );
65 pMan->pTriv0[1] = Min_CubeAllocVar( pMan, 0, 1 );
66 pMan->pTriv1[0] = Min_CubeAllocVar( pMan, 0, 0 );
67 pMan->pTriv1[1] = Min_CubeAllocVar( pMan, 0, 1 );
68 Min_ManClean( pMan, nVars );
69 return pMan;
70}
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition abc_global.h:264
Min_ManClean
void Min_ManClean(Min_Man_t *p, int nSupp)
Definition covMinMan.c:83
Extra_MmFixedStart
Extra_MmFixed_t * Extra_MmFixedStart(int nEntrySize)
Definition extraUtilMemory.c:122
Min_Man_t
typedefABC_NAMESPACE_IMPL_START struct Min_Man_t_ Min_Man_t
DECLARATIONS ///.
Definition giaPat2.c:34
memset
char * memset()
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_ManClean()

void Min_ManClean ( Min_Man_t * p,
int nSupp )
extern

Function*************************************************************

Synopsis [Cleans the minimization manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 83 of file covMinMan.c.

84{
85 // set the size of the cube manager
86 p->nVars = nSupp;
87 p->nWords = Abc_BitWordNum(2*nSupp);
88 // clean the storage
89 memset( p->ppStore, 0, sizeof(Min_Cube_t *) * (nSupp + 1) );
90 p->nCubes = 0;
91}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_ManFree()

void Min_ManFree ( Min_Man_t * p)
extern

Function*************************************************************

Synopsis [Stops the minimization manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 104 of file covMinMan.c.

105{
106 Extra_MmFixedStop( p->pMemMan );
107 ABC_FREE( p->ppStore );
108 ABC_FREE( p );
109}
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
Extra_MmFixedStop
void Extra_MmFixedStop(Extra_MmFixed_t *p)
Definition extraUtilMemory.c:180
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_SopAddCube()

void Min_SopAddCube ( Min_Man_t * p,
Min_Cube_t * pCube )
extern

Function*************************************************************

Synopsis [Adds the cube to storage.]

Description []

SideEffects []

SeeAlso []

Definition at line 433 of file covMinSop.c.

434{
435 assert( Min_CubeCheck( pCube ) );
436 assert( pCube != p->pBubble );
437 assert( (int)pCube->nLits == Min_CubeCountLits(pCube) );
438 while ( Min_SopAddCubeInt( p, pCube ) );
439}
Min_CubeCheck
int Min_CubeCheck(Min_Cube_t *pCube)
Definition covMinUtil.c:244
Min_SopAddCubeInt
int Min_SopAddCubeInt(Min_Man_t *p, Min_Cube_t *pCube)
Definition covMinSop.c:361
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Min_SopMinimize()

void Min_SopMinimize ( Min_Man_t * p)
extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file covMinSop.c.

48{
49 int nCubesInit, nCubesOld, nIter;
50 if ( p->nCubes < 3 )
51 return;
52 nIter = 0;
53 nCubesInit = p->nCubes;
54 do {
55 nCubesOld = p->nCubes;
56 Min_SopRewrite( p );
57 nIter++;
58// printf( "%d:%d->%d ", nIter, nCubesInit, p->nCubes );
59 }
60 while ( 100.0*(nCubesOld - p->nCubes)/nCubesOld > 3.0 );
61// printf( "\n" );
62
63}
Here is the caller graph for this function: