diff options
Diffstat (limited to 'src/aig')
35 files changed, 6679 insertions, 1214 deletions
diff --git a/src/aig/bbl/bblif.c b/src/aig/bbl/bblif.c new file mode 100644 index 00000000..adc10b28 --- /dev/null +++ b/src/aig/bbl/bblif.c @@ -0,0 +1,1511 @@ +/**CFile**************************************************************** + + FileName [bblif.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Binary BLIF representation for logic networks.] + + Synopsis [Main implementation module.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - February 28, 2009.] + + Revision [$Id: bblif.c,v 1.00 2009/02/28 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <time.h> + +#include "bblif.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +// vector of integers +typedef struct Vec_Int_t_ Vec_Int_t; +struct Vec_Int_t_ +{ + int nCap; + int nSize; + int * pArray; +}; + +// vector of characters +typedef struct Vec_Str_t_ Vec_Str_t; +struct Vec_Str_t_ +{ + int nCap; + int nSize; + char * pArray; +}; + +// network object +struct Bbl_Obj_t_ +{ + int Id; // user ID + int Fnc; // functionality + unsigned fCi : 1; // combinational input + unsigned fCo : 1; // combinational output + unsigned fBox : 1; // subcircuit + unsigned fMark : 1; // temporary mark + unsigned nFanins : 28; // fanin number + int pFanins[0]; // fanin array +}; + +// object function +typedef struct Bbl_Fnc_t_ Bbl_Fnc_t; +struct Bbl_Fnc_t_ +{ + int nWords; // word number + int pWords[0]; // word array +}; + +// object function +typedef struct Bbl_Ent_t_ Bbl_Ent_t; +struct Bbl_Ent_t_ +{ + int iFunc; // function handle + int iNext; // next entry handle +}; + +// data manager +struct Bbl_Man_t_ +{ + // data pool + Vec_Str_t * pName; // design name + Vec_Str_t * pObjs; // vector of objects + Vec_Str_t * pFncs; // vector of functions + // construction + Vec_Int_t * vId2Obj; // mapping user IDs into objects + Vec_Int_t * vObj2Id; // mapping objects into user IDs + Vec_Int_t * vFaninNums; // mapping user IDs into fanin number + // file contents + int nFileSize; // file size + char * pFileData; // file contents + // other data + Vec_Str_t * pEnts; // vector of entries + int SopMap[17][17]; // mapping vars x cubes into entry handles +}; + +static inline int Bbl_ObjIsCi( Bbl_Obj_t * pObj ) { return pObj->fCi; } +static inline int Bbl_ObjIsCo( Bbl_Obj_t * pObj ) { return pObj->fCo; } +static inline int Bbl_ObjIsNode( Bbl_Obj_t * pObj ) { return!pObj->fCi && !pObj->fCo; } + +static inline int Bbl_ObjFaninNum( Bbl_Obj_t * pObj ) { return pObj->nFanins; } +static inline Bbl_Obj_t * Bbl_ObjFanin( Bbl_Obj_t * pObj, int i ) { return (Bbl_Obj_t *)(((char *)pObj) - pObj->pFanins[i]); } + +static inline int Bbl_ObjSize( Bbl_Obj_t * pObj ) { return sizeof(Bbl_Obj_t) + sizeof(int) * pObj->nFanins; } +static inline int Bbl_FncSize( Bbl_Fnc_t * pFnc ) { return sizeof(Bbl_Fnc_t) + sizeof(int) * pFnc->nWords; } + +static inline Bbl_Obj_t * Bbl_VecObj( Vec_Str_t * p, int h ) { return (Bbl_Obj_t *)(p->pArray + h); } +static inline Bbl_Fnc_t * Bbl_VecFnc( Vec_Str_t * p, int h ) { return (Bbl_Fnc_t *)(p->pArray + h); } +static inline Bbl_Ent_t * Bbl_VecEnt( Vec_Str_t * p, int h ) { return (Bbl_Ent_t *)(p->pArray + h); } + +static inline char * Bbl_ManSop( Bbl_Man_t * p, int h ) { return (char *)Bbl_VecFnc(p->pFncs, h)->pWords; } +static inline Bbl_Obj_t * Bbl_ManObj( Bbl_Man_t * p, int Id ) { return Bbl_VecObj(p->pObjs, p->vId2Obj->pArray[Id]); } + +#define Bbl_ManForEachObj_int( p, pObj, h ) \ + for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecObj(p,h)); h += Bbl_ObjSize(pObj) ) +#define Bbl_ManForEachFnc_int( p, pObj, h ) \ + for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecFnc(p,h)); h += Bbl_FncSize(pObj) ) +#define Bbl_ObjForEachFanin_int( pObj, pFanin, i ) \ + for ( i = 0; (i < (int)pObj->nFanins) && (pFanin = Bbl_ObjFanin(pObj,i)); i++ ) + +#define BBLIF_ALLOC(type, num) ((type *) malloc(sizeof(type) * (num))) +#define BBLIF_CALLOC(type, num) ((type *) calloc((num), sizeof(type))) +#define BBLIF_FALLOC(type, num) ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num))) +#define BBLIF_FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0) +#define BBLIF_REALLOC(type, obj, num) \ + ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \ + ((type *) malloc(sizeof(type) * (num)))) + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Allocates a vector with the given capacity.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Vec_IntAlloc( int nCap ) +{ + Vec_Int_t * p; + p = BBLIF_ALLOC( Vec_Int_t, 1 ); + if ( nCap > 0 && nCap < 16 ) + nCap = 16; + p->nSize = 0; + p->nCap = nCap; + p->pArray = p->nCap? BBLIF_ALLOC( int, p->nCap ) : NULL; + return p; +} + +/**Function************************************************************* + + Synopsis [Allocates a vector with the given size and cleans it.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Vec_IntStart( int nSize ) +{ + Vec_Int_t * p; + p = Vec_IntAlloc( nSize ); + p->nSize = nSize; + memset( p->pArray, 0, sizeof(int) * nSize ); + return p; +} + +/**Function************************************************************* + + Synopsis [Allocates a vector with the given size and cleans it.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Vec_IntStartNatural( int nSize ) +{ + Vec_Int_t * p; + int i; + p = Vec_IntAlloc( nSize ); + p->nSize = nSize; + for ( i = 0; i < nSize; i++ ) + p->pArray[i] = i; + return p; +} + +/**Function************************************************************* + + Synopsis [Creates the vector from an integer array of the given size.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Int_t * Vec_IntAllocArray( int * pArray, int nSize ) +{ + Vec_Int_t * p; + p = BBLIF_ALLOC( Vec_Int_t, 1 ); + p->nSize = nSize; + p->nCap = nSize; + p->pArray = pArray; + return p; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntFree( Vec_Int_t * p ) +{ + BBLIF_FREE( p->pArray ); + BBLIF_FREE( p ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_IntSize( Vec_Int_t * p ) +{ + return p->nSize; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_IntEntry( Vec_Int_t * p, int i ) +{ + assert( i >= 0 && i < p->nSize ); + return p->pArray[i]; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry ) +{ + assert( i >= 0 && i < p->nSize ); + p->pArray[i] = Entry; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition ) +{ + assert( i >= 0 && i < p->nSize ); + p->pArray[i] += Addition; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_IntEntryLast( Vec_Int_t * p ) +{ + assert( p->nSize > 0 ); + return p->pArray[p->nSize-1]; +} + +/**Function************************************************************* + + Synopsis [Resizes the vector to the given capacity.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin ) +{ + if ( p->nCap >= nCapMin ) + return; + p->pArray = BBLIF_REALLOC( int, p->pArray, nCapMin ); + assert( p->pArray ); + p->nCap = nCapMin; +} + +/**Function************************************************************* + + Synopsis [Fills the vector with given number of entries.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntFill( Vec_Int_t * p, int nSize, int Fill ) +{ + int i; + Vec_IntGrow( p, nSize ); + for ( i = 0; i < nSize; i++ ) + p->pArray[i] = Fill; + p->nSize = nSize; +} + +/**Function************************************************************* + + Synopsis [Fills the vector with given number of entries.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Fill ) +{ + int i; + if ( p->nSize >= nSize ) + return; + if ( nSize < 2 * p->nSize ) + nSize = 2 * p->nSize; + Vec_IntGrow( p, nSize ); + for ( i = p->nSize; i < nSize; i++ ) + p->pArray[i] = Fill; + p->nSize = nSize; +} + +/**Function************************************************************* + + Synopsis [Returns the entry even if the place not exist.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_IntGetEntry( Vec_Int_t * p, int i ) +{ + Vec_IntFillExtra( p, i + 1, 0 ); + return Vec_IntEntry( p, i ); +} + +/**Function************************************************************* + + Synopsis [Inserts the entry even if the place does not exist.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntSetEntry( Vec_Int_t * p, int i, int Entry ) +{ + Vec_IntFillExtra( p, i + 1, 0 ); + Vec_IntWriteEntry( p, i, Entry ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntShrink( Vec_Int_t * p, int nSizeNew ) +{ + assert( p->nSize >= nSizeNew ); + p->nSize = nSizeNew; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntClear( Vec_Int_t * p ) +{ + p->nSize = 0; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_IntPush( Vec_Int_t * p, int Entry ) +{ + if ( p->nSize == p->nCap ) + { + if ( p->nCap < 16 ) + Vec_IntGrow( p, 16 ); + else + Vec_IntGrow( p, 2 * p->nCap ); + } + p->pArray[p->nSize++] = Entry; +} + + + + + +/**Function************************************************************* + + Synopsis [Allocates a vector with the given capacity.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Str_t * Vec_StrAlloc( int nCap ) +{ + Vec_Str_t * p; + p = BBLIF_ALLOC( Vec_Str_t, 1 ); + if ( nCap > 0 && nCap < 16 ) + nCap = 16; + p->nSize = 0; + p->nCap = nCap; + p->pArray = p->nCap? BBLIF_ALLOC( char, p->nCap ) : NULL; + return p; +} + +/**Function************************************************************* + + Synopsis [Creates the vector from an array of the given size.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Vec_Str_t * Vec_StrAllocArray( char * pArray, int nSize ) +{ + Vec_Str_t * p; + p = BBLIF_ALLOC( Vec_Str_t, 1 ); + p->nSize = nSize; + p->nCap = nSize; + p->pArray = pArray; + return p; +} + +/**Fnction************************************************************* + + Synopsis [Returns a piece of memory.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Vec_StrFetch( Vec_Str_t * p, int nBytes ) +{ + while ( p->nSize + nBytes > p->nCap ) + { + p->pArray = BBLIF_REALLOC( char, p->pArray, 3 * p->nCap ); + p->nCap *= 3; + } + p->nSize += nBytes; + return p->pArray + p->nSize - nBytes; +} + +/**Fnction************************************************************* + + Synopsis [Write vector into file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Vec_StrWrite( FILE * pFile, Vec_Str_t * p ) +{ + fwrite( &p->nSize, sizeof(int), 1, pFile ); + fwrite( p->pArray, sizeof(char), p->nSize, pFile ); +} + +/**Fnction************************************************************* + + Synopsis [Write vector into file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Vec_Str_t * Vec_StrRead( char ** ppStr ) +{ + Vec_Str_t * p; + char * pStr = *ppStr; + p = Vec_StrAlloc( 0 ); + p->nSize = *(int *)pStr; + p->pArray = pStr + sizeof(int); + *ppStr = pStr + sizeof(int) + p->nSize * sizeof(char); + return p; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Vec_StrSize( Vec_Str_t * p ) +{ + return p->nSize; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_StrFree( Vec_Str_t * p ) +{ + BBLIF_FREE( p->pArray ); + BBLIF_FREE( p ); +} + + + + + +/**Fnction************************************************************* + + Synopsis [Returns the file size.] + + Description [The file should be closed.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManFileSize( char * pFileName ) +{ + FILE * pFile; + int nFileSize; + pFile = fopen( pFileName, "r" ); + if ( pFile == NULL ) + { + printf( "Bbl_ManFileSize(): The file is unavailable (absent or open).\n" ); + return 0; + } + fseek( pFile, 0, SEEK_END ); + nFileSize = ftell( pFile ); + fclose( pFile ); + return nFileSize; +} + +/**Fnction************************************************************* + + Synopsis [Read data from file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Bbl_ManFileRead( char * pFileName ) +{ + FILE * pFile; + char * pContents; + int nFileSize; + nFileSize = Bbl_ManFileSize( pFileName ); + pFile = fopen( pFileName, "rb" ); + pContents = BBLIF_ALLOC( char, nFileSize ); + fread( pContents, nFileSize, 1, pFile ); + fclose( pFile ); + return pContents; +} + + + +/**Fnction************************************************************* + + Synopsis [Writes data into file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManDumpBinaryBlif( Bbl_Man_t * p, char * pFileName ) +{ + FILE * pFile; + pFile = fopen( pFileName, "wb" ); + Vec_StrWrite( pFile, p->pName ); + Vec_StrWrite( pFile, p->pObjs ); + Vec_StrWrite( pFile, p->pFncs ); + fclose( pFile ); +} + +/**Fnction************************************************************* + + Synopsis [Creates manager after reading.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Man_t * Bbl_ManReadBinaryBlif( char * pFileName ) +{ + Bbl_Man_t * p; + Bbl_Obj_t * pObj; + char * pBuffer; + int h; + p = BBLIF_ALLOC( Bbl_Man_t, 1 ); + memset( p, 0, sizeof(Bbl_Man_t) ); + p->nFileSize = Bbl_ManFileSize( pFileName ); + p->pFileData = Bbl_ManFileRead( pFileName ); + // extract three managers + pBuffer = p->pFileData; + p->pName = Vec_StrRead( &pBuffer ); + p->pObjs = Vec_StrRead( &pBuffer ); + p->pFncs = Vec_StrRead( &pBuffer ); + assert( pBuffer - p->pFileData == p->nFileSize ); + // remember original IDs in the objects + p->vObj2Id = Vec_IntAlloc( 1000 ); + Bbl_ManForEachObj_int( p->pObjs, pObj, h ) + { + Vec_IntPush( p->vObj2Id, pObj->Id ); + pObj->Id = Vec_IntSize(p->vObj2Id) - 1; + } + return p; +} + +/**Fnction************************************************************* + + Synopsis [Prints stats of the manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManPrintStats( Bbl_Man_t * p ) +{ + Bbl_Obj_t * pObj; + Bbl_Fnc_t * pFnc; + int h, nFuncs = 0, nNodes = 0, nObjs = 0; + Bbl_ManForEachObj_int( p->pObjs, pObj, h ) + nObjs++, nNodes += Bbl_ObjIsNode(pObj); + Bbl_ManForEachFnc_int( p->pFncs, pFnc, h ) + nFuncs++; + printf( "Total objects = %7d. Total nodes = %7d. Unique functions = %7d.\n", nObjs, nNodes, nFuncs ); + printf( "Name manager = %5.2f Mb\n", 1.0*Vec_StrSize(p->pName)/(1 << 20) ); + printf( "Objs manager = %5.2f Mb\n", 1.0*Vec_StrSize(p->pObjs)/(1 << 20) ); + printf( "Fncs manager = %5.2f Mb\n", 1.0*Vec_StrSize(p->pFncs)/(1 << 20) ); +} + +/**Fnction************************************************************* + + Synopsis [Deletes the manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManStop( Bbl_Man_t * p ) +{ + if ( p->vId2Obj ) Vec_IntFree( p->vId2Obj ); + if ( p->vObj2Id ) Vec_IntFree( p->vObj2Id ); + if ( p->vFaninNums ) Vec_IntFree( p->vFaninNums ); + if ( p->pFileData ) + { + BBLIF_FREE( p->pFileData ); + p->pName->pArray = NULL; + p->pObjs->pArray = NULL; + p->pFncs->pArray = NULL; + } + if ( p->pEnts ) + Vec_StrFree( p->pEnts ); + Vec_StrFree( p->pName ); + Vec_StrFree( p->pObjs ); + Vec_StrFree( p->pFncs ); + BBLIF_FREE( p ); +} + +/**Fnction************************************************************* + + Synopsis [Creates manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Man_t * Bbl_ManStart( char * pName ) +{ + Bbl_Man_t * p; + int nLength; + p = BBLIF_ALLOC( Bbl_Man_t, 1 ); + memset( p, 0, sizeof(Bbl_Man_t) ); + nLength = pName? 4 * ((strlen(pName) + 1) / 4 + 1) : 0; + p->pName = Vec_StrAlloc( nLength ); + p->pName->nSize = p->pName->nCap; + if ( pName ) + strcpy( p->pName->pArray, pName ); + p->pObjs = Vec_StrAlloc( 1 << 16 ); + p->pFncs = Vec_StrAlloc( 1 << 16 ); + p->pEnts = Vec_StrAlloc( 1 << 16 ); p->pEnts->nSize = 1; + p->vId2Obj = Vec_IntStart( 1 << 10 ); + p->vFaninNums = Vec_IntStart( 1 << 10 ); + return p; +} + + + + +/**Function************************************************************* + + Synopsis [Performs selection sort on the array of cubes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManSortCubes( char ** pCubes, int nCubes, int nVars ) +{ + char * pTemp; + int i, j, best_i; + for ( i = 0; i < nCubes-1; i++ ) + { + best_i = i; + for (j = i+1; j < nCubes; j++) + if ( memcmp( pCubes[j], pCubes[best_i], nVars ) < 0 ) + best_i = j; + pTemp = pCubes[i]; pCubes[i] = pCubes[best_i]; pCubes[best_i] = pTemp; + } +} + +/**Function************************************************************* + + Synopsis [Sorts the cubes in the SOP to uniqify them to some extent.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Bbl_ManSortSop( char * pSop, int nVars ) +{ + char ** pCubes, * pSopNew; + int c, Length, nCubes; + Length = strlen(pSop); + assert( Length % (nVars + 3) == 0 ); + nCubes = Length / (nVars + 3); + if ( nCubes < 2 ) + { + pSopNew = BBLIF_ALLOC( char, Length + 1 ); + memcpy( pSopNew, pSop, Length + 1 ); + return pSopNew; + } + pCubes = BBLIF_ALLOC( char *, nCubes ); + for ( c = 0; c < nCubes; c++ ) + pCubes[c] = pSop + c * (nVars + 3); + if ( nCubes < 300 ) + Bbl_ManSortCubes( pCubes, nCubes, nVars ); + pSopNew = BBLIF_ALLOC( char, Length + 1 ); + for ( c = 0; c < nCubes; c++ ) + memcpy( pSopNew + c * (nVars + 3), pCubes[c], nVars + 3 ); + BBLIF_FREE( pCubes ); + pSopNew[nCubes * (nVars + 3)] = 0; + return pSopNew; +} + +/**Fnction************************************************************* + + Synopsis [Saves one entry.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManCreateEntry( Bbl_Man_t * p, int iFunc, int iNext ) +{ + Bbl_Ent_t * pEnt; + pEnt = (Bbl_Ent_t *)Vec_StrFetch( p->pEnts, 2 * sizeof(int) ); + pEnt->iFunc = iFunc; + pEnt->iNext = iNext; + return (char *)pEnt - p->pEnts->pArray; +} + +/**Function************************************************************* + + Synopsis [Sorts the cubes in the SOP to uniqify them to some extent.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManSopCheckUnique( Bbl_Man_t * p, char * pSop, int nVars, int nCubes, int iFunc ) +{ + Bbl_Fnc_t * pFnc; + Bbl_Ent_t * pEnt; + int h, Length = strlen(pSop) + 1; + int nWords = (Length / 4 + (Length % 4 > 0)); + if ( nVars > 16 ) nVars = 16; + if ( nCubes > 16 ) nCubes = 16; +// if ( nVars == 16 && nCubes == 16 ) +// return iFunc; + for ( h = p->SopMap[nVars][nCubes]; h; h = pEnt->iNext ) + { + pEnt = Bbl_VecEnt( p->pEnts, h ); + pFnc = Bbl_VecFnc( p->pFncs, pEnt->iFunc ); + assert( nVars == 16 || nCubes == 16 || pFnc->nWords == nWords ); + if ( pFnc->nWords == nWords && memcmp( pFnc->pWords, pSop, Length ) == 0 ) + return pEnt->iFunc; + } + p->SopMap[nVars][nCubes] = Bbl_ManCreateEntry( p, iFunc, p->SopMap[nVars][nCubes] ); + return iFunc; +} + +/**Fnction************************************************************* + + Synopsis [Saves one SOP.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManSaveSop( Bbl_Man_t * p, char * pSop, int nVars ) +{ + Bbl_Fnc_t * pFnc; + char * pSopNew; + int iFunc, Length = strlen(pSop) + 1; + int nWords = Length / 4 + (Length % 4 > 0); + // reorder cubes to semi-canicize SOPs + pSopNew = Bbl_ManSortSop( pSop, nVars ); + // get the candidate location + iFunc = Bbl_ManSopCheckUnique( p, pSopNew, nVars, Length / (nVars + 3), Vec_StrSize(p->pFncs) ); +// iFunc = Vec_StrSize(p->pFncs); + if ( iFunc == Vec_StrSize(p->pFncs) ) + { // store this SOP + pFnc = (Bbl_Fnc_t *)Vec_StrFetch( p->pFncs, sizeof(Bbl_Fnc_t) + nWords * sizeof(int) ); + pFnc->pWords[nWords-1] = 0; + pFnc->nWords = nWords; + strcpy( (char *)pFnc->pWords, pSopNew ); + assert( iFunc == (char *)pFnc - p->pFncs->pArray ); + } + BBLIF_FREE( pSopNew ); + return iFunc; +} + +/**Fnction************************************************************* + + Synopsis [Adds one object.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManCreateObject( Bbl_Man_t * p, Bbl_Type_t Type, int ObjId, int nFanins, char * pSop ) +{ + Bbl_Obj_t * pObj; + if ( Type == BBL_OBJ_CI && nFanins != 0 ) + { + printf( "Attempting to create a combinational input with %d fanins (should be 0).\n", nFanins ); + return; + } + if ( Type == BBL_OBJ_CO && nFanins != 1 ) + { + printf( "Attempting to create a combinational output with %d fanins (should be 1).\n", nFanins ); + return; + } + pObj = (Bbl_Obj_t *)Vec_StrFetch( p->pObjs, sizeof(Bbl_Obj_t) + nFanins * sizeof(int) ); + memset( pObj, 0, sizeof(Bbl_Obj_t) ); + Vec_IntSetEntry( p->vId2Obj, ObjId, (char *)pObj - p->pObjs->pArray ); + Vec_IntSetEntry( p->vFaninNums, ObjId, 0 ); + pObj->fCi = (Type == BBL_OBJ_CI); + pObj->fCo = (Type == BBL_OBJ_CO); + pObj->Id = ObjId; + pObj->Fnc = pSop? Bbl_ManSaveSop(p, pSop, nFanins) : -1; + pObj->nFanins = nFanins; +} + +/**Fnction************************************************************* + + Synopsis [Creates fanin/fanout relationship between two objects.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManAddFanin( Bbl_Man_t * p, int ObjId, int FaninId ) +{ + Bbl_Obj_t * pObj, * pFanin; + int iFanin; + pObj = Bbl_ManObj( p, ObjId ); + if ( Bbl_ObjIsCi(pObj) ) + { + printf( "Bbl_ManAddFanin(): Cannot add fanin of the combinational input (Id = %d).\n", ObjId ); + return; + } + pFanin = Bbl_ManObj( p, FaninId ); + if ( Bbl_ObjIsCo(pFanin) ) + { + printf( "Bbl_ManAddFanin(): Cannot add fanout of the combinational output (Id = %d).\n", FaninId ); + return; + } + iFanin = Vec_IntEntry( p->vFaninNums, ObjId ); + if ( iFanin >= (int)pObj->nFanins ) + { + printf( "Bbl_ManAddFanin(): Trying to add more fanins to object (Id = %d) than declared (%d).\n", ObjId, pObj->nFanins ); + return; + } + assert( iFanin < (int)pObj->nFanins ); + Vec_IntWriteEntry( p->vFaninNums, ObjId, iFanin+1 ); + pObj->pFanins[iFanin] = (char *)pObj - (char *)pFanin; +} + + +/**Fnction************************************************************* + + Synopsis [Returns 1 if the manager was created correctly.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManCheck( Bbl_Man_t * p ) +{ + Bbl_Obj_t * pObj; + int h, RetValue = 1; + Bbl_ManForEachObj_int( p->pObjs, pObj, h ) + { + if ( Bbl_ObjIsNode(pObj) && pObj->Fnc == -1 ) + RetValue = 0, printf( "Bbl_ManCheck(): Node %d does not have function specified.\n", pObj->Id ); + if ( Bbl_ObjIsCi(pObj) && pObj->Fnc != -1 ) + RetValue = 0, printf( "Bbl_ManCheck(): CI with %d has function specified.\n", pObj->Id ); + if ( Bbl_ObjIsCo(pObj) && pObj->Fnc != -1 ) + RetValue = 0, printf( "Bbl_ManCheck(): CO with %d has function specified.\n", pObj->Id ); + if ( Vec_IntEntry(p->vFaninNums, pObj->Id) != (int)pObj->nFanins ) + RetValue = 0, printf( "Bbl_ManCheck(): Object %d has less fanins (%d) than declared (%d).\n", + pObj->Id, Vec_IntEntry(p->vFaninNums, pObj->Id), pObj->nFanins ); + } + return RetValue; +} + + +/**Fnction************************************************************* + + Synopsis [Misc APIs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ObjIsInput( Bbl_Obj_t * p ) { return Bbl_ObjIsCi(p); } +int Bbl_ObjIsOutput( Bbl_Obj_t * p ) { return Bbl_ObjIsCo(p); } +int Bbl_ObjIsLut( Bbl_Obj_t * p ) { return Bbl_ObjIsNode(p); } +int Bbl_ObjId( Bbl_Obj_t * p ) { return p->Id; } +int Bbl_ObjIdOriginal( Bbl_Man_t * pMan, Bbl_Obj_t * p ) { assert(0); return Vec_IntEntry(pMan->vObj2Id, p->Id); } +int Bbl_ObjFaninNumber( Bbl_Obj_t * p ) { return Bbl_ObjFaninNum(p); } +char * Bbl_ObjSop( Bbl_Man_t * pMan, Bbl_Obj_t * p ) { return Bbl_ManSop(pMan, p->Fnc); } +int Bbl_ObjIsMarked( Bbl_Obj_t * p ) { return p->fMark; } +void Bbl_ObjMark( Bbl_Obj_t * p ) { p->fMark = 1; } +int Bbl_ObjFncHandle( Bbl_Obj_t * p ) { return p->Fnc; } + +/**Fnction************************************************************* + + Synopsis [Returns the name of the design.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Bbl_ManName( Bbl_Man_t * p ) +{ + return p->pName->pArray; +} + +/**Fnction************************************************************* + + Synopsis [Returns the maximum handle of the SOP.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Bbl_ManFncSize( Bbl_Man_t * p ) +{ + return p->pFncs->nSize; +} + +/**Fnction************************************************************* + + Synopsis [Returns the first object.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Obj_t * Bbl_ManObjFirst( Bbl_Man_t * p ) +{ + return Bbl_VecObj( p->pObjs, 0 ); +} + +/**Fnction************************************************************* + + Synopsis [Returns the next object.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Obj_t * Bbl_ManObjNext( Bbl_Man_t * p, Bbl_Obj_t * pObj ) +{ + char * pNext = (char *)pObj + Bbl_ObjSize(pObj); + char * pEdge = p->pObjs->pArray + p->pObjs->nSize; + return (Bbl_Obj_t *)(pNext < pEdge ? pNext : NULL); +} + +/**Fnction************************************************************* + + Synopsis [Returns the first fanin.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Obj_t * Bbl_ObjFaninFirst( Bbl_Obj_t * p ) +{ + return Bbl_ObjFaninNum(p) ? Bbl_ObjFanin( p, 0 ) : NULL; +} + +/**Fnction************************************************************* + + Synopsis [Returns the next fanin.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Bbl_Obj_t * Bbl_ObjFaninNext( Bbl_Obj_t * p, Bbl_Obj_t * pPrev ) +{ + Bbl_Obj_t * pFanin; + int i; + Bbl_ObjForEachFanin_int( p, pFanin, i ) + if ( pFanin == pPrev ) + break; + return i < Bbl_ObjFaninNum(p) - 1 ? Bbl_ObjFanin( p, i+1 ) : NULL; +} + +/**Fnction************************************************************* + + Synopsis [Drives text BLIF file for debugging.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManDumpBlif( Bbl_Man_t * p, char * pFileName ) +{ + FILE * pFile; + Bbl_Obj_t * pObj, * pFanin; + pFile = fopen( pFileName, "w" ); + fprintf( pFile, "# Test file written by Bbl_ManDumpBlif() in ABC.\n" ); + fprintf( pFile, ".model %s\n", Bbl_ManName(p) ); + // write objects + Bbl_ManForEachObj( p, pObj ) + { + if ( Bbl_ObjIsInput(pObj) ) + fprintf( pFile, ".inputs %d\n", Bbl_ObjId(pObj) ); + else if ( Bbl_ObjIsOutput(pObj) ) + fprintf( pFile, ".outputs %d\n", Bbl_ObjId(pObj) ); + else if ( Bbl_ObjIsLut(pObj) ) + { + fprintf( pFile, ".names" ); + Bbl_ObjForEachFanin( pObj, pFanin ) + fprintf( pFile, " %d", Bbl_ObjId(pFanin) ); + fprintf( pFile, " %d\n", Bbl_ObjId(pObj) ); + fprintf( pFile, "%s", Bbl_ObjSop(p, pObj) ); + } + else assert( 0 ); + } + // write output drivers + Bbl_ManForEachObj( p, pObj ) + { + if ( !Bbl_ObjIsOutput(pObj) ) + continue; + fprintf( pFile, ".names" ); + Bbl_ObjForEachFanin( pObj, pFanin ) + fprintf( pFile, " %d", Bbl_ObjId(pFanin) ); + fprintf( pFile, " %d\n", Bbl_ObjId(pObj) ); + fprintf( pFile, "1 1\n" ); + } + fprintf( pFile, ".end\n" ); + fclose( pFile ); +} + +/**Fnction************************************************************* + + Synopsis [Converting truth table into an SOP.] + + Description [The truth table is given as a bit-string pTruth + composed of 2^nVars bits. The result is an SOP derived by + collecting minterms appearing in the truth table. The SOP is + represented as a C-string, as documented in file "bblif.h". + It is recommended to limit the use of this procedure to Boolean + functions up to 6 inputs.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Bbl_ManTruthToSop( unsigned * pTruth, int nVars ) +{ + char * pResult, * pTemp; + int nMints, nOnes, b, v; + assert( nVars >= 0 && nVars <= 16 ); + nMints = (1 << nVars); + // count the number of ones + nOnes = 0; + for ( b = 0; b < nMints; b++ ) + nOnes += ((pTruth[b>>5] >> (b&31)) & 1); + // handle constants + if ( nOnes == 0 || nOnes == nMints ) + { + pResult = pTemp = BBLIF_ALLOC( char, nVars + 4 ); + for ( v = 0; v < nVars; v++ ) + *pTemp++ = '-'; + *pTemp++ = ' '; + *pTemp++ = nOnes? '1' : '0'; + *pTemp++ = '\n'; + *pTemp++ = 0; + assert( pTemp - pResult == nVars + 4 ); + return pResult; + } + pResult = pTemp = BBLIF_ALLOC( char, nOnes * (nVars + 3) + 1 ); + for ( b = 0; b < nMints; b++ ) + { + if ( ((pTruth[b>>5] >> (b&31)) & 1) == 0 ) + continue; + for ( v = 0; v < nVars; v++ ) + *pTemp++ = ((b >> v) & 1)? '1' : '0'; + *pTemp++ = ' '; + *pTemp++ = '1'; + *pTemp++ = '\n'; + } + *pTemp++ = 0; + assert( pTemp - pResult == nOnes * (nVars + 3) + 1 ); + return pResult; +} + +/**Function************************************************************* + + Synopsis [Allocates the array of truth tables for the given number of vars.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Bbl_ManSopToTruthElem( int nVars, unsigned ** pVars ) +{ + unsigned Masks[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 }; + int i, k, nWords; + nWords = (nVars <= 5 ? 1 : (1 << (nVars - 5))); + for ( i = 0; i < nVars; i++ ) + { + if ( i < 5 ) + { + for ( k = 0; k < nWords; k++ ) + pVars[i][k] = Masks[i]; + } + else + { + for ( k = 0; k < nWords; k++ ) + if ( k & (1 << (i-5)) ) + pVars[i][k] = ~(unsigned)0; + else + pVars[i][k] = 0; + } + } +} + +/**Fnction************************************************************* + + Synopsis [Converting SOP into a truth table.] + + Description [The SOP is represented as a C-string, as documented in + file "bblif.h". The truth table is returned as a bit-string composed + of 2^nVars bits. For functions of less than 6 variables, the full + machine word is returned. (The truth table looks as if the function + had 5 variables.) The use of this procedure should be limited to + Boolean functions with no more than 16 inputs.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +unsigned * Bbl_ManSopToTruth( char * pSop, int nVars ) +{ + unsigned * pTruth, * pCube, * pVars[16]; + int nWords = nVars <= 5 ? 1 : (1 << (nVars - 5)); + int v, c, w, nCubes, fCompl = 0; + if ( pSop == NULL ) + return NULL; + if ( strlen(pSop) % (nVars + 3) != 0 ) + { + printf( "Bbl_ManSopToTruth(): SOP is represented incorrectly.\n" ); + return NULL; + } + // create storage for TTs of the result, elementary variables and the temp cube + pTruth = BBLIF_ALLOC( unsigned, nWords ); + pVars[0] = BBLIF_ALLOC( unsigned, nWords * (nVars+1) ); + for ( v = 1; v < nVars; v++ ) + pVars[v] = pVars[v-1] + nWords; + pCube = pVars[v-1] + nWords; + Bbl_ManSopToTruthElem( nVars, pVars ); + // iterate through the cubes + memset( pTruth, 0, sizeof(unsigned) * nWords ); + nCubes = strlen(pSop) / (nVars + 3); + for ( c = 0; c < nCubes; c++ ) + { + fCompl = (pSop[nVars+1] == '0'); + memset( pCube, 0xff, sizeof(unsigned) * nWords ); + // iterate through the literals of the cube + for ( v = 0; v < nVars; v++ ) + if ( pSop[v] == '1' ) + for ( w = 0; w < nWords; w++ ) + pCube[w] &= pVars[v][w]; + else if ( pSop[v] == '0' ) + for ( w = 0; w < nWords; w++ ) + pCube[w] &= ~pVars[v][w]; + // add cube to storage + for ( w = 0; w < nWords; w++ ) + pTruth[w] |= pCube[w]; + // go to the next cube + pSop += (nVars + 3); + } + BBLIF_FREE( pVars[0] ); + if ( fCompl ) + for ( w = 0; w < nWords; w++ ) + pTruth[w] = ~pTruth[w]; + return pTruth; +} + + +/**Fnction************************************************************* + + Synopsis [Checks the truth table computation.] + + Description [We construct the logic network for the half-adder represnted + using the BLIF file below] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManTestTruth( char * pSop, int nVars ) +{ + unsigned * pTruth; + char * pSopNew; + pTruth = Bbl_ManSopToTruth( pSop, nVars ); + pSopNew = Bbl_ManTruthToSop( pTruth, nVars ); + printf( "Old SOP:\n%s\n", pSop ); + printf( "New SOP:\n%s\n", pSopNew ); + BBLIF_FREE( pSopNew ); + BBLIF_FREE( pTruth ); +} + +/**Fnction************************************************************* + + Synopsis [This demo shows using the internal to construct a half-adder.] + + Description [We construct the logic network for the half-adder represnted + using the BLIF file below] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Bbl_ManSimpleDemo() +{ +/* + # There are contents of a BLIF file representing a half-adder: + .model hadder + .inputs a // ID = 1 + .inputs b // ID = 2 + .inputs cin // ID = 3 + .outputs s // ID = 4 + .outputs cout // ID = 5 + .names a b cin s_driver // ID = 6 + 100 1 + 010 1 + 001 1 + 111 1 + .names a b cin cout_driver // ID = 7 + -11 1 + 1-1 1 + 11- 1 + .names s_driver s + 1 1 + .names cout_driver cout + 1 1 + .end +*/ + Bbl_Man_t * p; + // start the data manager + p = Bbl_ManStart( "hadder" ); + // create CIs + Bbl_ManCreateObject( p, BBL_OBJ_CI, 1, 0, NULL ); // a + Bbl_ManCreateObject( p, BBL_OBJ_CI, 2, 0, NULL ); // b + Bbl_ManCreateObject( p, BBL_OBJ_CI, 3, 0, NULL ); // cin + // create COs + Bbl_ManCreateObject( p, BBL_OBJ_CO, 4, 1, NULL ); // s + Bbl_ManCreateObject( p, BBL_OBJ_CO, 5, 1, NULL ); // cout + // create internal nodes + Bbl_ManCreateObject( p, BBL_OBJ_NODE, 6, 3, "100 1\n010 1\n001 1\n111 1\n" ); // s_driver + Bbl_ManCreateObject( p, BBL_OBJ_NODE, 7, 3, "-11 1\n1-1 1\n11- 1\n" ); // cout_driver + // add fanins of node 6 + Bbl_ManAddFanin( p, 6, 1 ); // s_driver <- a + Bbl_ManAddFanin( p, 6, 2 ); // s_driver <- b + Bbl_ManAddFanin( p, 6, 3 ); // s_driver <- cin + // add fanins of node 7 + Bbl_ManAddFanin( p, 7, 1 ); // cout_driver <- a + Bbl_ManAddFanin( p, 7, 2 ); // cout_driver <- b + Bbl_ManAddFanin( p, 7, 3 ); // cout_driver <- cin + // add fanins of COs + Bbl_ManAddFanin( p, 4, 6 ); // s <- s_driver + Bbl_ManAddFanin( p, 5, 7 ); // cout <- cout_driver + // sanity check + Bbl_ManCheck( p ); + // write BLIF file as a sanity check + Bbl_ManDumpBlif( p, "hadder.blif" ); + // write binary BLIF file + Bbl_ManDumpBinaryBlif( p, "hadder.bblif" ); + // remove the manager + Bbl_ManStop( p ); + + +// Bbl_ManTestTruth( "100 1\n010 1\n001 1\n111 1\n", 3 ); +// Bbl_ManTestTruth( "-11 0\n1-1 0\n11- 0\n", 3 ); +// Bbl_ManTestTruth( "--- 1\n", 3 ); +} + + + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/bbl/bblif.h b/src/aig/bbl/bblif.h new file mode 100644 index 00000000..db3eb2f5 --- /dev/null +++ b/src/aig/bbl/bblif.h @@ -0,0 +1,273 @@ +/**CFile**************************************************************** + + FileName [bblif.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Binary BLIF representation for logic networks.] + + Synopsis [External declarations.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - February 28, 2009.] + + Revision [$Id: bblif.h,v 1.00 2009/02/28 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef __BBLIF_H__ +#define __BBLIF_H__ + +/* + This file (taken together with "bblif.c") implements a stand-alone + interface between ABC and an application that uses ABC. + + The interface is designed to pass a combinational logic network + from the calling application to ABC using a binary BLIF format (BBLIF) + and return the network after synthesis/mapping/verification in ABC + back to the caller. + + The interface can do the following: + (1) accept a combinational logic network via a set of APIs + (2) write the logic network into a binary BLIF file readable by ABC + (3) read a binary BLIF file with a mapped network produced by ABC + (4) return the mapped network to the caller through a set of APIs + + Here these steps are described in more detail: + + (1) The BBLIF manager is allocated by calling Bbl_ManStart() and + deallocated by calling Bbl_ManStop(). + + The combinational network is composed of three types of objects: + (a) combinational inputs (CIs), (b) combinational outputs (COs), + (c) internal logic nodes represented using Sum-of-Products (SOPs) + similar to the way logic nodes are represented in SIS. Sequential + elements (flops) are currently not supported. A CI has no fanins. + A CO has exactly one fanin and no fanouts. Internal nodes can + have any number of fanins and fanouts. Only an internal node can + have a logic function. + + Before constructing the BBLIF manager, each object should be + assigned a unique non-negative (0-based) integer ID. The sequence + of ID numbers may have gaps in it (for example, 0, 1, 2, 5, 6, etc) + but care should be taken that the ID numbers do not grow too large + because internally they are used to index the objects. So if + the largest given ID has value N, an array of 4*N bytes will be + allocated internally by the BBLIF manager. Obviously if N = 1M, + the array will use 4Mb, but if N = 100M, it will use 0.4Gb. + + This object ID (called also "the original ID of the object") is + given to Bbl_ManCreateObject(), which construct the BBLIF objects + and to the procedure Bbl_ManAddFanin(), which creates fanin/fanout + relations between two objects. The exact number of fanins of an + object should be declared when calling Bbl_ManCreateObject(). + Later on, each node should be assigned as many fanins using + Bbl_ManAddFanin(). The order/number of fanins corresponds to the + order/number of variables in the SOP of the logic function of the + node. The declared and actual number of fanins should be the same. + otherwise the interface will not function correctly. This is checked + by the procedure Bbl_ManCheck(), which should be called when + constructing all objects and their fanins is finished. + + The SOP representation of the logic function should be given to + every internal node. It is given as a C-string, showing the SOP + as it would appear in a BLIF or PLA file. Each cube is composed + of characters '0', '1', and '-', and ended by a seqence of three + characters: space ' ', followed by '0' or '1' (depending on whether + on- or off-set is used), followed by the new line character '\n'. + For example, a two-input OR has the following SOP representation: + "1- 1\n-1 1\n", or equivalently, "00 0\n". The SOP for a constant + function with no fanins is represented as " 0\n" (constant 0) and + " 1\n" (constant 1). SOP for a constant node with some fanins + may also be represented. For example, constant 0 node with three + fanins will have SOP representation as follows: "--- 0\n". + + The objects can be added to the BBLIF manager in any order, but + by the time the fanin/fanout connections are created, corresponding + objects should be already created. + + The number of objects is limited by 2^31. The number of fanins + of one object is restricted to 2^28. The SOP representation can + have arbitrary many products (cubes), as long as memory is enough + to represent them in the C-string form, as described above. + + (2) To write the manager into a file, call procedure Bbl_ManDumpBinaryBlif(). + It is recommended to use files with extension ".bblif" because it + will allow ABC to call the approapriate reader in command "read". + + (3) To read the network from file, call procedure Bbl_ManReadBinaryBlif(). + + (4) It is assumed that ABC will return the network after mapping. + This network will arrive in a BBLIF file, from which the BBLIF + manager is created by the call to Bbl_ManReadBinaryBlif(). The + following APIs are useful to extract the mapped network from the manager: + + Iterator Bbl_ManForEachObj() iterates through the pointers to the + BBLIF objects, which are guaranteed to be in a topological order. + + For each object, the following APIs can be used: + Bbl_ObjIsInput() returns 1 if the object is a CI + Bbl_ObjIsOutput() returns 1 if the object is a CO + Bbl_ObjIsLut() returns 1 if the object is a logic node (lookup table) + Bbl_ObjFaninNumber() returns the number of fanins of the node + Bbl_ObjSop() returns the SOP representation of the node, as described above. + + A special attention should be given to the representation of object IDs + after mapping. Recall that when the outgoing BBLIF network is constructed, + the IDs of objects are assigned by the calling application and given to + the BBLIF manager when procedure Bbl_ManCreateObject() is called. + We refer to these object IDs as "original IDs of the objects". + + When the network has been given to ABC, mapped, and returned to the + calling application in the incoming BBLIF file, only CIs and COs are + guaranteed to preserve their "original IDs". Other objects may be created + during synthesis/mapping. The original IDs of these objects are set to -1. + + The following two APIs are used to return the IDs of objects after mapping: + Bbl_ObjId() returns the new ID (useful to construct network after mapping) + Bbl_ObjIdOriginal() returns the original ID (or -1 if this is a new object). + + !!!***!!! + Note: The original ID currently cannot be returned by Bbl_ObjIdOriginal(). + It is recommended to use the work-around described below. + !!!***!!! + + The original ID is useful to map CIs/COs after mapping into CIs/COs before + mapping. However, the order of CIs/COs after mapping in the incoming network + is the same as the order of their creation by the calling application + in the outgoing network. This allows for a workaround that does not have + the need for the original IDs. We can simply iterate through the objects + after mapping, and create CIs and COs in the order of their appearance, + and this order is guaranteed to be the same as the order of their + construction by the calling application. + + It is also worth noting that currently the internal node names are not + preserved by ABC during synthesis. This may change in the future. and then + some of the internal nodes will preserve their IDs, which may allow the + calling application to reconstruct the names of some of the nodes after + synthesis/mapping in ABC using their original IDs whenever available. + + Finally, iterator Bbl_ObjForEachFanin() can be used to iterate through + the fanins of each mapped object. For CIs, there will be no fanins. + For COs, there will be exactly one fanin. For the internal nodes (LUTs) + the number of fanins is the number of inputs of these nodes. + + A demo of using this interface is included at the bottom of file "bblif.c" in + procedure Bbl_ManSimpleDemo(). Additional examples can be found in the files + "abc\src\base\io\ioReadBblif.c" and "abc\src\base\io\ioWriteBblif.c". These + files illustrate how an ABC network is created from the BBLIF data manager + and how the data manager is created from the ABC network. + + Note that only the files "bblif.h" and "bblif.c" are needed for interfacing + the user's application with ABC, while other files should not be compiled + as part of the application code. + + Finally, a warning regarding endianness. The interface may not work + if the BBLIF file is produced on a machine whose engianness is different + from the machine, which is reading this file. +*/ + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _WIN32 +#define inline __inline +#endif + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +// object types +typedef enum { + BBL_OBJ_NONE, // 0: non-existent object + BBL_OBJ_CI, // 1: primary input + BBL_OBJ_CO, // 2: primary output + BBL_OBJ_NODE, // 3: buffer node + BBL_OBJ_VOID // 4: unused object +} Bbl_Type_t; + +// data manager +typedef struct Bbl_Man_t_ Bbl_Man_t; + +// data object +typedef struct Bbl_Obj_t_ Bbl_Obj_t; + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +// (1) creating the data manager in the application code +extern Bbl_Man_t * Bbl_ManStart( char * pName ); +extern void Bbl_ManCreateObject( Bbl_Man_t * p, Bbl_Type_t Type, int ObjId, int nFanins, char * pSop ); +extern void Bbl_ManAddFanin( Bbl_Man_t * p, int ObjId, int FaninId ); +extern int Bbl_ManCheck( Bbl_Man_t * p ); +extern void Bbl_ManPrintStats( Bbl_Man_t * p ); +extern void Bbl_ManStop( Bbl_Man_t * p ); + +// (2) writing the data manager into file +extern void Bbl_ManDumpBinaryBlif( Bbl_Man_t * p, char * pFileName ); + +// (3) reading the data manager from file +extern Bbl_Man_t * Bbl_ManReadBinaryBlif( char * pFileName ); + +// (4) returning the mapped network after reading the data manaager from file +extern char * Bbl_ManName( Bbl_Man_t * p ); +extern int Bbl_ObjIsInput( Bbl_Obj_t * p ); +extern int Bbl_ObjIsOutput( Bbl_Obj_t * p ); +extern int Bbl_ObjIsLut( Bbl_Obj_t * p ); +extern int Bbl_ObjId( Bbl_Obj_t * p ); +extern int Bbl_ObjIdOriginal( Bbl_Man_t * pMan, Bbl_Obj_t * p ); +extern int Bbl_ObjFaninNumber( Bbl_Obj_t * p ); +extern char * Bbl_ObjSop( Bbl_Man_t * pMan, Bbl_Obj_t * p ); + +// for the use in iterators only +extern Bbl_Obj_t * Bbl_ManObjFirst( Bbl_Man_t * p ); +extern Bbl_Obj_t * Bbl_ManObjNext( Bbl_Man_t * p, Bbl_Obj_t * pObj ); +extern Bbl_Obj_t * Bbl_ObjFaninFirst( Bbl_Obj_t * p ); +extern Bbl_Obj_t * Bbl_ObjFaninNext( Bbl_Obj_t * p, Bbl_Obj_t * pPrev ); + +// iterator through the objects +#define Bbl_ManForEachObj( p, pObj ) \ + for ( pObj = Bbl_ManObjFirst(p); pObj; pObj = Bbl_ManObjNext(p, pObj) ) +// iterator through the fanins fo the an object +#define Bbl_ObjForEachFanin( pObj, pFanin ) \ + for ( pFanin = Bbl_ObjFaninFirst(pObj); pFanin; pFanin = Bbl_ObjFaninNext(pObj, pFanin) ) + +// these additional procedures are provided to transform truth tables into SOPs, and vice versa +extern char * Bbl_ManTruthToSop( unsigned * pTruth, int nVars ); +extern unsigned * Bbl_ManSopToTruth( char * pSop, int nVars ); + +// write text BLIF file for debugging +extern void Bbl_ManDumpBlif( Bbl_Man_t * p, char * pFileName ); + +// a simple demo procedure +extern void Bbl_ManSimpleDemo(); + + +#ifdef __cplusplus +} +#endif + +#endif + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + diff --git a/src/aig/bbl/module.make b/src/aig/bbl/module.make new file mode 100644 index 00000000..89ed2fa3 --- /dev/null +++ b/src/aig/bbl/module.make @@ -0,0 +1 @@ +SRC += src/aig/bbl/bblif.c diff --git a/src/aig/cec/cec.h b/src/aig/cec/cec.h index fa7c5dbc..16748233 100644 --- a/src/aig/cec/cec.h +++ b/src/aig/cec/cec.h @@ -45,24 +45,42 @@ struct Cec_ParSat_t_ int nSatVarMax; // the max number of SAT variables int nCallsRecycle; // calls to perform before recycling SAT solver int fPolarFlip; // flops polarity of variables + int fCheckMiter; // the circuit is the miter int fFirstStop; // stop on the first sat output int fVerbose; // verbose stats }; +// simulation parameters +typedef struct Cec_ParSim_t_ Cec_ParSim_t; +struct Cec_ParSim_t_ +{ + int nWords; // the number of simulation words + int nRounds; // the number of simulation rounds + int TimeLimit; // the runtime limit in seconds + int fDoubleOuts; // miter with separate outputs + int fCheckMiter; // the circuit is the miter + int fFirstStop; // stop on the first sat output + int fSeqSimulate; // performs sequential simulation + int fVeryVerbose; // verbose stats + int fVerbose; // verbose stats +}; + // combinational SAT sweeping parameters -typedef struct Cec_ParCsw_t_ Cec_ParCsw_t; -struct Cec_ParCsw_t_ +typedef struct Cec_ParFra_t_ Cec_ParFra_t; +struct Cec_ParFra_t_ { int nWords; // the number of simulation words int nRounds; // the number of simulation rounds int nItersMax; // the maximum number of iterations of SAT sweeping int nBTLimit; // conflict limit at a node - int nSatVarMax; // the max number of SAT variables - int nCallsRecycle; // calls to perform before recycling SAT solver + int TimeLimit; // the runtime limit in seconds int nLevelMax; // restriction on the level nodes to be swept int nDepthMax; // the depth in terms of steps of speculative reduction int fRewriting; // enables AIG rewriting + int fCheckMiter; // the circuit is the miter int fFirstStop; // stop on the first sat output + int fDoubleOuts; // miter with separate outputs + int fColorDiff; // miter with separate outputs int fVeryVerbose; // verbose stats int fVerbose; // verbose stats }; @@ -71,13 +89,12 @@ struct Cec_ParCsw_t_ typedef struct Cec_ParCec_t_ Cec_ParCec_t; struct Cec_ParCec_t_ { - int nIters; // iterations of SAT solving/sweeping - int nBTLimitBeg; // starting backtrack limit - int nBTlimitMulti; // multiple of backtrack limit + int nBTLimit; // conflict limit at a node + int TimeLimit; // the runtime limit in seconds + int fFirstStop; // stop on the first sat output int fUseSmartCnf; // use smart CNF computation int fRewriting; // enables AIG rewriting - int fSatSweeping; // enables SAT sweeping - int fFirstStop; // stop on the first sat output + int fVeryVerbose; // verbose stats int fVerbose; // verbose stats }; @@ -89,12 +106,17 @@ struct Cec_ParCec_t_ /// FUNCTION DECLARATIONS /// //////////////////////////////////////////////////////////////////////// +/*=== cecCec.c ==========================================================*/ +extern int Cec_ManVerify( Gia_Man_t * p, Cec_ParCec_t * pPars ); +extern int Cec_ManVerifyTwo( Gia_Man_t * p0, Gia_Man_t * p1, int fVerbose ); /*=== cecCore.c ==========================================================*/ extern void Cec_ManSatSetDefaultParams( Cec_ParSat_t * p ); -extern void Cec_ManCswSetDefaultParams( Cec_ParCsw_t * p ); +extern void Cec_ManSimSetDefaultParams( Cec_ParSim_t * p ); +extern void Cec_ManFraSetDefaultParams( Cec_ParFra_t * p ); extern void Cec_ManCecSetDefaultParams( Cec_ParCec_t * p ); -extern Gia_Man_t * Cec_ManSatSweeping( Gia_Man_t * pAig, Cec_ParCsw_t * pPars ); +extern Gia_Man_t * Cec_ManSatSweeping( Gia_Man_t * pAig, Cec_ParFra_t * pPars ); extern Gia_Man_t * Cec_ManSatSolving( Gia_Man_t * pAig, Cec_ParSat_t * pPars ); +extern void Cec_ManSimulation( Gia_Man_t * pAig, Cec_ParSim_t * pPars ); #ifdef __cplusplus } diff --git a/src/aig/cec/cecCec.c b/src/aig/cec/cecCec.c new file mode 100644 index 00000000..ea730693 --- /dev/null +++ b/src/aig/cec/cecCec.c @@ -0,0 +1,241 @@ +/**CFile**************************************************************** + + FileName [cecCec.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Combinatinoal equivalence checking.] + + Synopsis [Integrated combinatinal equivalence checker.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: cecCec.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "cecInt.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Saves the input pattern with the given number.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManTransformPattern( Gia_Man_t * p, int iOut, int * pValues ) +{ + int i; + assert( p->pCexComb == NULL ); + p->pCexComb = (Gia_Cex_t *)ABC_CALLOC( char, + sizeof(Gia_Cex_t) + sizeof(unsigned) * Aig_BitWordNum(Gia_ManCiNum(p)) ); + p->pCexComb->iPo = iOut; + p->pCexComb->nPis = Gia_ManCiNum(p); + p->pCexComb->nBits = Gia_ManCiNum(p); + for ( i = 0; i < Gia_ManCiNum(p); i++ ) + if ( pValues[i] ) + Aig_InfoSetBit( p->pCexComb->pData, i ); +} + +/**Function************************************************************* + + Synopsis [Interface to the old CEC engine] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManVerifyOld( Gia_Man_t * pMiter, int fVerbose ) +{ + extern int Fra_FraigCec( Aig_Man_t ** ppAig, int nConfLimit, int fVerbose ); + extern int Ssw_SecCexResimulate( Aig_Man_t * p, int * pModel, int * pnOutputs ); + Gia_Man_t * pTemp = Gia_ManTransformMiter( pMiter ); + Aig_Man_t * pMiterCec = Gia_ManToAig( pTemp ); + int RetValue, iOut, nOuts, clkTotal = clock(); + Gia_ManStop( pTemp ); + // run CEC on this miter + RetValue = Fra_FraigCec( &pMiterCec, 100000, fVerbose ); + // report the miter + if ( RetValue == 1 ) + { + printf( "Networks are equivalent. " ); +ABC_PRT( "Time", clock() - clkTotal ); + } + else if ( RetValue == 0 ) + { + printf( "Networks are NOT EQUIVALENT. " ); +ABC_PRT( "Time", clock() - clkTotal ); + if ( pMiterCec->pData == NULL ) + printf( "Counter-example is not available.\n" ); + else + { + iOut = Ssw_SecCexResimulate( pMiterCec, pMiterCec->pData, &nOuts ); + if ( iOut == -1 ) + printf( "Counter-example verification has failed.\n" ); + else + { + printf( "Primary output %d has failed in frame %d.\n", iOut ); + printf( "The counter-example detected %d incorrect outputs.\n", nOuts ); + } + Cec_ManTransformPattern( pMiter, iOut, pMiterCec->pData ); + } + } + else + { + printf( "Networks are UNDECIDED. " ); +ABC_PRT( "Time", clock() - clkTotal ); + } + fflush( stdout ); + Aig_ManStop( pMiterCec ); + return RetValue; +} + +/**Function************************************************************* + + Synopsis [New CEC engine.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManVerify( Gia_Man_t * p, Cec_ParCec_t * pPars ) +{ + int fDumpUndecided = 1; + Cec_ParFra_t ParsFra, * pParsFra = &ParsFra; + Gia_Man_t * pNew; + int RetValue, clk = clock(); + double clkTotal = clock(); + // sweep for equivalences + Cec_ManFraSetDefaultParams( pParsFra ); + pParsFra->nBTLimit = pPars->nBTLimit; + pParsFra->TimeLimit = pPars->TimeLimit; + pParsFra->fVerbose = pPars->fVerbose; + pParsFra->fCheckMiter = 1; + pParsFra->fFirstStop = 1; + pParsFra->fDoubleOuts = 1; + pNew = Cec_ManSatSweeping( p, pParsFra ); + if ( pNew == NULL ) + { + if ( !Gia_ManVerifyCounterExample( p, p->pCexComb, 1 ) ) + printf( "Counter-example simulation has failed.\n" ); + printf( "Networks are NOT EQUIVALENT. " ); + ABC_PRT( "Time", clock() - clk ); + return 0; + } + if ( Gia_ManAndNum(pNew) == 0 ) + { + printf( "Networks are equivalent. " ); + ABC_PRT( "Time", clock() - clk ); + Gia_ManStop( pNew ); + return 1; + } + printf( "Networks are UNDECIDED after the new CEC engine. " ); + ABC_PRT( "Time", clock() - clk ); + if ( fDumpUndecided ) + { + Gia_WriteAiger( pNew, "gia_cec_undecided.aig", 0, 0 ); + printf( "The result is written into file \"%s\".\n", "gia_cec_undecided.aig" ); + } + if ( pPars->TimeLimit && ((double)clock() - clkTotal)/CLOCKS_PER_SEC >= pPars->TimeLimit ) + { + Gia_ManStop( pNew ); + return -1; + } + // call other solver + printf( "Calling the old CEC engine.\n" ); + fflush( stdout ); + RetValue = Cec_ManVerifyOld( pNew, pPars->fVerbose ); + p->pCexComb = pNew->pCexComb; pNew->pCexComb = NULL; + if ( p->pCexComb && !Gia_ManVerifyCounterExample( p, p->pCexComb, 1 ) ) + printf( "Counter-example simulation has failed.\n" ); + Gia_ManStop( pNew ); + return RetValue; +} + +/**Function************************************************************* + + Synopsis [New CEC engine applied to two circuits.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManVerifyTwo( Gia_Man_t * p0, Gia_Man_t * p1, int fVerbose ) +{ + Cec_ParCec_t ParsCec, * pPars = &ParsCec; + Gia_Man_t * pMiter; + int RetValue; + Cec_ManCecSetDefaultParams( pPars ); + pPars->fVerbose = fVerbose; + pMiter = Gia_ManMiter( p0, p1, 0, 1, pPars->fVerbose ); + if ( pMiter == NULL ) + return -1; + RetValue = Cec_ManVerify( pMiter, pPars ); + p0->pCexComb = pMiter->pCexComb; pMiter->pCexComb = NULL; + Gia_ManStop( pMiter ); + return RetValue; +} + +/**Function************************************************************* + + Synopsis [New CEC engine applied to two circuits.] + + Description [Returns 1 if equivalent, 0 if counter-example, -1 if undecided. + Counter-example is returned in the first manager as pAig0->pSeqModel. + The format is given in Gia_Cex_t (file "abc\src\aig\gia\gia.h").] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManVerifyTwoAigs( Aig_Man_t * pAig0, Aig_Man_t * pAig1, int fVerbose ) +{ + Gia_Man_t * p0, * p1, * pTemp; + int RetValue; + + p0 = Gia_ManFromAig( pAig0 ); + p0 = Gia_ManCleanup( pTemp = p0 ); + Gia_ManStop( pTemp ); + + p1 = Gia_ManFromAig( pAig1 ); + p1 = Gia_ManCleanup( pTemp = p1 ); + Gia_ManStop( pTemp ); + + RetValue = Cec_ManVerifyTwo( p0, p1, fVerbose ); + pAig0->pSeqModel = p0->pCexComb; p0->pCexComb = NULL; + Gia_ManStop( p0 ); + Gia_ManStop( p1 ); + return RetValue; +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/cec/cecClass.c b/src/aig/cec/cecClass.c index 65fa2e9b..aaa85ffa 100644 --- a/src/aig/cec/cecClass.c +++ b/src/aig/cec/cecClass.c @@ -24,39 +24,10 @@ /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// -static inline int Cec_ObjRepr( Cec_ManCsw_t * p, int Id ) { return p->pObjs[Id].iRepr; } -static inline void Cec_ObjSetRepr( Cec_ManCsw_t * p, int Id, int Num ) { p->pObjs[Id].iRepr = Num; } - -static inline int Cec_ObjProved( Cec_ManCsw_t * p, int Id ) { return p->pObjs[Id].iProved; } -static inline void Cec_ObjSetProved( Cec_ManCsw_t * p, int Id ) { p->pObjs[Id].iProved = 1; } - -static inline int Cec_ObjFailed( Cec_ManCsw_t * p, int Id ) { return p->pObjs[Id].iFailed; } -static inline void Cec_ObjSetFailed( Cec_ManCsw_t * p, int Id ) { p->pObjs[Id].iFailed = 1; } - -static inline int Cec_ObjNext( Cec_ManCsw_t * p, int Id ) { return p->pObjs[Id].iNext; } -static inline void Cec_ObjSetNext( Cec_ManCsw_t * p, int Id, int Num ) { p->pObjs[Id].iNext = Num; } - -static inline unsigned Cec_ObjSim( Cec_ManCsw_t * p, int Id ) { return p->pObjs[Id].SimNum; } -static inline unsigned * Cec_ObjSimP1( Cec_ManCsw_t * p, int Id ) { return &p->pObjs[Id].SimNum; } -static inline unsigned * Cec_ObjSimP( Cec_ManCsw_t * p, int Id ) { return p->pMems + Cec_ObjSim(p, Id) + 1; } -static inline void Cec_ObjSetSim( Cec_ManCsw_t * p, int Id, unsigned n ) { p->pObjs[Id].SimNum = n; } - -static inline int Cec_ObjIsConst( Cec_ManCsw_t * p, int Id ) { return Cec_ObjRepr(p, Id) == 0; } -static inline int Cec_ObjIsHead( Cec_ManCsw_t * p, int Id ) { return Cec_ObjRepr(p, Id) < 0 && Cec_ObjNext(p, Id) > 0; } -static inline int Cec_ObjIsNone( Cec_ManCsw_t * p, int Id ) { return Cec_ObjRepr(p, Id) < 0 && Cec_ObjNext(p, Id) == 0; } -static inline int Cec_ObjIsTail( Cec_ManCsw_t * p, int Id ) { return Cec_ObjRepr(p, Id) > 0 && Cec_ObjNext(p, Id) == 0; } -static inline int Cec_ObjIsClass( Cec_ManCsw_t * p, int Id ) { return Cec_ObjRepr(p, Id) > 0 || Cec_ObjNext(p, Id) > 0; } - -#define Cec_ManForEachObj( p, i ) \ - for ( i = 0; i < Gia_ManObjNum(p->pAig); i++ ) -#define Cec_ManForEachObj1( p, i ) \ - for ( i = 1; i < Gia_ManObjNum(p->pAig); i++ ) -#define Cec_ManForEachClass( p, i ) \ - for ( i = 1; i < Gia_ManObjNum(p->pAig); i++ ) if ( !Cec_ObjIsHead(p, i) ) {} else -#define Cec_ClassForEachObj( p, i, iObj ) \ - for ( assert(Cec_ObjIsHead(p, i)), iObj = i; iObj; iObj = Cec_ObjNext(p, iObj) ) -#define Cec_ClassForEachObj1( p, i, iObj ) \ - for ( assert(Cec_ObjIsHead(p, i)), iObj = Cec_ObjNext(p, i); iObj; iObj = Cec_ObjNext(p, iObj) ) +static inline unsigned * Cec_ObjSim( Cec_ManSim_t * p, int Id ) { return p->pMems + p->pSimInfo[Id] + 1; } +static inline void Cec_ObjSetSim( Cec_ManSim_t * p, int Id, int n ) { p->pSimInfo[Id] = n; } + +static inline float Cec_MemUsage( Cec_ManSim_t * p ) { return 1.0*p->nMemsMax*(p->pPars->nWords+1)/(1<<20); } //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// @@ -64,30 +35,7 @@ static inline int Cec_ObjIsClass( Cec_ManCsw_t * p, int Id ) { /**Function************************************************************* - Synopsis [Creates the set of representatives.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int * Cec_ManCswDeriveReprs( Cec_ManCsw_t * p ) -{ - int i, * pReprs = ABC_FALLOC( int, Gia_ManObjNum(p->pAig) ); - for ( i = 1; i < Gia_ManObjNum(p->pAig); i++ ) - if ( Cec_ObjProved(p, i) ) - { - assert( Cec_ObjRepr(p, i) >= 0 ); - pReprs[i] = Cec_ObjRepr(p, i); - } - return pReprs; -} - -/**Function************************************************************* - - Synopsis [] + Synopsis [Compares simulation info of one node with constant 0.] Description [] @@ -96,250 +44,28 @@ int * Cec_ManCswDeriveReprs( Cec_ManCsw_t * p ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Cec_ManCswDupWithClasses( Cec_ManCsw_t * p ) +int Cec_ManSimCompareConst( unsigned * p, int nWords ) { - Gia_Man_t * pNew, * pTemp; - Gia_Obj_t * pObj, * pRepr; - int iRes0, iRes1, iRepr, iNode; - int i, fCompl, * piCopies; - Vec_IntClear( p->vXorNodes ); - Gia_ManLevelNum( p->pAig ); - pNew = Gia_ManStart( Gia_ManObjNum(p->pAig) ); - pNew->pName = Aig_UtilStrsav( p->pAig->pName ); - Gia_ManHashAlloc( pNew ); - piCopies = ABC_FALLOC( int, Gia_ManObjNum(p->pAig) ); - piCopies[0] = 0; - Gia_ManForEachObj1( p->pAig, pObj, i ) - { - if ( Gia_ObjIsCi(pObj) ) - { - piCopies[i] = Gia_ManAppendCi( pNew ); - continue; - } - iRes0 = Gia_LitNotCond( piCopies[Gia_ObjFaninId0(pObj,i)], Gia_ObjFaninC0(pObj) ); - if ( Gia_ObjIsCo(pObj) ) - { - Gia_ManAppendCo( pNew, iRes0 ); - continue; - } - iRes1 = Gia_LitNotCond( piCopies[Gia_ObjFaninId1(pObj,i)], Gia_ObjFaninC1(pObj) ); - iNode = piCopies[i] = Gia_ManHashAnd( pNew, iRes0, iRes1 ); - if ( Cec_ObjRepr(p, i) < 0 || !Cec_ObjProved(p, i) ) - continue; - assert( Cec_ObjRepr(p, i) < i ); - iRepr = piCopies[Cec_ObjRepr(p, i)]; - if ( Gia_LitRegular(iNode) == Gia_LitRegular(iRepr) ) - continue; - pRepr = Gia_ManObj( p->pAig, Cec_ObjRepr(p, i) ); - fCompl = Gia_ObjPhaseReal(pObj) ^ Gia_ObjPhaseReal(pRepr); - piCopies[i] = Gia_LitNotCond( iRepr, fCompl ); - } - ABC_FREE( piCopies ); - Gia_ManHashStop( pNew ); - Gia_ManSetRegNum( pNew, 0 ); - pNew = Gia_ManCleanup( pTemp = pNew ); - Gia_ManStop( pTemp ); - return pNew; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Gia_Man_t * Cec_ManCswSpecReduction( Cec_ManCsw_t * p ) -{ - Gia_Man_t * pNew, * pTemp; - Gia_Obj_t * pObj, * pRepr; - int iRes0, iRes1, iRepr, iNode, iMiter; - int i, fCompl, * piCopies, * pDepths; - Vec_IntClear( p->vXorNodes ); -// Gia_ManLevelNum( p->pAig ); - pNew = Gia_ManStart( Gia_ManObjNum(p->pAig) ); - pNew->pName = Aig_UtilStrsav( p->pAig->pName ); - Gia_ManHashAlloc( pNew ); - piCopies = ABC_FALLOC( int, Gia_ManObjNum(p->pAig) ); - pDepths = ABC_CALLOC( int, Gia_ManObjNum(p->pAig) ); - piCopies[0] = 0; - Gia_ManForEachObj1( p->pAig, pObj, i ) - { - if ( Gia_ObjIsCi(pObj) ) - { - piCopies[i] = Gia_ManAppendCi( pNew ); - continue; - } - if ( Gia_ObjIsCo(pObj) ) - continue; - if ( piCopies[Gia_ObjFaninId0(pObj,i)] == -1 || - piCopies[Gia_ObjFaninId1(pObj,i)] == -1 ) - continue; - iRes0 = Gia_LitNotCond( piCopies[Gia_ObjFaninId0(pObj,i)], Gia_ObjFaninC0(pObj) ); - iRes1 = Gia_LitNotCond( piCopies[Gia_ObjFaninId1(pObj,i)], Gia_ObjFaninC1(pObj) ); - iNode = piCopies[i] = Gia_ManHashAnd( pNew, iRes0, iRes1 ); - pDepths[i] = AIG_MAX( pDepths[Gia_ObjFaninId0(pObj,i)], pDepths[Gia_ObjFaninId1(pObj,i)] ); - if ( Cec_ObjRepr(p, i) < 0 || Cec_ObjFailed(p, i) ) - continue; - assert( Cec_ObjRepr(p, i) < i ); - iRepr = piCopies[Cec_ObjRepr(p, i)]; - if ( iRepr == -1 ) - continue; - if ( Gia_LitRegular(iNode) == Gia_LitRegular(iRepr) ) - continue; - pRepr = Gia_ManObj( p->pAig, Cec_ObjRepr(p, i) ); - fCompl = Gia_ObjPhaseReal(pObj) ^ Gia_ObjPhaseReal(pRepr); - piCopies[i] = Gia_LitNotCond( iRepr, fCompl ); - if ( Cec_ObjProved(p, i) ) - continue; -// if ( p->pPars->nLevelMax && -// (Gia_ObjLevel(p->pAig, pObj) > p->pPars->nLevelMax || -// Gia_ObjLevel(p->pAig, pRepr) > p->pPars->nLevelMax) ) -// continue; - // produce speculative miter - iMiter = Gia_ManHashXor( pNew, iNode, piCopies[i] ); - Gia_ManAppendCo( pNew, iMiter ); - Vec_IntPush( p->vXorNodes, Cec_ObjRepr(p, i) ); - Vec_IntPush( p->vXorNodes, i ); - // add to the depth of this node - pDepths[i] = 1 + AIG_MAX( pDepths[i], pDepths[Cec_ObjRepr(p, i)] ); - if ( p->pPars->nDepthMax && pDepths[i] >= p->pPars->nDepthMax ) - piCopies[i] = -1; - } - ABC_FREE( piCopies ); - ABC_FREE( pDepths ); - Gia_ManHashStop( pNew ); - Gia_ManSetRegNum( pNew, 0 ); - pNew = Gia_ManCleanup( pTemp = pNew ); - Gia_ManStop( pTemp ); - return pNew; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Gia_Man_t * Cec_ManCswSpecReductionProved( Cec_ManCsw_t * p ) -{ - Gia_Man_t * pNew, * pTemp; - Gia_Obj_t * pObj, * pRepr; - int iRes0, iRes1, iRepr, iNode, iMiter; - int i, fCompl, * piCopies; - Vec_IntClear( p->vXorNodes ); - Gia_ManLevelNum( p->pAig ); - pNew = Gia_ManStart( Gia_ManObjNum(p->pAig) ); - pNew->pName = Aig_UtilStrsav( p->pAig->pName ); - Gia_ManHashAlloc( pNew ); - piCopies = ABC_FALLOC( int, Gia_ManObjNum(p->pAig) ); - piCopies[0] = 0; - Gia_ManForEachObj1( p->pAig, pObj, i ) + int w; + if ( p[0] & 1 ) { - if ( Gia_ObjIsCi(pObj) ) - { - piCopies[i] = Gia_ManAppendCi( pNew ); - continue; - } - if ( Gia_ObjIsCo(pObj) ) - continue; - iRes0 = Gia_LitNotCond( piCopies[Gia_ObjFaninId0(pObj,i)], Gia_ObjFaninC0(pObj) ); - iRes1 = Gia_LitNotCond( piCopies[Gia_ObjFaninId1(pObj,i)], Gia_ObjFaninC1(pObj) ); - iNode = piCopies[i] = Gia_ManHashAnd( pNew, iRes0, iRes1 ); - if ( Cec_ObjRepr(p, i) < 0 || !Cec_ObjProved(p, i) ) - continue; - assert( Cec_ObjRepr(p, i) < i ); - iRepr = piCopies[Cec_ObjRepr(p, i)]; - if ( Gia_LitRegular(iNode) == Gia_LitRegular(iRepr) ) - continue; - pRepr = Gia_ManObj( p->pAig, Cec_ObjRepr(p, i) ); - fCompl = Gia_ObjPhaseReal(pObj) ^ Gia_ObjPhaseReal(pRepr); - piCopies[i] = Gia_LitNotCond( iRepr, fCompl ); - // add speculative miter - iMiter = Gia_ManHashXor( pNew, iNode, piCopies[i] ); - Gia_ManAppendCo( pNew, iMiter ); + for ( w = 0; w < nWords; w++ ) + if ( p[w] != ~0 ) + return 0; + return 1; } - ABC_FREE( piCopies ); - Gia_ManHashStop( pNew ); - Gia_ManSetRegNum( pNew, 0 ); - pNew = Gia_ManCleanup( pTemp = pNew ); - Gia_ManStop( pTemp ); - return pNew; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Cec_ManCswCountOne( Cec_ManCsw_t * p, int i ) -{ - int Ent, nLits = 1; - Cec_ClassForEachObj1( p, i, Ent ) + else { - assert( Cec_ObjRepr(p, Ent) == i ); - nLits++; + for ( w = 0; w < nWords; w++ ) + if ( p[w] != 0 ) + return 0; + return 1; } - return nLits; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Cec_ManCswCountLitsAll( Cec_ManCsw_t * p ) -{ - int i, nLits = 0; - Cec_ManForEachObj( p, i ) - nLits += (Cec_ObjRepr(p, i) >= 0); - return nLits; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Cec_ManCswPrintOne( Cec_ManCsw_t * p, int i, int Counter ) -{ - int Ent; - printf( "Class %4d : Num = %2d {", Counter, Cec_ManCswCountOne(p, i) ); - Cec_ClassForEachObj( p, i, Ent ) - printf(" %d", Ent ); - printf( " }\n" ); } /**Function************************************************************* - Synopsis [] + Synopsis [Compares simulation info of two nodes.] Description [] @@ -348,32 +74,28 @@ void Cec_ManCswPrintOne( Cec_ManCsw_t * p, int i, int Counter ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswPrintClasses( Cec_ManCsw_t * p, int fVerbose ) +int Cec_ManSimCompareEqual( unsigned * p0, unsigned * p1, int nWords ) { - int i, Counter = 0, Counter1 = 0, CounterX = 0, nLits; - Cec_ManForEachObj1( p, i ) + int w; + if ( (p0[0] & 1) == (p1[0] & 1) ) { - if ( Cec_ObjIsHead(p, i) ) - Counter++; - else if ( Cec_ObjIsConst(p, i) ) - Counter1++; - else if ( Cec_ObjIsNone(p, i) ) - CounterX++; + for ( w = 0; w < nWords; w++ ) + if ( p0[w] != p1[w] ) + return 0; + return 1; } - nLits = Cec_ManCswCountLitsAll( p ); - printf( "Class =%7d. Const =%7d. Unsed =%7d. Lits =%8d. All =%8d. Mem = %5.2f Mb\n", - Counter, Counter1, CounterX, nLits-Counter1, nLits, 1.0*p->nMemsMax*(p->pPars->nWords+1)/(1<<20) ); - if ( fVerbose ) + else { - Counter = 0; - Cec_ManForEachClass( p, i ) - Cec_ManCswPrintOne( p, i, ++Counter ); + for ( w = 0; w < nWords; w++ ) + if ( p0[w] != ~p1[w] ) + return 0; + return 1; } } /**Function************************************************************* - Synopsis [] + Synopsis [Returns the number of the first non-equal bit.] Description [] @@ -382,28 +104,28 @@ void Cec_ManCswPrintClasses( Cec_ManCsw_t * p, int fVerbose ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswCompareEqual( unsigned * p0, unsigned * p1, int nWords ) +int Cec_ManSimCompareConstFirstBit( unsigned * p, int nWords ) { int w; - if ( (p0[0] & 1) == (p1[0] & 1) ) + if ( p[0] & 1 ) { for ( w = 0; w < nWords; w++ ) - if ( p0[w] != p1[w] ) - return 0; - return 1; + if ( p[w] != ~0 ) + return 32*w + Aig_WordFindFirstBit( ~p[w] ); + return -1; } else { for ( w = 0; w < nWords; w++ ) - if ( p0[w] != ~p1[w] ) - return 0; - return 1; + if ( p[w] != 0 ) + return 32*w + Aig_WordFindFirstBit( p[w] ); + return -1; } } /**Function************************************************************* - Synopsis [] + Synopsis [Compares simulation info of two nodes.] Description [] @@ -412,28 +134,28 @@ int Cec_ManCswCompareEqual( unsigned * p0, unsigned * p1, int nWords ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswCompareConst( unsigned * p, int nWords ) +int Cec_ManSimCompareEqualFirstBit( unsigned * p0, unsigned * p1, int nWords ) { int w; - if ( p[0] & 1 ) + if ( (p0[0] & 1) == (p1[0] & 1) ) { for ( w = 0; w < nWords; w++ ) - if ( p[w] != ~0 ) - return 0; - return 1; + if ( p0[w] != p1[w] ) + return 32*w + Aig_WordFindFirstBit( p0[w] ^ p1[w] ); + return -1; } else { for ( w = 0; w < nWords; w++ ) - if ( p[w] != 0 ) - return 0; - return 1; + if ( p0[w] != ~p1[w] ) + return 32*w + Aig_WordFindFirstBit( p0[w] ^ ~p1[w] ); + return -1; } } /**Function************************************************************* - Synopsis [] + Synopsis [Creates equivalence class.] Description [] @@ -442,31 +164,31 @@ int Cec_ManCswCompareConst( unsigned * p, int nWords ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswClassCreate( Cec_ManCsw_t * p, Vec_Int_t * vClass ) +void Cec_ManSimClassCreate( Gia_Man_t * p, Vec_Int_t * vClass ) { - int Repr = -1, EntPrev = -1, Ent, i; + int Repr = GIA_VOID, EntPrev = -1, Ent, i; assert( Vec_IntSize(vClass) > 0 ); Vec_IntForEachEntry( vClass, Ent, i ) { if ( i == 0 ) { Repr = Ent; - Cec_ObjSetRepr( p, Ent, -1 ); + Gia_ObjSetRepr( p, Ent, GIA_VOID ); EntPrev = Ent; } else { - Cec_ObjSetRepr( p, Ent, Repr ); - Cec_ObjSetNext( p, EntPrev, Ent ); + Gia_ObjSetRepr( p, Ent, Repr ); + Gia_ObjSetNext( p, EntPrev, Ent ); EntPrev = Ent; } } - Cec_ObjSetNext( p, EntPrev, 0 ); + Gia_ObjSetNext( p, EntPrev, 0 ); } /**Function************************************************************* - Synopsis [] + Synopsis [Refines one equivalence class.] Description [] @@ -475,34 +197,34 @@ void Cec_ManCswClassCreate( Cec_ManCsw_t * p, Vec_Int_t * vClass ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswClassRefineOne( Cec_ManCsw_t * p, int i, int fFirst ) +int Cec_ManSimClassRefineOne( Cec_ManSim_t * p, int i ) { unsigned * pSim0, * pSim1; int Ent; Vec_IntClear( p->vClassOld ); Vec_IntClear( p->vClassNew ); Vec_IntPush( p->vClassOld, i ); - pSim0 = fFirst? Cec_ObjSimP1(p, i) : Cec_ObjSimP(p, i); - Cec_ClassForEachObj1( p, i, Ent ) + pSim0 = Cec_ObjSim(p, i); + Gia_ClassForEachObj1( p->pAig, i, Ent ) { - pSim1 = fFirst? Cec_ObjSimP1(p, Ent) : Cec_ObjSimP(p, Ent); - if ( Cec_ManCswCompareEqual( pSim0, pSim1, p->nWords ) ) + pSim1 = Cec_ObjSim(p, Ent); + if ( Cec_ManSimCompareEqual( pSim0, pSim1, p->nWords ) ) Vec_IntPush( p->vClassOld, Ent ); else Vec_IntPush( p->vClassNew, Ent ); } if ( Vec_IntSize( p->vClassNew ) == 0 ) return 0; - Cec_ManCswClassCreate( p, p->vClassOld ); - Cec_ManCswClassCreate( p, p->vClassNew ); + Cec_ManSimClassCreate( p->pAig, p->vClassOld ); + Cec_ManSimClassCreate( p->pAig, p->vClassNew ); if ( Vec_IntSize(p->vClassNew) > 1 ) - return 1 + Cec_ManCswClassRefineOne( p, Vec_IntEntry(p->vClassNew,0), fFirst ); + return 1 + Cec_ManSimClassRefineOne( p, Vec_IntEntry(p->vClassNew,0) ); return 1; } /**Function************************************************************* - Synopsis [] + Synopsis [Computes hash key of the simuation info.] Description [] @@ -511,7 +233,7 @@ int Cec_ManCswClassRefineOne( Cec_ManCsw_t * p, int i, int fFirst ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswHashKey( unsigned * pSim, int nWords, int nTableSize ) +int Cec_ManSimHashKey( unsigned * pSim, int nWords, int nTableSize ) { static int s_Primes[16] = { 1291, 1699, 1999, 2357, 2953, 3313, 3907, 4177, @@ -530,7 +252,7 @@ int Cec_ManCswHashKey( unsigned * pSim, int nWords, int nTableSize ) /**Function************************************************************* - Synopsis [] + Synopsis [Resets pointers to the simulation memory.] Description [] @@ -539,90 +261,7 @@ int Cec_ManCswHashKey( unsigned * pSim, int nWords, int nTableSize ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswClassesCreate( Cec_ManCsw_t * p ) -{ - int * pTable, nTableSize, i, Key; - p->nWords = 1; - nTableSize = Aig_PrimeCudd( 100 + Gia_ManObjNum(p->pAig) / 10 ); - pTable = ABC_CALLOC( int, nTableSize ); - Cec_ObjSetRepr( p, 0, -1 ); - Cec_ManForEachObj1( p, i ) - { - if ( Gia_ObjIsCo(Gia_ManObj(p->pAig, i)) ) - { - Cec_ObjSetRepr( p, i, -1 ); - continue; - } - if ( Cec_ManCswCompareConst( Cec_ObjSimP1(p, i), p->nWords ) ) - { - Cec_ObjSetRepr( p, i, 0 ); - continue; - } - Key = Cec_ManCswHashKey( Cec_ObjSimP1(p, i), p->nWords, nTableSize ); - if ( pTable[Key] == 0 ) - Cec_ObjSetRepr( p, i, -1 ); - else - { - Cec_ObjSetNext( p, pTable[Key], i ); - Cec_ObjSetRepr( p, i, Cec_ObjRepr(p, pTable[Key]) ); - if ( Cec_ObjRepr(p, i) == -1 ) - Cec_ObjSetRepr( p, i, pTable[Key] ); - } - pTable[Key] = i; - } - ABC_FREE( pTable ); - if ( p->pPars->fVeryVerbose ) - Cec_ManCswPrintClasses( p, 0 ); - // refine classes - Cec_ManForEachClass( p, i ) - Cec_ManCswClassRefineOne( p, i, 1 ); - // clean memory - Cec_ManForEachObj( p, i ) - Cec_ObjSetSim( p, i, 0 ); - if ( p->pPars->fVeryVerbose ) - Cec_ManCswPrintClasses( p, 0 ); -} - - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Cec_ManCswSimulateSimple( Cec_ManCsw_t * p ) -{ - Gia_Obj_t * pObj; - unsigned Res0, Res1; - int i; - Gia_ManForEachCi( p->pAig, pObj, i ) - Cec_ObjSetSim( p, i, Aig_ManRandom(0) ); - Gia_ManForEachAnd( p->pAig, pObj, i ) - { - Res0 = Cec_ObjSim( p, Gia_ObjFaninId0(pObj, i) ); - Res1 = Cec_ObjSim( p, Gia_ObjFaninId1(pObj, i) ); - Cec_ObjSetSim( p, i, (Gia_ObjFaninC0(pObj)? ~Res0: Res0) & - (Gia_ObjFaninC1(pObj)? ~Res1: Res1) ); - } -} - -/**Function************************************************************* - - Synopsis [References simulation info.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Cec_ManCswSimMemRelink( Cec_ManCsw_t * p ) +void Cec_ManSimMemRelink( Cec_ManSim_t * p ) { unsigned * pPlace, Ent; pPlace = &p->MemFree; @@ -634,6 +273,7 @@ void Cec_ManCswSimMemRelink( Cec_ManCsw_t * p ) pPlace = p->pMems + Ent; } *pPlace = 0; + p->nWordsOld = p->nWords; } /**Function************************************************************* @@ -647,10 +287,10 @@ void Cec_ManCswSimMemRelink( Cec_ManCsw_t * p ) SeeAlso [] ***********************************************************************/ -unsigned * Cec_ManCswSimRef( Cec_ManCsw_t * p, int i ) +unsigned * Cec_ManSimSimRef( Cec_ManSim_t * p, int i ) { unsigned * pSim; - assert( p->pObjs[i].SimNum == 0 ); + assert( p->pSimInfo[i] == 0 ); if ( p->MemFree == 0 ) { if ( p->nWordsAlloc == 0 ) @@ -661,9 +301,9 @@ unsigned * Cec_ManCswSimRef( Cec_ManCsw_t * p, int i ) } p->nWordsAlloc *= 2; p->pMems = ABC_REALLOC( unsigned, p->pMems, p->nWordsAlloc ); - Cec_ManCswSimMemRelink( p ); + Cec_ManSimMemRelink( p ); } - p->pObjs[i].SimNum = p->MemFree; + p->pSimInfo[i] = p->MemFree; pSim = p->pMems + p->MemFree; p->MemFree = pSim[0]; pSim[0] = Gia_ObjValue( Gia_ManObj(p->pAig, i) ); @@ -675,7 +315,7 @@ unsigned * Cec_ManCswSimRef( Cec_ManCsw_t * p, int i ) /**Function************************************************************* - Synopsis [Dereference simulaton info.] + Synopsis [Dereferences simulaton info.] Description [] @@ -684,16 +324,16 @@ unsigned * Cec_ManCswSimRef( Cec_ManCsw_t * p, int i ) SeeAlso [] ***********************************************************************/ -unsigned * Cec_ManCswSimDeref( Cec_ManCsw_t * p, int i ) +unsigned * Cec_ManSimSimDeref( Cec_ManSim_t * p, int i ) { unsigned * pSim; - assert( p->pObjs[i].SimNum > 0 ); - pSim = p->pMems + p->pObjs[i].SimNum; + assert( p->pSimInfo[i] > 0 ); + pSim = p->pMems + p->pSimInfo[i]; if ( --pSim[0] == 0 ) { pSim[0] = p->MemFree; - p->MemFree = p->pObjs[i].SimNum; - p->pObjs[i].SimNum = 0; + p->MemFree = p->pSimInfo[i]; + p->pSimInfo[i] = 0; p->nMems--; } return pSim; @@ -701,7 +341,7 @@ unsigned * Cec_ManCswSimDeref( Cec_ManCsw_t * p, int i ) /**Function************************************************************* - Synopsis [] + Synopsis [Refines nodes belonging to candidate constant class.] Description [] @@ -710,52 +350,145 @@ unsigned * Cec_ManCswSimDeref( Cec_ManCsw_t * p, int i ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswProcessRefined( Cec_ManCsw_t * p, Vec_Int_t * vRefined ) +void Cec_ManSimProcessRefined( Cec_ManSim_t * p, Vec_Int_t * vRefined ) { unsigned * pSim; int * pTable, nTableSize, i, k, Key; if ( Vec_IntSize(vRefined) == 0 ) return; - nTableSize = Aig_PrimeCudd( 100 + Vec_IntSize(vRefined) / 5 ); + nTableSize = Aig_PrimeCudd( 100 + Vec_IntSize(vRefined) / 3 ); pTable = ABC_CALLOC( int, nTableSize ); Vec_IntForEachEntry( vRefined, i, k ) { - if ( i == 7720 ) - { - int s = 0; - } - pSim = Cec_ObjSimP( p, i ); - assert( !Cec_ManCswCompareConst( pSim, p->nWords ) ); - Key = Cec_ManCswHashKey( pSim, p->nWords, nTableSize ); + pSim = Cec_ObjSim( p, i ); + assert( !Cec_ManSimCompareConst( pSim, p->nWords ) ); + Key = Cec_ManSimHashKey( pSim, p->nWords, nTableSize ); if ( pTable[Key] == 0 ) { - assert( Cec_ObjRepr(p, i) == 0 ); - assert( Cec_ObjNext(p, i) == 0 ); - Cec_ObjSetRepr( p, i, -1 ); + assert( Gia_ObjRepr(p->pAig, i) == 0 ); + assert( Gia_ObjNext(p->pAig, i) == 0 ); + Gia_ObjSetRepr( p->pAig, i, GIA_VOID ); } else { - Cec_ObjSetNext( p, pTable[Key], i ); - Cec_ObjSetRepr( p, i, Cec_ObjRepr(p, pTable[Key]) ); - if ( Cec_ObjRepr(p, i) == -1 ) - Cec_ObjSetRepr( p, i, pTable[Key] ); - assert( Cec_ObjRepr(p, i) > 0 ); + Gia_ObjSetNext( p->pAig, pTable[Key], i ); + Gia_ObjSetRepr( p->pAig, i, Gia_ObjRepr(p->pAig, pTable[Key]) ); + if ( Gia_ObjRepr(p->pAig, i) == GIA_VOID ) + Gia_ObjSetRepr( p->pAig, i, pTable[Key] ); + assert( Gia_ObjRepr(p->pAig, i) > 0 ); } pTable[Key] = i; } Vec_IntForEachEntry( vRefined, i, k ) { - if ( Cec_ObjIsHead( p, i ) ) - Cec_ManCswClassRefineOne( p, i, 0 ); + if ( Gia_ObjIsHead( p->pAig, i ) ) + Cec_ManSimClassRefineOne( p, i ); } Vec_IntForEachEntry( vRefined, i, k ) - Cec_ManCswSimDeref( p, i ); + Cec_ManSimSimDeref( p, i ); ABC_FREE( pTable ); } /**Function************************************************************* + Synopsis [Saves the input pattern with the given number.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManSimSavePattern( Cec_ManSim_t * p, int iPat ) +{ + unsigned * pInfo; + int i; + assert( p->pCexComb == NULL ); + assert( iPat >= 0 && iPat < 32 * p->nWords ); + p->pCexComb = (Gia_Cex_t *)ABC_CALLOC( char, + sizeof(Gia_Cex_t) + sizeof(unsigned) * Aig_BitWordNum(Gia_ManCiNum(p->pAig)) ); + p->pCexComb->iPo = p->iOut; + p->pCexComb->nPis = Gia_ManCiNum(p->pAig); + p->pCexComb->nBits = Gia_ManCiNum(p->pAig); + for ( i = 0; i < Gia_ManCiNum(p->pAig); i++ ) + { + pInfo = Vec_PtrEntry( p->vCiSimInfo, i ); + if ( Aig_InfoHasBit( pInfo, iPat ) ) + Aig_InfoSetBit( p->pCexComb->pData, i ); + } +} + +/**Function************************************************************* + + Synopsis [Returns 1 if computation should stop.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManSimAnalyzeOutputs( Cec_ManSim_t * p ) +{ + unsigned * pInfo, * pInfo2; + int i; + if ( p->vCoSimInfo == NULL ) + return 0; + // compare outputs with 0 + if ( p->pPars->fDoubleOuts ) + { + assert( (Gia_ManCoNum(p->pAig) & 1) == 0 ); + for ( i = 0; i < Gia_ManCoNum(p->pAig); i++ ) + { + pInfo = Vec_PtrEntry( p->vCoSimInfo, i ); + pInfo2 = Vec_PtrEntry( p->vCoSimInfo, ++i ); + if ( !Cec_ManSimCompareEqual( pInfo, pInfo2, p->nWords ) ) + { + if ( p->iOut == -1 ) + { + p->iOut = i/2; + Cec_ManSimSavePattern( p, Cec_ManSimCompareEqualFirstBit(pInfo, pInfo2, p->nWords) ); + } + if ( p->pCexes == NULL ) + p->pCexes = ABC_CALLOC( void *, Gia_ManCoNum(p->pAig)/2 ); + if ( p->pCexes[i/2] == NULL ) + { + p->nOuts++; + p->pCexes[i/2] = (void *)1; + } + } + } + } + else + { + for ( i = 0; i < Gia_ManCoNum(p->pAig); i++ ) + { + pInfo = Vec_PtrEntry( p->vCoSimInfo, i ); + if ( !Cec_ManSimCompareConst( pInfo, p->nWords ) ) + { + if ( p->iOut == -1 ) + { + p->iOut = i; + Cec_ManSimSavePattern( p, Cec_ManSimCompareConstFirstBit(pInfo, p->nWords) ); + } + if ( p->pCexes == NULL ) + p->pCexes = ABC_CALLOC( void *, Gia_ManCoNum(p->pAig) ); + if ( p->pCexes[i] == NULL ) + { + p->nOuts++; + p->pCexes[i] = (void *)1; + } + } + } + } + return p->pCexes != NULL && p->pPars->fFirstStop; +} + +/**Function************************************************************* + Synopsis [Simulates one round.] Description [Returns the number of PO entry if failed; 0 otherwise.] @@ -765,17 +498,20 @@ void Cec_ManCswProcessRefined( Cec_ManCsw_t * p, Vec_Int_t * vRefined ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswSimulateRound( Cec_ManCsw_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t * vInfoCos, int iSeries, int fRandomize ) +int Cec_ManSimSimulateRound( Cec_ManSim_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t * vInfoCos ) { - static int nCountRand = 0; Gia_Obj_t * pObj; unsigned * pRes0, * pRes1, * pRes; int i, k, w, Ent, iCiId = 0, iCoId = 0; + // prepare internal storage + if ( p->nWordsOld != p->nWords ) + Cec_ManSimMemRelink( p ); p->nMemsMax = 0; + // simulate nodes Vec_IntClear( p->vRefinedC ); if ( Gia_ObjValue(Gia_ManConst0(p->pAig)) ) { - pRes = Cec_ManCswSimRef( p, 0 ); + pRes = Cec_ManSimSimRef( p, 0 ); for ( w = 1; w <= p->nWords; w++ ) pRes[w] = 0; } @@ -788,16 +524,12 @@ void Cec_ManCswSimulateRound( Cec_ManCsw_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t iCiId++; continue; } - pRes = Cec_ManCswSimRef( p, i ); + pRes = Cec_ManSimSimRef( p, i ); if ( vInfoCis ) { pRes0 = Vec_PtrEntry( vInfoCis, iCiId++ ); for ( w = 1; w <= p->nWords; w++ ) - { - pRes[w] = pRes0[iSeries*p->nWords+w-1]; - if ( fRandomize ) - pRes[w] ^= (1 << (nCountRand++ & 0x1f)); - } + pRes[w] = pRes0[w-1]; } else { @@ -810,7 +542,7 @@ void Cec_ManCswSimulateRound( Cec_ManCsw_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t } if ( Gia_ObjIsCo(pObj) ) // co always has non-zero 1st fanin and zero 2nd fanin { - pRes0 = Cec_ManCswSimDeref( p, Gia_ObjFaninId0(pObj,i) ); + pRes0 = Cec_ManSimSimDeref( p, Gia_ObjFaninId0(pObj,i) ); if ( vInfoCos ) { pRes = Vec_PtrEntry( vInfoCos, iCoId++ ); @@ -824,9 +556,9 @@ void Cec_ManCswSimulateRound( Cec_ManCsw_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t continue; } assert( Gia_ObjValue(pObj) ); - pRes = Cec_ManCswSimRef( p, i ); - pRes0 = Cec_ManCswSimDeref( p, Gia_ObjFaninId0(pObj,i) ); - pRes1 = Cec_ManCswSimDeref( p, Gia_ObjFaninId1(pObj,i) ); + pRes = Cec_ManSimSimRef( p, i ); + pRes0 = Cec_ManSimSimDeref( p, Gia_ObjFaninId0(pObj,i) ); + pRes1 = Cec_ManSimSimDeref( p, Gia_ObjFaninId1(pObj,i) ); if ( Gia_ObjFaninC0(pObj) ) { if ( Gia_ObjFaninC1(pObj) ) @@ -847,47 +579,50 @@ void Cec_ManCswSimulateRound( Cec_ManCsw_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t } references: // if this node is candidate constant, collect it - if ( Cec_ObjIsConst(p, i) && !Cec_ManCswCompareConst(pRes + 1, p->nWords) ) + if ( Gia_ObjIsConst(p->pAig, i) && !Cec_ManSimCompareConst(pRes + 1, p->nWords) ) { pRes[0]++; Vec_IntPush( p->vRefinedC, i ); } // if the node belongs to a class, save it - if ( Cec_ObjIsClass(p, i) ) + if ( Gia_ObjIsClass(p->pAig, i) ) pRes[0]++; // if this is the last node of the class, process it - if ( Cec_ObjIsTail(p, i) ) + if ( Gia_ObjIsTail(p->pAig, i) ) { Vec_IntClear( p->vClassTemp ); - Cec_ClassForEachObj( p, Cec_ObjRepr(p, i), Ent ) + Gia_ClassForEachObj( p->pAig, Gia_ObjRepr(p->pAig, i), Ent ) Vec_IntPush( p->vClassTemp, Ent ); - Cec_ManCswClassRefineOne( p, Cec_ObjRepr(p, i), 0 ); + Cec_ManSimClassRefineOne( p, Gia_ObjRepr(p->pAig, i) ); Vec_IntForEachEntry( p->vClassTemp, Ent, k ) - Cec_ManCswSimDeref( p, Ent ); + Cec_ManSimSimDeref( p, Ent ); } } if ( Vec_IntSize(p->vRefinedC) > 0 ) - Cec_ManCswProcessRefined( p, p->vRefinedC ); + Cec_ManSimProcessRefined( p, p->vRefinedC ); assert( vInfoCis == NULL || iCiId == Gia_ManCiNum(p->pAig) ); assert( vInfoCos == NULL || iCoId == Gia_ManCoNum(p->pAig) ); assert( p->nMems == 1 ); + if ( p->nMems != 1 ) + printf( "Cec_ManSimSimulateRound(): Memory management error!\n" ); if ( p->pPars->fVeryVerbose ) - Cec_ManCswPrintClasses( p, 0 ); + Gia_ManEquivPrintClasses( p->pAig, 0, Cec_MemUsage(p) ); /* - if ( p->nMems > 1 ) - { + if ( p->nMems > 1 ) { for ( i = 1; i < p->nObjs; i++ ) - if ( p->pSims[i] ) - { + if ( p->pSims[i] ) { int x = 0; } } */ + return Cec_ManSimAnalyzeOutputs( p ); } + + /**Function************************************************************* - Synopsis [] + Synopsis [Creates simulation info for this round.] Description [] @@ -896,28 +631,41 @@ references: SeeAlso [] ***********************************************************************/ -int Cec_ManCswClassesPrepare( Cec_ManCsw_t * p ) +void Cec_ManSimCreateInfo( Cec_ManSim_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t * vInfoCos ) { - int i; - Gia_ManSetRefs( p->pAig ); - Cec_ManCswSimulateSimple( p ); - Cec_ManCswClassesCreate( p ); - for ( i = 0; i < p->pPars->nRounds; i++ ) + unsigned * pRes0, * pRes1; + int i, w; + if ( p->pPars->fSeqSimulate && Gia_ManRegNum(p->pAig) > 0 ) { - p->nWords = i + 1; - Cec_ManCswSimMemRelink( p ); - Cec_ManCswSimulateRound( p, NULL, NULL, 0, 0 ); + assert( vInfoCis && vInfoCos ); + for ( i = 0; i < Gia_ManPiNum(p->pAig); i++ ) + { + pRes0 = Vec_PtrEntry( vInfoCis, i ); + for ( w = 0; w < p->nWords; w++ ) + pRes0[w] = Aig_ManRandom( 0 ); + } + for ( i = 0; i < Gia_ManRegNum(p->pAig); i++ ) + { + pRes0 = Vec_PtrEntry( vInfoCis, Gia_ManPiNum(p->pAig) + i ); + pRes1 = Vec_PtrEntry( vInfoCos, Gia_ManPoNum(p->pAig) + i ); + for ( w = 0; w < p->nWords; w++ ) + pRes0[w] = pRes1[w]; + } + } + else + { + for ( i = 0; i < Gia_ManCiNum(p->pAig); i++ ) + { + pRes0 = Vec_PtrEntry( vInfoCis, i ); + for ( w = 0; w < p->nWords; w++ ) + pRes0[w] = Aig_ManRandom( 0 ); + } } - p->nWords = p->pPars->nWords; - Cec_ManCswSimMemRelink( p ); - for ( i = 0; i < p->pPars->nRounds; i++ ) - Cec_ManCswSimulateRound( p, NULL, NULL, 0, 0 ); - return 1; } /**Function************************************************************* - Synopsis [] + Synopsis [Returns 1 if the bug is found.] Description [] @@ -926,21 +674,37 @@ int Cec_ManCswClassesPrepare( Cec_ManCsw_t * p ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswClassesUpdate_rec( Gia_Obj_t * pObj ) +int Cec_ManSimClassesPrepare( Cec_ManSim_t * p ) { - int Result; - if ( pObj->fMark0 ) - return 1; - if ( Gia_ObjIsCi(pObj) || Gia_ObjIsConst0(pObj) ) - return 0; - Result = (Cec_ManCswClassesUpdate_rec( Gia_ObjFanin0(pObj) ) | - Cec_ManCswClassesUpdate_rec( Gia_ObjFanin1(pObj) )); - return pObj->fMark0 = Result; + Gia_Obj_t * pObj; + int i; + assert( p->pAig->pReprs == NULL ); + // allocate representation + p->pAig->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p->pAig) ); + p->pAig->pNexts = ABC_CALLOC( int, Gia_ManObjNum(p->pAig) ); + Gia_ManForEachObj( p->pAig, pObj, i ) + Gia_ObjSetRepr( p->pAig, i, (Gia_ObjIsAnd(pObj) || Gia_ObjIsCi(pObj)) ? 0 : GIA_VOID ); + // perform simulation + Gia_ManSetRefs( p->pAig ); + p->nWords = 1; + do { + if ( p->pPars->fVerbose ) + Gia_ManEquivPrintClasses( p->pAig, 0, Cec_MemUsage(p) ); + for ( i = 0; i < 4; i++ ) + { + Cec_ManSimCreateInfo( p, p->vCiSimInfo, p->vCoSimInfo ); + if ( Cec_ManSimSimulateRound( p, p->vCiSimInfo, p->vCoSimInfo ) ) + return 1; + } + p->nWords = 2 * p->nWords + 1; + } + while ( p->nWords <= p->pPars->nWords ); + return 0; } /**Function************************************************************* - Synopsis [] + Synopsis [Returns 1 if the bug is found.] Description [] @@ -949,100 +713,23 @@ int Cec_ManCswClassesUpdate_rec( Gia_Obj_t * pObj ) SeeAlso [] ***********************************************************************/ -int Cec_ManCswClassesUpdate( Cec_ManCsw_t * p, Cec_ManPat_t * pPat, Gia_Man_t * pNew ) +int Cec_ManSimClassesRefine( Cec_ManSim_t * p ) { - Vec_Ptr_t * vInfo; - Gia_Obj_t * pObj, * pObjOld, * pReprOld; - int i, k, iRepr, iNode; - vInfo = Cec_ManPatCollectPatterns( pPat, Gia_ManCiNum(p->pAig), p->pPars->nWords ); - if ( vInfo != NULL ) - { - for ( i = 0; i < pPat->nSeries; i++ ) - Cec_ManCswSimulateRound( p, vInfo, NULL, i, 0 ); - Vec_PtrFree( vInfo ); - } - assert( Vec_IntSize(p->vXorNodes) == 2*Gia_ManCoNum(pNew) ); - // mark the transitive fanout of failed nodes - if ( p->pPars->nDepthMax != 1 ) + int i; + Gia_ManSetRefs( p->pAig ); + p->nWords = p->pPars->nWords; + for ( i = 0; i < p->pPars->nRounds; i++ ) { - Gia_ManCleanMark0( p->pAig ); - Gia_ManCleanMark1( p->pAig ); - Gia_ManForEachCo( pNew, pObj, k ) - { - iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); - iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); - if ( pObj->fMark0 == 0 && pObj->fMark1 == 1 ) // proved - continue; -// Gia_ManObj(p->pAig, iRepr)->fMark0 = 1; - Gia_ManObj(p->pAig, iNode)->fMark0 = 1; - } - // mark the nodes reachable through the failed nodes - Gia_ManForEachAnd( p->pAig, pObjOld, k ) - pObjOld->fMark0 |= (Gia_ObjFanin0(pObjOld)->fMark0 | Gia_ObjFanin1(pObjOld)->fMark0); - // unmark the disproved nodes - Gia_ManForEachCo( pNew, pObj, k ) - { - iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); - iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); - if ( pObj->fMark0 == 0 && pObj->fMark1 == 1 ) // proved - continue; - pObjOld = Gia_ManObj(p->pAig, iNode); - assert( pObjOld->fMark0 == 1 ); - if ( Gia_ObjFanin0(pObjOld)->fMark0 == 0 && Gia_ObjFanin1(pObjOld)->fMark0 == 0 ) - pObjOld->fMark1 = 1; - } - // clean marks - Gia_ManForEachAnd( p->pAig, pObjOld, k ) - if ( pObjOld->fMark1 ) - { - pObjOld->fMark0 = 0; - pObjOld->fMark1 = 0; - } + if ( (i % 4) == 0 && p->pPars->fVerbose ) + Gia_ManEquivPrintClasses( p->pAig, 0, Cec_MemUsage(p) ); + Cec_ManSimCreateInfo( p, p->vCiSimInfo, p->vCoSimInfo ); + if ( Cec_ManSimSimulateRound( p, p->vCiSimInfo, p->vCoSimInfo ) ) + return 1; } - // set the results - Gia_ManForEachCo( pNew, pObj, k ) - { - iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); - iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); - pReprOld = Gia_ManObj(p->pAig, iRepr); - pObjOld = Gia_ManObj(p->pAig, iNode); - if ( pObj->fMark1 ) - { // proved - assert( pObj->fMark0 == 0 ); - assert( !Cec_ObjProved(p, iNode) ); - if ( pReprOld->fMark0 == 0 && pObjOld->fMark0 == 0 ) -// if ( pObjOld->fMark0 == 0 ) - { - assert( iRepr == Cec_ObjRepr(p, iNode) ); - Cec_ObjSetProved( p, iNode ); - p->nAllProved++; - } - } - else if ( pObj->fMark0 ) - { // disproved - assert( pObj->fMark1 == 0 ); - if ( pReprOld->fMark0 == 0 && pObjOld->fMark0 == 0 ) -// if ( pObjOld->fMark0 == 0 ) - { - if ( iRepr == Cec_ObjRepr(p, iNode) ) - printf( "Cec_ManCswClassesUpdate(): Error! Node is not refined!\n" ); - p->nAllDisproved++; - } - } - else - { // failed - assert( pObj->fMark0 == 0 ); - assert( pObj->fMark1 == 0 ); - assert( !Cec_ObjFailed(p, iNode) ); - assert( !Cec_ObjProved(p, iNode) ); - Cec_ObjSetFailed( p, iNode ); - p->nAllFailed++; - } - } + if ( p->pPars->fVerbose ) + Gia_ManEquivPrintClasses( p->pAig, 0, Cec_MemUsage(p) ); return 0; } - - //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/cec/cecCore.c b/src/aig/cec/cecCore.c index ab8fd5cf..e25ddc90 100644 --- a/src/aig/cec/cecCore.c +++ b/src/aig/cec/cecCore.c @@ -44,11 +44,37 @@ void Cec_ManSatSetDefaultParams( Cec_ParSat_t * p ) memset( p, 0, sizeof(Cec_ParSat_t) ); p->nBTLimit = 10; // conflict limit at a node p->nSatVarMax = 2000; // the max number of SAT variables - p->nCallsRecycle = 100; // calls to perform before recycling SAT solver + p->nCallsRecycle = 200; // calls to perform before recycling SAT solver p->fPolarFlip = 1; // flops polarity of variables + p->fCheckMiter = 0; // the circuit is the miter p->fFirstStop = 0; // stop on the first sat output - p->fVerbose = 1; // verbose stats + p->fVerbose = 0; // verbose stats } + +/**Function************ ************************************************* + + Synopsis [This procedure sets default parameters.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManSimSetDefaultParams( Cec_ParSim_t * p ) +{ + memset( p, 0, sizeof(Cec_ParSim_t) ); + p->nWords = 15; // the number of simulation words + p->nRounds = 15; // the number of simulation rounds + p->TimeLimit = 0; // the runtime limit in seconds + p->fCheckMiter = 0; // the circuit is the miter + p->fFirstStop = 0; // stop on the first sat output + p->fDoubleOuts = 0; // miter with separate outputs + p->fSeqSimulate = 0; // performs sequential simulation + p->fVeryVerbose = 0; // verbose stats + p->fVerbose = 0; // verbose stats +} /**Function************ ************************************************* @@ -61,19 +87,21 @@ void Cec_ManSatSetDefaultParams( Cec_ParSat_t * p ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswSetDefaultParams( Cec_ParCsw_t * p ) +void Cec_ManFraSetDefaultParams( Cec_ParFra_t * p ) { - memset( p, 0, sizeof(Cec_ParCsw_t) ); - p->nWords = 20; // the number of simulation words - p->nRounds = 20; // the number of simulation rounds - p->nItersMax = 20; // the maximum number of iterations of SAT sweeping - p->nBTLimit = 10000; // conflict limit at a node - p->nSatVarMax = 2000; // the max number of SAT variables - p->nCallsRecycle = 100; // calls to perform before recycling SAT solver + memset( p, 0, sizeof(Cec_ParFra_t) ); + p->nWords = 15; // the number of simulation words + p->nRounds = 15; // the number of simulation rounds + p->TimeLimit = 0; // the runtime limit in seconds + p->nItersMax = 1000; // the maximum number of iterations of SAT sweeping + p->nBTLimit = 1000; // conflict limit at a node p->nLevelMax = 0; // restriction on the level of nodes to be swept p->nDepthMax = 1; // the depth in terms of steps of speculative reduction p->fRewriting = 0; // enables AIG rewriting + p->fCheckMiter = 0; // the circuit is the miter p->fFirstStop = 0; // stop on the first sat output + p->fDoubleOuts = 0; // miter with separate outputs + p->fColorDiff = 0; // miter with separate outputs p->fVeryVerbose = 0; // verbose stats p->fVerbose = 0; // verbose stats } @@ -92,14 +120,13 @@ void Cec_ManCswSetDefaultParams( Cec_ParCsw_t * p ) void Cec_ManCecSetDefaultParams( Cec_ParCec_t * p ) { memset( p, 0, sizeof(Cec_ParCec_t) ); - p->nIters = 1; // iterations of SAT solving/sweeping - p->nBTLimitBeg = 2; // starting backtrack limit - p->nBTlimitMulti = 8; // multiple of backtrack limiter + p->nBTLimit = 1000; // conflict limit at a node + p->TimeLimit = 0; // the runtime limit in seconds + p->fFirstStop = 0; // stop on the first sat output p->fUseSmartCnf = 0; // use smart CNF computation p->fRewriting = 0; // enables AIG rewriting - p->fSatSweeping = 0; // enables SAT sweeping - p->fFirstStop = 0; // stop on the first sat output - p->fVerbose = 1; // verbose stats + p->fVeryVerbose = 0; // verbose stats + p->fVerbose = 0; // verbose stats } /**Function************************************************************* @@ -124,6 +151,35 @@ Gia_Man_t * Cec_ManSatSolving( Gia_Man_t * pAig, Cec_ParSat_t * pPars ) return pNew; } +/**Function************************************************************* + + Synopsis [Core procedure for simulation.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManSimulation( Gia_Man_t * pAig, Cec_ParSim_t * pPars ) +{ + Cec_ManSim_t * pSim; + int RetValue, clkTotal = clock(); + if ( pPars->fSeqSimulate ) + printf( "Performing sequential simulation of %d frames with %d words.\n", + pPars->nWords, pPars->nRounds ); + Aig_ManRandom( 1 ); + pSim = Cec_ManSimStart( pAig, pPars ); + if ( pAig->pReprs == NULL ) + RetValue = Cec_ManSimClassesPrepare( pSim ); + Cec_ManSimClassesRefine( pSim ); + if ( pPars->fCheckMiter ) + printf( "The number of failed outputs of the miter = %6d. (Words = %4d. Rounds = %4d.)\n", + pSim->iOut, pSim->nOuts, pPars->nWords, pPars->nRounds ); + ABC_PRT( "Time", clock() - clkTotal ); + Cec_ManSimStop( pSim ); +} /**Function************************************************************* @@ -136,96 +192,185 @@ Gia_Man_t * Cec_ManSatSolving( Gia_Man_t * pAig, Cec_ParSat_t * pPars ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Cec_ManSatSweeping( Gia_Man_t * pAig, Cec_ParCsw_t * pPars ) +Gia_Man_t * Cec_ManSatSweeping( Gia_Man_t * pAig, Cec_ParFra_t * pPars ) { + int fOutputResult = 0; Cec_ParSat_t ParsSat, * pParsSat = &ParsSat; - Gia_Man_t * pNew; - Cec_ManCsw_t * p; + Cec_ParSim_t ParsSim, * pParsSim = &ParsSim; + Gia_Man_t * pIni, * pSrm, * pTemp; + Cec_ManFra_t * p; + Cec_ManSim_t * pSim; Cec_ManPat_t * pPat; - int i, RetValue, clk, clk2, clkTotal = clock(); + int i, fTimeOut = 0, nMatches = 0, clk, clk2; + double clkTotal = clock(); + + // duplicate AIG and transfer equivalence classes Aig_ManRandom( 1 ); - Gia_ManSetPhase( pAig ); - Gia_ManCleanMark0( pAig ); - Gia_ManCleanMark1( pAig ); - p = Cec_ManCswStart( pAig, pPars ); -clk = clock(); - RetValue = Cec_ManCswClassesPrepare( p ); -p->timeSim += clock() - clk; + pIni = Gia_ManDup(pAig); + pIni->pReprs = pAig->pReprs; pAig->pReprs = NULL; + pIni->pNexts = pAig->pNexts; pAig->pNexts = NULL; + + // prepare the managers + // SAT sweeping + p = Cec_ManFraStart( pIni, pPars ); + if ( pPars->fDoubleOuts ) + pPars->fColorDiff = 1; + // simulation + Cec_ManSimSetDefaultParams( pParsSim ); + pParsSim->nWords = pPars->nWords; + pParsSim->nRounds = pPars->nRounds; + pParsSim->fCheckMiter = pPars->fCheckMiter; + pParsSim->fFirstStop = pPars->fFirstStop; + pParsSim->fDoubleOuts = pPars->fDoubleOuts; + pParsSim->fVerbose = pPars->fVerbose; + pSim = Cec_ManSimStart( p->pAig, pParsSim ); + pSim->nWords = p->pPars->nWords; + // SAT solving Cec_ManSatSetDefaultParams( pParsSat ); pParsSat->nBTLimit = pPars->nBTLimit; pParsSat->fVerbose = pPars->fVeryVerbose; + // simulation patterns pPat = Cec_ManPatStart(); pPat->fVerbose = pPars->fVeryVerbose; + + // start equivalence classes +clk = clock(); + if ( p->pAig->pReprs == NULL ) + { + if ( Cec_ManSimClassesPrepare(pSim) || Cec_ManSimClassesRefine(pSim) ) + { + Gia_ManStop( p->pAig ); + p->pAig = NULL; + goto finalize; + } + } +p->timeSim += clock() - clk; + // perform solving for ( i = 1; i <= pPars->nItersMax; i++ ) { clk2 = clock(); - pNew = Cec_ManCswSpecReduction( p ); - if ( pPars->fVeryVerbose ) + nMatches = 0; + if ( pPars->fDoubleOuts ) { - Gia_ManPrintStats( p->pAig ); - Gia_ManPrintStats( pNew ); + nMatches = Gia_ManEquivSetColors( p->pAig, pPars->fVeryVerbose ); +// p->pAig->pIso = Cec_ManDetectIsomorphism( p->pAig ); +// Gia_ManEquivTransform( p->pAig, 1 ); } - if ( Gia_ManCoNum(pNew) == 0 ) + pSrm = Cec_ManFraSpecReduction( p ); + if ( pPars->fVeryVerbose ) + Gia_ManPrintStats( pSrm ); + if ( Gia_ManCoNum(pSrm) == 0 ) { - Gia_ManStop( pNew ); + Gia_ManStop( pSrm ); + if ( p->pPars->fVerbose ) + printf( "Considered all available candidate equivalences.\n" ); + if ( pPars->fDoubleOuts && Gia_ManAndNum(p->pAig) > 0 ) + { + if ( pPars->fColorDiff ) + { + if ( p->pPars->fVerbose ) + printf( "Switching into reduced mode.\n" ); + pPars->fColorDiff = 0; + } + else + { + if ( p->pPars->fVerbose ) + printf( "Switching into normal mode.\n" ); + pPars->fDoubleOuts = 0; + } + continue; + } break; } clk = clock(); - Cec_ManSatSolve( pPat, pNew, pParsSat ); + Cec_ManSatSolve( pPat, pSrm, pParsSat ); p->timeSat += clock() - clk; -clk = clock(); - Cec_ManCswClassesUpdate( p, pPat, pNew ); -p->timeSim += clock() - clk; - Gia_ManStop( pNew ); - pNew = Cec_ManCswDupWithClasses( p ); - Gia_WriteAiger( pNew, "gia_temp_new.aig", 0, 1 ); + if ( Cec_ManFraClassesUpdate( p, pSim, pPat, pSrm ) ) + { + Gia_ManStop( pSrm ); + Gia_ManStop( p->pAig ); + p->pAig = NULL; + goto finalize; + } + Gia_ManStop( pSrm ); + + // update the manager + pSim->pAig = p->pAig = Gia_ManEquivReduceAndRemap( pTemp = p->pAig, 0, pParsSim->fDoubleOuts ); + Gia_ManStop( pTemp ); if ( p->pPars->fVerbose ) { - printf( "%3d : P =%7d. D =%7d. F =%6d. Lit =%8d. And =%8d. ", - i, p->nAllProved, p->nAllDisproved, p->nAllFailed, - Cec_ManCswCountLitsAll(p), Gia_ManAndNum(pNew) ); + printf( "%3d : P =%7d. D =%7d. F =%6d. M = %7d. And =%8d. ", + i, p->nAllProved, p->nAllDisproved, p->nAllFailed, nMatches, Gia_ManAndNum(p->pAig) ); ABC_PRT( "Time", clock() - clk2 ); } - if ( p->pPars->fVeryVerbose ) + if ( Gia_ManAndNum(p->pAig) == 0 ) { - ABC_PRTP( "Sim ", p->timeSim, clock() - clkTotal ); - ABC_PRTP( "Sat ", p->timeSat, clock() - clkTotal ); - ABC_PRT( "Time", clock() - clkTotal ); - printf( "****** Intermedate result %3d ******\n", i ); - Gia_ManPrintStats( p->pAig ); - Gia_ManPrintStats( pNew ); - printf("The result is written into file \"%s\".\n", "gia_temp.aig" ); - printf( "************************************\n" ); + if ( p->pPars->fVerbose ) + printf( "Network after reduction is empty.\n" ); + break; } - if ( Gia_ManAndNum(pNew) == 0 ) + // check resource limits + if ( p->pPars->TimeLimit && ((double)clock() - clkTotal)/CLOCKS_PER_SEC >= p->pPars->TimeLimit ) { - Gia_ManStop( pNew ); + fTimeOut = 1; break; } - Gia_ManStop( pNew ); +// if ( p->nAllFailed && !p->nAllProved && !p->nAllDisproved ) + if ( p->nAllFailed > p->nAllProved + p->nAllDisproved ) + { + if ( pParsSat->nBTLimit >= 10000 ) + break; + pParsSat->nBTLimit *= 10; + if ( p->pPars->fVerbose ) + { + if ( p->pPars->fVerbose ) + printf( "Increasing conflict limit to %d.\n", pParsSat->nBTLimit ); + if ( fOutputResult ) + { + Gia_WriteAiger( p->pAig, "gia_cec_temp.aig", 0, 0 ); + printf("The result is written into file \"%s\".\n", "gia_cec_temp.aig" ); + } + } + } + if ( pPars->fDoubleOuts && pPars->fColorDiff && Gia_ManAndNum(p->pAig) < 100000 ) + { + if ( p->pPars->fVerbose ) + printf( "Switching into reduced mode.\n" ); + pPars->fColorDiff = 0; + } + if ( pPars->fDoubleOuts && Gia_ManAndNum(p->pAig) < 20000 ) + { + if ( p->pPars->fVerbose ) + printf( "Switching into normal mode.\n" ); + pPars->fColorDiff = 0; + pPars->fDoubleOuts = 0; + } } - Gia_ManCleanMark0( pAig ); - Gia_ManCleanMark1( pAig ); - - // verify the result +finalize: if ( p->pPars->fVerbose ) { - printf( "Verifying the result:\n" ); - pNew = Cec_ManCswSpecReductionProved( p ); - pParsSat->nBTLimit = 1000000; - pParsSat->fVerbose = 1; - Cec_ManSatSolve( NULL, pNew, pParsSat ); - Gia_ManStop( pNew ); + ABC_PRTP( "Sim ", p->timeSim, clock() - (int)clkTotal ); + ABC_PRTP( "Sat ", p->timeSat-pPat->timeTotalSave, clock() - (int)clkTotal ); + ABC_PRTP( "Pat ", p->timePat+pPat->timeTotalSave, clock() - (int)clkTotal ); + ABC_PRT( "Time", clock() - clkTotal ); } - // create the resulting miter - pAig->pReprs = Cec_ManCswDeriveReprs( p ); - pNew = Gia_ManDupDfsClasses( pAig ); - Cec_ManCswStop( p ); + pTemp = p->pAig; p->pAig = NULL; + if ( pTemp == NULL ) + printf( "Disproved at least one output of the miter (zero-based number %d).\n", pSim->iOut ); + else if ( pSim->pCexes ) + printf( "Disproved %d outputs of the miter.\n", pSim->nOuts ); + if ( fTimeOut ) + printf( "Timed out after %d seconds.\n", (int)((double)clock() - clkTotal)/CLOCKS_PER_SEC ); + + pAig->pCexComb = pSim->pCexComb; pSim->pCexComb = NULL; + Cec_ManSimStop( pSim ); Cec_ManPatStop( pPat ); - return pNew; + Cec_ManFraStop( p ); + return pTemp; } + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/cec/cecInt.h b/src/aig/cec/cecInt.h index 309f4292..1898b07c 100644 --- a/src/aig/cec/cecInt.h +++ b/src/aig/cec/cecInt.h @@ -65,6 +65,7 @@ struct Cec_ManPat_t_ int timeSort; // sorting literals int timePack; // packing into sim info structures int timeTotal; // total runtime + int timeTotalSave; // total runtime for saving }; // SAT solving manager @@ -100,38 +101,43 @@ struct Cec_ManSat_t_ int timeTotal; // total runtime }; -// combinational sweeping object -typedef struct Cec_ObjCsw_t_ Cec_ObjCsw_t; -struct Cec_ObjCsw_t_ -{ - int iRepr; // representative node - unsigned iNext : 30; // next node in the class - unsigned iProved : 1; // this node is proved - unsigned iFailed : 1; // this node is failed - unsigned SimNum; // simulation info number -}; - // combinational simulation manager -typedef struct Cec_ManCsw_t_ Cec_ManCsw_t; -struct Cec_ManCsw_t_ +typedef struct Cec_ManSim_t_ Cec_ManSim_t; +struct Cec_ManSim_t_ { // parameters Gia_Man_t * pAig; // the AIG to be used for simulation - Cec_ParCsw_t * pPars; // SAT sweeping parameters + Cec_ParSim_t * pPars; // simulation parameters int nWords; // the number of simulation words - // equivalence classes - Cec_ObjCsw_t * pObjs; // objects used for SAT sweeping // recycable memory + int * pSimInfo; // simulation information offsets unsigned * pMems; // allocated simulaton memory int nWordsAlloc; // the number of allocated entries int nMems; // the number of used entries int nMemsMax; // the max number of used entries int MemFree; // next free entry + int nWordsOld; // the number of simulation words after previous relink + // bug catcher + Vec_Ptr_t * vCiSimInfo; // CI simulation info + Vec_Ptr_t * vCoSimInfo; // CO simulation info + void ** pCexes; // counter-examples for each output + int iOut; // first failed output + int nOuts; // the number of failed outputs + Gia_Cex_t * pCexComb; // counter-example for the first failed output // temporaries Vec_Int_t * vClassOld; // old class numbers Vec_Int_t * vClassNew; // new class numbers Vec_Int_t * vClassTemp; // temporary storage Vec_Int_t * vRefinedC; // refined const reprs +}; + +// combinational simulation manager +typedef struct Cec_ManFra_t_ Cec_ManFra_t; +struct Cec_ManFra_t_ +{ + // parameters + Gia_Man_t * pAig; // the AIG to be used for simulation + Cec_ParFra_t * pPars; // SAT sweeping parameters // simulation patterns Vec_Int_t * vXorNodes; // nodes used in speculative reduction int nAllProved; // total number of proved nodes @@ -139,6 +145,7 @@ struct Cec_ManCsw_t_ int nAllFailed; // total number of failed nodes // runtime stats int timeSim; // unsat + int timePat; // unsat int timeSat; // sat int timeTotal; // total runtime }; @@ -153,29 +160,31 @@ struct Cec_ManCsw_t_ /*=== cecCore.c ============================================================*/ /*=== cecClass.c ============================================================*/ -extern int Cec_ManCswCountLitsAll( Cec_ManCsw_t * p ); -extern int * Cec_ManCswDeriveReprs( Cec_ManCsw_t * p ); -extern Gia_Man_t * Cec_ManCswSpecReduction( Cec_ManCsw_t * p ); -extern Gia_Man_t * Cec_ManCswSpecReductionProved( Cec_ManCsw_t * p ); -extern Gia_Man_t * Cec_ManCswDupWithClasses( Cec_ManCsw_t * p ); -extern int Cec_ManCswClassesPrepare( Cec_ManCsw_t * p ); -extern int Cec_ManCswClassesUpdate( Cec_ManCsw_t * p, Cec_ManPat_t * pPat, Gia_Man_t * pNew ); +extern int Cec_ManSimClassesPrepare( Cec_ManSim_t * p ); +extern int Cec_ManSimClassesRefine( Cec_ManSim_t * p ); +extern int Cec_ManSimSimulateRound( Cec_ManSim_t * p, Vec_Ptr_t * vInfoCis, Vec_Ptr_t * vInfoCos ); +/*=== cecIso.c ============================================================*/ +extern int * Cec_ManDetectIsomorphism( Gia_Man_t * p ); /*=== cecMan.c ============================================================*/ -extern Cec_ManCsw_t * Cec_ManCswStart( Gia_Man_t * pAig, Cec_ParCsw_t * pPars ); -extern void Cec_ManCswStop( Cec_ManCsw_t * p ); -extern Cec_ManPat_t * Cec_ManPatStart(); -extern void Cec_ManPatPrintStats( Cec_ManPat_t * p ); -extern void Cec_ManPatStop( Cec_ManPat_t * p ); extern Cec_ManSat_t * Cec_ManSatCreate( Gia_Man_t * pAig, Cec_ParSat_t * pPars ); extern void Cec_ManSatPrintStats( Cec_ManSat_t * p ); extern void Cec_ManSatStop( Cec_ManSat_t * p ); +extern Cec_ManPat_t * Cec_ManPatStart(); +extern void Cec_ManPatPrintStats( Cec_ManPat_t * p ); +extern void Cec_ManPatStop( Cec_ManPat_t * p ); +extern Cec_ManSim_t * Cec_ManSimStart( Gia_Man_t * pAig, Cec_ParSim_t * pPars ); +extern void Cec_ManSimStop( Cec_ManSim_t * p ); +extern Cec_ManFra_t * Cec_ManFraStart( Gia_Man_t * pAig, Cec_ParFra_t * pPars ); +extern void Cec_ManFraStop( Cec_ManFra_t * p ); /*=== cecPat.c ============================================================*/ extern void Cec_ManPatSavePattern( Cec_ManPat_t * pPat, Cec_ManSat_t * p, Gia_Obj_t * pObj ); extern Vec_Ptr_t * Cec_ManPatCollectPatterns( Cec_ManPat_t * pMan, int nInputs, int nWords ); /*=== cecSolve.c ============================================================*/ extern int Cec_ObjSatVarValue( Cec_ManSat_t * p, Gia_Obj_t * pObj ); extern void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPars ); -/*=== cecUtil.c ============================================================*/ +/*=== ceFraeep.c ============================================================*/ +extern Gia_Man_t * Cec_ManFraSpecReduction( Cec_ManFra_t * p ); +extern int Cec_ManFraClassesUpdate( Cec_ManFra_t * p, Cec_ManSim_t * pSim, Cec_ManPat_t * pPat, Gia_Man_t * pNew ); #ifdef __cplusplus } diff --git a/src/aig/cec/cecIso.c b/src/aig/cec/cecIso.c new file mode 100644 index 00000000..08d4b7ec --- /dev/null +++ b/src/aig/cec/cecIso.c @@ -0,0 +1,370 @@ +/**CFile**************************************************************** + + FileName [cecIso.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Combinatinoal equivalence checking.] + + Synopsis [Detection of structural isomorphism.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: cecIso.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "cecInt.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +static inline unsigned * Cec_ManIsoInfo( unsigned * pStore, int nWords, int Id ) { return pStore + nWords * Id; } + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Computes simulation info for one node.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Gia_ManIsoSimulate( Gia_Obj_t * pObj, int Id, unsigned * pStore, int nWords ) +{ + unsigned * pInfo = Cec_ManIsoInfo( pStore, nWords, Id ); + unsigned * pInfo0 = Cec_ManIsoInfo( pStore, nWords, Gia_ObjFaninId0(pObj, Id) ); + unsigned * pInfo1 = Cec_ManIsoInfo( pStore, nWords, Gia_ObjFaninId1(pObj, Id) ); + int w; + if ( Gia_ObjFaninC0(pObj) ) + { + if ( Gia_ObjFaninC1(pObj) ) + for ( w = 0; w < nWords; w++ ) + pInfo[w] = ~(pInfo0[w] | pInfo1[w]); + else + for ( w = 0; w < nWords; w++ ) + pInfo[w] = ~pInfo0[w] & pInfo1[w]; + } + else + { + if ( Gia_ObjFaninC1(pObj) ) + for ( w = 0; w < nWords; w++ ) + pInfo[w] = pInfo0[w] & ~pInfo1[w]; + else + for ( w = 0; w < nWords; w++ ) + pInfo[w] = pInfo0[w] & pInfo1[w]; + } +} + +/**Function************************************************************* + + Synopsis [Copies simulation info.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Gia_ManIsoCopy( int IdDest, int IdSour, unsigned * pStore, int nWords ) +{ + unsigned * pInfo0 = Cec_ManIsoInfo( pStore, nWords, IdDest ); + unsigned * pInfo1 = Cec_ManIsoInfo( pStore, nWords, IdSour ); + int w; + for ( w = 0; w < nWords; w++ ) + pInfo0[w] = pInfo1[w]; +} + +/**Function************************************************************* + + Synopsis [Compares simulation info of two nodes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Gia_ManIsoEqual( int Id0, int Id1, unsigned * pStore, int nWords ) +{ + unsigned * pInfo0 = Cec_ManIsoInfo( pStore, nWords, Id0 ); + unsigned * pInfo1 = Cec_ManIsoInfo( pStore, nWords, Id1 ); + int w; + for ( w = 0; w < nWords; w++ ) + if ( pInfo0[w] != pInfo1[w] ) + return 0; + return 1; +} + +/**Function************************************************************* + + Synopsis [Generates random simulation info.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Gia_ManIsoRandom( int Id, unsigned * pStore, int nWords ) +{ + unsigned * pInfo0 = Cec_ManIsoInfo( pStore, nWords, Id ); + int w; + for ( w = 0; w < nWords; w++ ) + pInfo0[w] = Aig_ManRandom( 0 ); +} + +/**Function************************************************************* + + Synopsis [Computes hash key of the simuation info.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Gia_ManIsoHashKey( int Id, unsigned * pStore, int nWords, int nTableSize ) +{ + static int s_Primes[16] = { + 1291, 1699, 1999, 2357, 2953, 3313, 3907, 4177, + 4831, 5147, 5647, 6343, 6899, 7103, 7873, 8147 }; + unsigned * pInfo0 = Cec_ManIsoInfo( pStore, nWords, Id ); + unsigned uHash = 0; + int i; + for ( i = 0; i < nWords; i++ ) + uHash ^= pInfo0[i] * s_Primes[i & 0xf]; + return (int)(uHash % nTableSize); + +} + +/**Function************************************************************* + + Synopsis [Adds node to the hash table.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Gia_ManIsoTableAdd( Gia_Man_t * p, int Id, unsigned * pStore, int nWords, int * pTable, int nTableSize ) +{ + Gia_Obj_t * pTemp; + int Key, Ent, Counter = 0, Color = Gia_ObjColors( p, Id ); + assert( Color == 1 || Color == 2 ); + Key = Gia_ManIsoHashKey( Id, pStore, nWords, nTableSize ); + for ( Ent = pTable[Key], pTemp = (Ent ? Gia_ManObj(p, Ent) : NULL); pTemp; + Ent = pTemp->Value, pTemp = (Ent ? Gia_ManObj(p, Ent) : NULL) ) + { + if ( Gia_ObjColors( p, Ent ) != Color ) + continue; + if ( !Gia_ManIsoEqual( Id, Ent, pStore, nWords ) ) + continue; + // found node with the same color and signature - mark it and do not add new node + pTemp->fMark0 = 1; + return; + } + // did not find the node with the same color and signature - add new node + pTemp = Gia_ManObj( p, Id ); + assert( pTemp->Value == 0 ); + assert( pTemp->fMark0 == 0 ); + pTemp->Value = pTable[Key]; + pTable[Key] = Id; +} + +/**Function************************************************************* + + Synopsis [Extracts equivalence class candidates from one bin.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Gia_ManIsoExtractClasses( Gia_Man_t * p, int Bin, unsigned * pStore, int nWords, Vec_Int_t * vNodesA, Vec_Int_t * vNodesB ) +{ + Gia_Obj_t * pTemp; + int Ent; + Vec_IntClear( vNodesA ); + Vec_IntClear( vNodesB ); + for ( Ent = Bin, pTemp = (Ent ? Gia_ManObj(p, Ent) : NULL); pTemp; + Ent = pTemp->Value, pTemp = (Ent ? Gia_ManObj(p, Ent) : NULL) ) + { + if ( pTemp->fMark0 ) + { + pTemp->fMark0 = 0; + continue; + } + if ( Gia_ObjColors( p, Ent ) == 1 ) + Vec_IntPush( vNodesA, Ent ); + else + Vec_IntPush( vNodesB, Ent ); + } + return Vec_IntSize(vNodesA) > 0 && Vec_IntSize(vNodesB) > 0; +} + +/**Function************************************************************* + + Synopsis [Matches nodes in the extacted classes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Gia_ManIsoMatchNodes( int * pIso, unsigned * pStore, int nWords, Vec_Int_t * vNodesA, Vec_Int_t * vNodesB ) +{ + int k0, k1, IdA, IdB; + Vec_IntForEachEntry( vNodesA, IdA, k0 ) + Vec_IntForEachEntry( vNodesB, IdB, k1 ) + { + if ( Gia_ManIsoEqual( IdA, IdB, pStore, nWords ) ) + { + assert( pIso[IdA] == 0 ); + assert( pIso[IdB] == 0 ); + assert( IdA != IdB ); + pIso[IdA] = IdB; + pIso[IdB] = IdA; + continue; + } + } +} + +/**Function************************************************************* + + Synopsis [Transforms iso into equivalence classes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManTransformClasses( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i; + assert( p->pReprs && p->pNexts && p->pIso ); + memset( p->pReprs, 0, sizeof(int) * Gia_ManObjNum(p) ); + memset( p->pNexts, 0, sizeof(int) * Gia_ManObjNum(p) ); + Gia_ManForEachObj( p, pObj, i ) + { + p->pReprs[i].iRepr = GIA_VOID; + if ( p->pIso[i] && p->pIso[i] < i ) + { + p->pReprs[i].iRepr = p->pIso[i]; + p->pNexts[p->pIso[i]] = i; + } + } +} + +/**Function************************************************************* + + Synopsis [Finds node correspondences in the miter.] + + Description [Assumes that the colors are assigned.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int * Cec_ManDetectIsomorphism( Gia_Man_t * p ) +{ + int nWords = 2; + Gia_Obj_t * pObj; + Vec_Int_t * vNodesA, * vNodesB; + unsigned * pStore, Counter; + int i, * pIso, * pTable, nTableSize; + // start equivalence classes + pIso = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_ManForEachObj( p, pObj, i ) + { + if ( Gia_ObjIsCo(pObj) ) + { + assert( Gia_ObjColors(p, i) == 0 ); + continue; + } + assert( Gia_ObjColors(p, i) ); + if ( Gia_ObjColors(p, i) == 3 ) + pIso[i] = i; + } + // start simulation info + pStore = ABC_ALLOC( unsigned, Gia_ManObjNum(p) * nWords ); + // simulate and create table + nTableSize = Aig_PrimeCudd( 100 + Gia_ManObjNum(p)/2 ); + pTable = ABC_CALLOC( int, nTableSize ); + Gia_ManCleanValue( p ); + Gia_ManForEachObj1( p, pObj, i ) + { + if ( Gia_ObjIsCo(pObj) ) + continue; + if ( pIso[i] == 0 ) // simulate + Gia_ManIsoSimulate( pObj, i, pStore, nWords ); + else if ( pIso[i] < i ) // copy + Gia_ManIsoCopy( i, pIso[i], pStore, nWords ); + else // generate + Gia_ManIsoRandom( i, pStore, nWords ); + if ( pIso[i] == 0 ) + Gia_ManIsoTableAdd( p, i, pStore, nWords, pTable, nTableSize ); + } + // create equivalence classes + vNodesA = Vec_IntAlloc( 100 ); + vNodesB = Vec_IntAlloc( 100 ); + for ( i = 0; i < nTableSize; i++ ) + if ( Gia_ManIsoExtractClasses( p, pTable[i], pStore, nWords, vNodesA, vNodesB ) ) + Gia_ManIsoMatchNodes( pIso, pStore, nWords, vNodesA, vNodesB ); + Vec_IntFree( vNodesA ); + Vec_IntFree( vNodesB ); + // collect info + Counter = 0; + Gia_ManForEachObj1( p, pObj, i ) + { + Counter += (pIso[i] && pIso[i] < i); +/* + if ( pIso[i] && pIso[i] < i ) + { + if ( (Gia_ObjIsHead(p,pIso[i]) && Gia_ObjRepr(p,i)==pIso[i]) || + (Gia_ObjIsClass(p,pIso[i]) && Gia_ObjRepr(p,i)==Gia_ObjRepr(p,pIso[i])) ) + printf( "1" ); + else + printf( "0" ); + } +*/ + } + printf( "Computed %d pairs of structurally equivalent nodes.\n", Counter ); +// p->pIso = pIso; +// Cec_ManTransformClasses( p ); + + ABC_FREE( pTable ); + ABC_FREE( pStore ); + return pIso; +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/cec/cecMan.c b/src/aig/cec/cecMan.c index b8ee75b2..1a94409f 100644 --- a/src/aig/cec/cecMan.c +++ b/src/aig/cec/cecMan.c @@ -30,7 +30,7 @@ /**Function************************************************************* - Synopsis [Creates AIG.] + Synopsis [Creates the manager.] Description [] @@ -39,26 +39,25 @@ SeeAlso [] ***********************************************************************/ -Cec_ManCsw_t * Cec_ManCswStart( Gia_Man_t * pAig, Cec_ParCsw_t * pPars ) -{ - Cec_ManCsw_t * p; - p = ABC_ALLOC( Cec_ManCsw_t, 1 ); - memset( p, 0, sizeof(Cec_ManCsw_t) ); - p->pAig = pAig; - p->pPars = pPars; - p->pObjs = ABC_CALLOC( Cec_ObjCsw_t, Gia_ManObjNum(pAig) ); - // temporaries - p->vClassOld = Vec_IntAlloc( 1000 ); - p->vClassNew = Vec_IntAlloc( 1000 ); - p->vClassTemp = Vec_IntAlloc( 1000 ); - p->vRefinedC = Vec_IntAlloc( 10000 ); - p->vXorNodes = Vec_IntAlloc( 1000 ); +Cec_ManSat_t * Cec_ManSatCreate( Gia_Man_t * pAig, Cec_ParSat_t * pPars ) +{ + Cec_ManSat_t * p; + // create interpolation manager + p = ABC_ALLOC( Cec_ManSat_t, 1 ); + memset( p, 0, sizeof(Cec_ManSat_t) ); + p->pPars = pPars; + p->pAig = pAig; + // SAT solving + p->nSatVars = 1; + p->pSatVars = ABC_CALLOC( int, Gia_ManObjNum(pAig) ); + p->vUsedNodes = Vec_PtrAlloc( 1000 ); + p->vFanins = Vec_PtrAlloc( 100 ); return p; } /**Function************************************************************* - Synopsis [Deletes AIG.] + Synopsis [Prints statistics of the manager.] Description [] @@ -67,19 +66,46 @@ Cec_ManCsw_t * Cec_ManCswStart( Gia_Man_t * pAig, Cec_ParCsw_t * pPars ) SeeAlso [] ***********************************************************************/ -void Cec_ManCswStop( Cec_ManCsw_t * p ) +void Cec_ManSatPrintStats( Cec_ManSat_t * p ) { - Vec_IntFree( p->vXorNodes ); - Vec_IntFree( p->vClassOld ); - Vec_IntFree( p->vClassNew ); - Vec_IntFree( p->vClassTemp ); - Vec_IntFree( p->vRefinedC ); - ABC_FREE( p->pMems ); - ABC_FREE( p->pObjs ); + printf( "CO = %6d ", Gia_ManCoNum(p->pAig) ); + printf( "Conf = %5d ", p->pPars->nBTLimit ); + printf( "MinVar = %5d ", p->pPars->nSatVarMax ); + printf( "MinCalls = %5d\n", p->pPars->nCallsRecycle ); + printf( "Unsat calls %6d (%6.2f %%) Ave conf = %8.1f ", + p->nSatUnsat, 100.0*p->nSatUnsat/p->nSatTotal, p->nSatUnsat? 1.0*p->nConfUnsat/p->nSatUnsat :0.0 ); + ABC_PRTP( "Time", p->timeSatUnsat, p->timeTotal ); + printf( "Sat calls %6d (%6.2f %%) Ave conf = %8.1f ", + p->nSatSat, 100.0*p->nSatSat/p->nSatTotal, p->nSatSat? 1.0*p->nConfSat/p->nSatSat : 0.0 ); + ABC_PRTP( "Time", p->timeSatSat, p->timeTotal ); + printf( "Undef calls %6d (%6.2f %%) Ave conf = %8.1f ", + p->nSatUndec, 100.0*p->nSatUndec/p->nSatTotal, p->nSatUndec? 1.0*p->nConfUndec/p->nSatUndec : 0.0 ); + ABC_PRTP( "Time", p->timeSatUndec, p->timeTotal ); +} + +/**Function************************************************************* + + Synopsis [Frees the manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManSatStop( Cec_ManSat_t * p ) +{ + if ( p->pSat ) + sat_solver_delete( p->pSat ); + Vec_PtrFree( p->vUsedNodes ); + Vec_PtrFree( p->vFanins ); + ABC_FREE( p->pSatVars ); ABC_FREE( p ); } + /**Function************************************************************* Synopsis [Creates AIG.] @@ -147,9 +173,11 @@ void Cec_ManPatStop( Cec_ManPat_t * p ) ABC_FREE( p ); } + + /**Function************************************************************* - Synopsis [Creates the manager.] + Synopsis [Creates AIG.] Description [] @@ -158,25 +186,31 @@ void Cec_ManPatStop( Cec_ManPat_t * p ) SeeAlso [] ***********************************************************************/ -Cec_ManSat_t * Cec_ManSatCreate( Gia_Man_t * pAig, Cec_ParSat_t * pPars ) -{ - Cec_ManSat_t * p; - // create interpolation manager - p = ABC_ALLOC( Cec_ManSat_t, 1 ); - memset( p, 0, sizeof(Cec_ManSat_t) ); - p->pPars = pPars; - p->pAig = pAig; - // SAT solving - p->nSatVars = 1; - p->pSatVars = ABC_CALLOC( int, Gia_ManObjNum(pAig) ); - p->vUsedNodes = Vec_PtrAlloc( 1000 ); - p->vFanins = Vec_PtrAlloc( 100 ); +Cec_ManSim_t * Cec_ManSimStart( Gia_Man_t * pAig, Cec_ParSim_t * pPars ) +{ + Cec_ManSim_t * p; + p = ABC_ALLOC( Cec_ManSim_t, 1 ); + memset( p, 0, sizeof(Cec_ManSim_t) ); + p->pAig = pAig; + p->pPars = pPars; + p->pSimInfo = ABC_CALLOC( int, Gia_ManObjNum(pAig) ); + p->vClassOld = Vec_IntAlloc( 1000 ); + p->vClassNew = Vec_IntAlloc( 1000 ); + p->vClassTemp = Vec_IntAlloc( 1000 ); + p->vRefinedC = Vec_IntAlloc( 10000 ); + p->vCiSimInfo = Vec_PtrAllocSimInfo( Gia_ManCiNum(p->pAig), pPars->nWords ); + if ( pPars->fCheckMiter || Gia_ManRegNum(p->pAig) ) + { + p->vCoSimInfo = Vec_PtrAllocSimInfo( Gia_ManCoNum(p->pAig), pPars->nWords ); + Vec_PtrCleanSimInfo( p->vCoSimInfo, 0, pPars->nWords ); + } + p->iOut = -1; return p; } /**Function************************************************************* - Synopsis [Prints statistics of the manager.] + Synopsis [Deletes AIG.] Description [] @@ -185,26 +219,27 @@ Cec_ManSat_t * Cec_ManSatCreate( Gia_Man_t * pAig, Cec_ParSat_t * pPars ) SeeAlso [] ***********************************************************************/ -void Cec_ManSatPrintStats( Cec_ManSat_t * p ) +void Cec_ManSimStop( Cec_ManSim_t * p ) { - printf( "CO = %6d ", Gia_ManCoNum(p->pAig) ); - printf( "Conf = %5d ", p->pPars->nBTLimit ); - printf( "MinVar = %5d ", p->pPars->nSatVarMax ); - printf( "MinCalls = %5d\n", p->pPars->nCallsRecycle ); - printf( "Unsat calls %6d (%6.2f %%) Ave conf = %8.1f ", - p->nSatUnsat, 100.0*p->nSatUnsat/p->nSatTotal, p->nSatUnsat? 1.0*p->nConfUnsat/p->nSatUnsat :0.0 ); - ABC_PRTP( "Time", p->timeSatUnsat, p->timeTotal ); - printf( "Sat calls %6d (%6.2f %%) Ave conf = %8.1f ", - p->nSatSat, 100.0*p->nSatSat/p->nSatTotal, p->nSatSat? 1.0*p->nConfSat/p->nSatSat : 0.0 ); - ABC_PRTP( "Time", p->timeSatSat, p->timeTotal ); - printf( "Undef calls %6d (%6.2f %%) Ave conf = %8.1f ", - p->nSatUndec, 100.0*p->nSatUndec/p->nSatTotal, p->nSatUndec? 1.0*p->nConfUndec/p->nSatUndec : 0.0 ); - ABC_PRTP( "Time", p->timeSatUndec, p->timeTotal ); + Vec_IntFree( p->vClassOld ); + Vec_IntFree( p->vClassNew ); + Vec_IntFree( p->vClassTemp ); + Vec_IntFree( p->vRefinedC ); + if ( p->vCiSimInfo ) + Vec_PtrFree( p->vCiSimInfo ); + if ( p->vCoSimInfo ) + Vec_PtrFree( p->vCoSimInfo ); + ABC_FREE( p->pCexComb ); + ABC_FREE( p->pCexes ); + ABC_FREE( p->pMems ); + ABC_FREE( p->pSimInfo ); + ABC_FREE( p ); } + /**Function************************************************************* - Synopsis [Frees the manager.] + Synopsis [Creates AIG.] Description [] @@ -213,16 +248,35 @@ void Cec_ManSatPrintStats( Cec_ManSat_t * p ) SeeAlso [] ***********************************************************************/ -void Cec_ManSatStop( Cec_ManSat_t * p ) +Cec_ManFra_t * Cec_ManFraStart( Gia_Man_t * pAig, Cec_ParFra_t * pPars ) +{ + Cec_ManFra_t * p; + p = ABC_ALLOC( Cec_ManFra_t, 1 ); + memset( p, 0, sizeof(Cec_ManFra_t) ); + p->pAig = pAig; + p->pPars = pPars; + p->vXorNodes = Vec_IntAlloc( 1000 ); + return p; +} + +/**Function************************************************************* + + Synopsis [Deletes AIG.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManFraStop( Cec_ManFra_t * p ) { - if ( p->pSat ) - sat_solver_delete( p->pSat ); - Vec_PtrFree( p->vUsedNodes ); - Vec_PtrFree( p->vFanins ); - ABC_FREE( p->pSatVars ); + Vec_IntFree( p->vXorNodes ); ABC_FREE( p ); } + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/cec/cecPat.c b/src/aig/cec/cecPat.c index 1af4f333..b80f1e44 100644 --- a/src/aig/cec/cecPat.c +++ b/src/aig/cec/cecPat.c @@ -1,12 +1,12 @@ /**CFile**************************************************************** - FileName [cec.c] + FileName [cecPat.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Combinatinoal equivalence checking.] - Synopsis [] + Synopsis [Simulation pattern manager.] Author [Alan Mishchenko] @@ -14,7 +14,7 @@ Date [Ver. 1.0. Started - June 20, 2005.] - Revision [$Id: cec.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + Revision [$Id: cecPat.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] ***********************************************************************/ diff --git a/src/aig/cec/cecSim.c b/src/aig/cec/cecSim.c new file mode 100644 index 00000000..dbd3bd5e --- /dev/null +++ b/src/aig/cec/cecSim.c @@ -0,0 +1,48 @@ +/**CFile**************************************************************** + + FileName [cecSim.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Combinatinoal equivalence checking.] + + Synopsis [Simulation manager.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: cecSim.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "cecInt.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ + + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/cec/cecSolve.c b/src/aig/cec/cecSolve.c index e4daf719..ba4b0477 100644 --- a/src/aig/cec/cecSolve.c +++ b/src/aig/cec/cecSolve.c @@ -390,6 +390,70 @@ void Cec_ManSatSolverRecycle( Cec_ManSat_t * p ) /**Function************************************************************* + Synopsis [Sets variable activities in the cone.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_SetActivityFactors_rec( Cec_ManSat_t * p, Gia_Obj_t * pObj, int LevelMin, int LevelMax ) +{ + float dActConeBumpMax = 20.0; + int iVar; + // skip visited variables + if ( Gia_ObjIsTravIdCurrent(p->pAig, pObj) ) + return; + Gia_ObjSetTravIdCurrent(p->pAig, pObj); + // add the PI to the list + if ( Gia_ObjLevel(p->pAig, pObj) <= LevelMin || Gia_ObjIsCi(pObj) ) + return; + // set the factor of this variable + // (LevelMax-LevelMin) / (pObj->Level-LevelMin) = p->pPars->dActConeBumpMax / ThisBump + if ( (iVar = Cec_ObjSatNum(p,pObj)) ) + { + p->pSat->factors[iVar] = dActConeBumpMax * (Gia_ObjLevel(p->pAig, pObj) - LevelMin)/(LevelMax - LevelMin); + veci_push(&p->pSat->act_vars, iVar); + } + // explore the fanins + Cec_SetActivityFactors_rec( p, Gia_ObjFanin0(pObj), LevelMin, LevelMax ); + Cec_SetActivityFactors_rec( p, Gia_ObjFanin1(pObj), LevelMin, LevelMax ); +} + +/**Function************************************************************* + + Synopsis [Sets variable activities in the cone.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_SetActivityFactors( Cec_ManSat_t * p, Gia_Obj_t * pObj ) +{ + float dActConeRatio = 0.5; + int LevelMin, LevelMax; + // reset the active variables + veci_resize(&p->pSat->act_vars, 0); + // prepare for traversal + Gia_ManIncrementTravId( p->pAig ); + // determine the min and max level to visit + assert( dActConeRatio > 0 && dActConeRatio < 1 ); + LevelMax = Gia_ObjLevel(p->pAig,pObj); + LevelMin = (int)(LevelMax * (1.0 - dActConeRatio)); + // traverse + Cec_SetActivityFactors_rec( p, pObj, LevelMin, LevelMax ); +//Cec_PrintActivity( p ); + return 1; +} + + +/**Function************************************************************* + Synopsis [Runs equivalence test for the two nodes.] Description [] @@ -402,7 +466,7 @@ void Cec_ManSatSolverRecycle( Cec_ManSat_t * p ) int Cec_ManSatCheckNode( Cec_ManSat_t * p, Gia_Obj_t * pObj ) { int nBTLimit = p->pPars->nBTLimit; - int Lit, RetValue, status, clk, nConflicts; + int Lit, RetValue, status, clk, clk2, nConflicts; p->nCallsSince++; // experiment with this!!! p->nSatTotal++; @@ -415,7 +479,14 @@ int Cec_ManSatCheckNode( Cec_ManSat_t * p, Gia_Obj_t * pObj ) Cec_ManSatSolverRecycle( p ); // if the nodes do not have SAT variables, allocate them +clk2 = clock(); Cec_CnfNodeAddToSolver( p, Gia_ObjFanin0(pObj) ); +//ABC_PRT( "cnf", clock() - clk2 ); +//printf( "%d \n", p->pSat->size ); + +clk2 = clock(); +// Cec_SetActivityFactors( p, Gia_ObjFanin0(pObj) ); +//ABC_PRT( "act", clock() - clk2 ); // propage unit clauses if ( p->pSat->qtail != p->pSat->qhead ) @@ -435,8 +506,12 @@ int Cec_ManSatCheckNode( Cec_ManSat_t * p, Gia_Obj_t * pObj ) //Sat_SolverWriteDimacs( p->pSat, "temp.cnf", pLits, pLits + 2, 1 ); clk = clock(); nConflicts = p->pSat->stats.conflicts; + +clk2 = clock(); RetValue = sat_solver_solve( p->pSat, &Lit, &Lit + 1, (ABC_INT64_T)nBTLimit, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 ); +//ABC_PRT( "sat", clock() - clk2 ); + if ( RetValue == l_False ) { p->timeSatUnsat += clock() - clk; @@ -466,6 +541,7 @@ p->timeSatUndec += clock() - clk; } } + /**Function************************************************************* Synopsis [Performs one round of solving for the POs of the AIG.] @@ -486,7 +562,7 @@ void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPar Bar_Progress_t * pProgress = NULL; Cec_ManSat_t * p; Gia_Obj_t * pObj; - int i, status, clk = clock(); + int i, status, clk = clock(), clk2; // sprintf( Buffer, "gia%03d.aig", Counter++ ); //Gia_WriteAiger( pAig, Buffer, 0, 0 ); @@ -499,8 +575,9 @@ void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPar pPat->nPats = 0; pPat->nPatLits = 0; pPat->nPatLitsMin = 0; - } + } Gia_ManSetPhase( pAig ); + Gia_ManLevelNum( pAig ); Gia_ManResetTravId( pAig ); p = Cec_ManSatCreate( pAig, pPars ); pProgress = Bar_ProgressStart( stdout, Gia_ManPoNum(pAig) ); @@ -512,13 +589,19 @@ void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPar pObj->fMark1 = 1; continue; } -//printf( "Output %6d : ", i ); - Bar_ProgressUpdate( pProgress, i, "SAT..." ); +clk2 = clock(); status = Cec_ManSatCheckNode( p, pObj ); pObj->fMark0 = (status == 0); pObj->fMark1 = (status == 1); /* +printf( "Output %6d : ", i ); +printf( "conf = %6d ", p->pSat->stats.conflicts ); +printf( "prop = %6d ", p->pSat->stats.propagations ); +ABC_PRT( "time", clock() - clk2 ); +*/ + +/* if ( status == -1 ) { Gia_Man_t * pTemp = Gia_ManDupDfsCone( pAig, pObj ); @@ -531,7 +614,11 @@ void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPar continue; // save the pattern if ( pPat ) + { + int clk3 = clock(); Cec_ManPatSavePattern( pPat, p, pObj ); + pPat->timeTotalSave += clock() - clk3; + } // quit if one of them is solved if ( pPars->fFirstStop ) break; diff --git a/src/aig/cec/cecSweep.c b/src/aig/cec/cecSweep.c new file mode 100644 index 00000000..20a668bd --- /dev/null +++ b/src/aig/cec/cecSweep.c @@ -0,0 +1,294 @@ +/**CFile**************************************************************** + + FileName [ceFraeep.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Combinatinoal equivalence checking.] + + Synopsis [SAT sweeping manager.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: ceFraeep.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "cecInt.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Performs limited speculative reduction.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Cec_ManFraSpecReduction( Cec_ManFra_t * p ) +{ + Gia_Man_t * pNew, * pTemp; + Gia_Obj_t * pObj, * pRepr; + int iRes0, iRes1, iRepr, iNode, iMiter; + int i, fCompl, * piCopies, * pDepths; + Gia_ManSetPhase( p->pAig ); + Vec_IntClear( p->vXorNodes ); + if ( p->pPars->nLevelMax ) + Gia_ManLevelNum( p->pAig ); + pNew = Gia_ManStart( Gia_ManObjNum(p->pAig) ); + pNew->pName = Aig_UtilStrsav( p->pAig->pName ); + Gia_ManHashAlloc( pNew ); + piCopies = ABC_FALLOC( int, Gia_ManObjNum(p->pAig) ); + pDepths = ABC_CALLOC( int, Gia_ManObjNum(p->pAig) ); + piCopies[0] = 0; + Gia_ManForEachObj1( p->pAig, pObj, i ) + { + if ( Gia_ObjIsCi(pObj) ) + { + piCopies[i] = Gia_ManAppendCi( pNew ); + continue; + } + if ( Gia_ObjIsCo(pObj) ) + continue; + if ( piCopies[Gia_ObjFaninId0(pObj,i)] == -1 || + piCopies[Gia_ObjFaninId1(pObj,i)] == -1 ) + continue; + iRes0 = Gia_LitNotCond( piCopies[Gia_ObjFaninId0(pObj,i)], Gia_ObjFaninC0(pObj) ); + iRes1 = Gia_LitNotCond( piCopies[Gia_ObjFaninId1(pObj,i)], Gia_ObjFaninC1(pObj) ); + iNode = piCopies[i] = Gia_ManHashAnd( pNew, iRes0, iRes1 ); + pDepths[i] = AIG_MAX( pDepths[Gia_ObjFaninId0(pObj,i)], pDepths[Gia_ObjFaninId1(pObj,i)] ); + if ( Gia_ObjRepr(p->pAig, i) == GIA_VOID || Gia_ObjFailed(p->pAig, i) ) + continue; + assert( Gia_ObjRepr(p->pAig, i) < i ); + iRepr = piCopies[Gia_ObjRepr(p->pAig, i)]; + if ( iRepr == -1 ) + continue; + if ( Gia_LitRegular(iNode) == Gia_LitRegular(iRepr) ) + continue; + if ( p->pPars->nLevelMax && + (Gia_ObjLevel(p->pAig, pObj) > p->pPars->nLevelMax || + Gia_ObjLevel(p->pAig, pRepr) > p->pPars->nLevelMax) ) + continue; + if ( p->pPars->fDoubleOuts ) + { +// if ( i % 1000 == 0 && Gia_ObjRepr(p->pAig, i) ) +// Gia_ManEquivPrintOne( p->pAig, Gia_ObjRepr(p->pAig, i), 0 ); + if ( p->pPars->fColorDiff ) + { + if ( !Gia_ObjDiffColors( p->pAig, Gia_ObjRepr(p->pAig, i), i ) ) + continue; + } + else + { + if ( !Gia_ObjDiffColors2( p->pAig, Gia_ObjRepr(p->pAig, i), i ) ) + continue; + } + } + pRepr = Gia_ManObj( p->pAig, Gia_ObjRepr(p->pAig, i) ); + fCompl = Gia_ObjPhaseReal(pObj) ^ Gia_ObjPhaseReal(pRepr); + piCopies[i] = Gia_LitNotCond( iRepr, fCompl ); + if ( Gia_ObjProved(p->pAig, i) ) + continue; + // produce speculative miter + iMiter = Gia_ManHashXor( pNew, iNode, piCopies[i] ); + Gia_ManAppendCo( pNew, iMiter ); + Vec_IntPush( p->vXorNodes, Gia_ObjRepr(p->pAig, i) ); + Vec_IntPush( p->vXorNodes, i ); + // add to the depth of this node + pDepths[i] = 1 + AIG_MAX( pDepths[i], pDepths[Gia_ObjRepr(p->pAig, i)] ); + if ( p->pPars->nDepthMax && pDepths[i] >= p->pPars->nDepthMax ) + piCopies[i] = -1; + } + ABC_FREE( piCopies ); + ABC_FREE( pDepths ); + Gia_ManHashStop( pNew ); + Gia_ManSetRegNum( pNew, 0 ); + pNew = Gia_ManCleanup( pTemp = pNew ); + Gia_ManStop( pTemp ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManFraClassesUpdate_rec( Gia_Obj_t * pObj ) +{ + int Result; + if ( pObj->fMark0 ) + return 1; + if ( Gia_ObjIsCi(pObj) || Gia_ObjIsConst0(pObj) ) + return 0; + Result = (Cec_ManFraClassesUpdate_rec( Gia_ObjFanin0(pObj) ) | + Cec_ManFraClassesUpdate_rec( Gia_ObjFanin1(pObj) )); + return pObj->fMark0 = Result; +} + +/**Function************************************************************* + + Synopsis [Creates simulation info for this round.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Cec_ManFraCreateInfo( Cec_ManSim_t * p, Vec_Ptr_t * vCiInfo, Vec_Ptr_t * vInfo, int nSeries ) +{ + unsigned * pRes0, * pRes1; + int i, w; + for ( i = 0; i < Gia_ManCiNum(p->pAig); i++ ) + { + pRes0 = Vec_PtrEntry( vCiInfo, i ); + pRes1 = Vec_PtrEntry( vInfo, i ); + pRes1 += p->nWords * nSeries; + for ( w = 0; w < p->nWords; w++ ) + pRes0[w] = pRes1[w]; + } +} + +/**Function************************************************************* + + Synopsis [Updates equivalence classes using the patterns.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Cec_ManFraClassesUpdate( Cec_ManFra_t * p, Cec_ManSim_t * pSim, Cec_ManPat_t * pPat, Gia_Man_t * pNew ) +{ + Vec_Ptr_t * vInfo; + Gia_Obj_t * pObj, * pObjOld, * pReprOld; + int i, k, iRepr, iNode, clk; +clk = clock(); + vInfo = Cec_ManPatCollectPatterns( pPat, Gia_ManCiNum(p->pAig), pSim->nWords ); +p->timePat += clock() - clk; +clk = clock(); + if ( vInfo != NULL ) + { + Gia_ManSetRefs( p->pAig ); + for ( i = 0; i < pPat->nSeries; i++ ) + { + Cec_ManFraCreateInfo( pSim, pSim->vCiSimInfo, vInfo, i ); + if ( Cec_ManSimSimulateRound( pSim, pSim->vCiSimInfo, pSim->vCoSimInfo ) ) + { + Vec_PtrFree( vInfo ); + return 1; + } + } + Vec_PtrFree( vInfo ); + } +p->timeSim += clock() - clk; + assert( Vec_IntSize(p->vXorNodes) == 2*Gia_ManCoNum(pNew) ); + // mark the transitive fanout of failed nodes + if ( p->pPars->nDepthMax != 1 ) + { + Gia_ManCleanMark0( p->pAig ); + Gia_ManCleanMark1( p->pAig ); + Gia_ManForEachCo( pNew, pObj, k ) + { + iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); + iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); + if ( pObj->fMark0 == 0 && pObj->fMark1 == 1 ) // proved + continue; +// Gia_ManObj(p->pAig, iRepr)->fMark0 = 1; + Gia_ManObj(p->pAig, iNode)->fMark0 = 1; + } + // mark the nodes reachable through the failed nodes + Gia_ManForEachAnd( p->pAig, pObjOld, k ) + pObjOld->fMark0 |= (Gia_ObjFanin0(pObjOld)->fMark0 | Gia_ObjFanin1(pObjOld)->fMark0); + // unmark the disproved nodes + Gia_ManForEachCo( pNew, pObj, k ) + { + iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); + iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); + if ( pObj->fMark0 == 0 && pObj->fMark1 == 1 ) // proved + continue; + pObjOld = Gia_ManObj(p->pAig, iNode); + assert( pObjOld->fMark0 == 1 ); + if ( Gia_ObjFanin0(pObjOld)->fMark0 == 0 && Gia_ObjFanin1(pObjOld)->fMark0 == 0 ) + pObjOld->fMark1 = 1; + } + // clean marks + Gia_ManForEachAnd( p->pAig, pObjOld, k ) + if ( pObjOld->fMark1 ) + { + pObjOld->fMark0 = 0; + pObjOld->fMark1 = 0; + } + } + // set the results + p->nAllProved = p->nAllDisproved = p->nAllFailed = 0; + Gia_ManForEachCo( pNew, pObj, k ) + { + iRepr = Vec_IntEntry( p->vXorNodes, 2*k ); + iNode = Vec_IntEntry( p->vXorNodes, 2*k+1 ); + pReprOld = Gia_ManObj(p->pAig, iRepr); + pObjOld = Gia_ManObj(p->pAig, iNode); + if ( pObj->fMark1 ) + { // proved + assert( pObj->fMark0 == 0 ); + assert( !Gia_ObjProved(p->pAig, iNode) ); + if ( pReprOld->fMark0 == 0 && pObjOld->fMark0 == 0 ) +// if ( pObjOld->fMark0 == 0 ) + { + assert( iRepr == Gia_ObjRepr(p->pAig, iNode) ); + Gia_ObjSetProved( p->pAig, iNode ); + p->nAllProved++; + } + } + else if ( pObj->fMark0 ) + { // disproved + assert( pObj->fMark1 == 0 ); + if ( pReprOld->fMark0 == 0 && pObjOld->fMark0 == 0 ) +// if ( pObjOld->fMark0 == 0 ) + { + if ( iRepr == Gia_ObjRepr(p->pAig, iNode) ) + printf( "Cec_ManFraClassesUpdate(): Error! Node is not refined!\n" ); + p->nAllDisproved++; + } + } + else + { // failed + assert( pObj->fMark0 == 0 ); + assert( pObj->fMark1 == 0 ); + assert( !Gia_ObjFailed(p->pAig, iNode) ); + assert( !Gia_ObjProved(p->pAig, iNode) ); + Gia_ObjSetFailed( p->pAig, iNode ); + p->nAllFailed++; + } + } + return 0; +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/cec/module.make b/src/aig/cec/module.make index f8e2602a..4618c424 100644 --- a/src/aig/cec/module.make +++ b/src/aig/cec/module.make @@ -1,5 +1,9 @@ -SRC += src/aig/cec/cecClass.c \ +SRC += src/aig/cec/cecCec.c \ + src/aig/cec/cecClass.c \ src/aig/cec/cecCore.c \ + src/aig/cec/cecIso.c \ src/aig/cec/cecMan.c \ src/aig/cec/cecPat.c \ - src/aig/cec/cecSolve.c + src/aig/cec/cecSim.c \ + src/aig/cec/cecSolve.c \ + src/aig/cec/cecSweep.c diff --git a/src/aig/dar/darRefact.c b/src/aig/dar/darRefact.c index f0173a3c..f64564fa 100644 --- a/src/aig/dar/darRefact.c +++ b/src/aig/dar/darRefact.c @@ -113,7 +113,7 @@ Ref_Man_t * Dar_ManRefStart( Aig_Man_t * pAig, Dar_RefPar_t * pPars ) // other data p->vCuts = Vec_VecStart( pPars->nCutsMax ); p->vTruthElem = Vec_PtrAllocTruthTables( pPars->nLeafMax ); - p->vTruthStore = Vec_PtrAllocSimInfo( 256, Kit_TruthWordNum(pPars->nLeafMax) ); + p->vTruthStore = Vec_PtrAllocSimInfo( 1024, Kit_TruthWordNum(pPars->nLeafMax) ); p->vMemory = Vec_IntAlloc( 1 << 16 ); p->vCutNodes = Vec_PtrAlloc( 256 ); p->vLeavesBest = Vec_PtrAlloc( pPars->nLeafMax ); diff --git a/src/aig/gia/gia.h b/src/aig/gia/gia.h index b77dd76f..91507947 100644 --- a/src/aig/gia/gia.h +++ b/src/aig/gia/gia.h @@ -36,27 +36,50 @@ extern "C" { #endif #define GIA_NONE 0x1FFFFFFF +#define GIA_VOID 0x0FFFFFFF //////////////////////////////////////////////////////////////////////// /// BASIC TYPES /// //////////////////////////////////////////////////////////////////////// +typedef struct Gia_Rpr_t_ Gia_Rpr_t; +struct Gia_Rpr_t_ +{ + unsigned iRepr : 28; // representative node + unsigned fProved : 1; // marks the proved equivalence + unsigned fFailed : 1; // marks the failed equivalence + unsigned fColorA : 1; // marks cone of A + unsigned fColorB : 1; // marks cone of B +}; + typedef struct Gia_Obj_t_ Gia_Obj_t; struct Gia_Obj_t_ { - unsigned iDiff0 : 29; // the diff of the first fanin - unsigned fCompl0: 1; // the complemented attribute - unsigned fMark0 : 1; // first user-controlled mark - unsigned fTerm : 1; // terminal node (CI/CO) + unsigned iDiff0 : 29; // the diff of the first fanin + unsigned fCompl0: 1; // the complemented attribute + unsigned fMark0 : 1; // first user-controlled mark + unsigned fTerm : 1; // terminal node (CI/CO) - unsigned iDiff1 : 29; // the diff of the second fanin - unsigned fCompl1: 1; // the complemented attribute - unsigned fMark1 : 1; // second user-controlled mark - unsigned fPhase : 1; // value under 000 pattern + unsigned iDiff1 : 29; // the diff of the second fanin + unsigned fCompl1: 1; // the complemented attribute + unsigned fMark1 : 1; // second user-controlled mark + unsigned fPhase : 1; // value under 000 pattern unsigned Value; // application-specific value }; +// sequential counter-example +typedef struct Gia_Cex_t_ Gia_Cex_t; +struct Gia_Cex_t_ +{ + int iPo; // the zero-based number of PO, for which verification failed + int iFrame; // the zero-based number of the time-frame, for which verificaiton failed + int nRegs; // the number of registers in the miter + int nPis; // the number of primary inputs in the miter + int nBits; // the number of words of bit data used + unsigned pData[0]; // the cex bit data (the number of bits: nRegs + (iFrame+1) * nPis) +}; + typedef struct Gia_Man_t_ Gia_Man_t; struct Gia_Man_t_ { @@ -76,23 +99,42 @@ struct Gia_Man_t_ int nLevels; // the mamixum level int nTravIds; // the current traversal ID int nFront; // frontier size - int * pReprs; // representatives (for CIs and ANDs) + int * pReprsOld; // representatives (for CIs and ANDs) + Gia_Rpr_t * pReprs; // representatives (for CIs and ANDs) + int * pNexts; // next nodes in the equivalence classes + int * pIso; // pairs of structurally isomorphic nodes int nTerLoop; // the state where loop begins int nTerStates; // the total number of ternary states int * pFanData; // the database to store fanout information int nFansAlloc; // the size of fanout representation + int * pMapping; // mapping for each node + Gia_Cex_t * pCexComb; // combinational counter-example }; +typedef struct Emb_Par_t_ Emb_Par_t; +struct Emb_Par_t_ +{ + int nDims; // the number of dimension + int nSols; // the number of solutions (typically, 2) + int nIters; // the number of iterations of FORCE + int fRefine; // use refinement by FORCE + int fCluster; // use clustered representation + int fDump; // dump Gnuplot file + int fDumpLarge; // dump Gnuplot file for large benchmarks + int fShowImage; // shows image if Gnuplot is installed + int fVerbose; // verbose flag +}; + // frames parameters typedef struct Gia_ParFra_t_ Gia_ParFra_t; struct Gia_ParFra_t_ { - int nFrames; // the number of frames to unroll - int fInit; // initialize the timeframes - int fVerbose; // enables verbose output + int nFrames; // the number of frames to unroll + int fInit; // initialize the timeframes + int fVerbose; // enables verbose output }; @@ -180,17 +222,17 @@ static inline int Gia_ObjFaninId0p( Gia_Man_t * p, Gia_Obj_t * pObj ) { static inline int Gia_ObjFaninId1p( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjFaninId1( pObj, Gia_ObjId(p, pObj) ); } static inline int Gia_ObjFaninLit0( Gia_Obj_t * pObj, int ObjId ) { return Gia_Var2Lit( Gia_ObjFaninId0(pObj, ObjId), Gia_ObjFaninC0(pObj) ); } static inline int Gia_ObjFaninLit1( Gia_Obj_t * pObj, int ObjId ) { return Gia_Var2Lit( Gia_ObjFaninId1(pObj, ObjId), Gia_ObjFaninC1(pObj) ); } -static inline int Gia_ObjFaninLit0p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Gia_Var2Lit( Gia_ObjFaninId0p(p, pObj), Gia_ObjFaninC0(pObj) ); } -static inline int Gia_ObjFaninLit1p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Gia_Var2Lit( Gia_ObjFaninId1p(p, pObj), Gia_ObjFaninC1(pObj) ); } +static inline int Gia_ObjFaninLit0p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Gia_Var2Lit( Gia_ObjFaninId0p(p, pObj), Gia_ObjFaninC0(pObj) ); } +static inline int Gia_ObjFaninLit1p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Gia_Var2Lit( Gia_ObjFaninId1p(p, pObj), Gia_ObjFaninC1(pObj) ); } static inline void Gia_ObjFlipFaninC0( Gia_Obj_t * pObj ) { assert( Gia_ObjIsCo(pObj) ); pObj->fCompl0 ^= 1; } static inline int Gia_ObjWhatFanin( Gia_Obj_t * pObj, Gia_Obj_t * pFanin ) { return Gia_ObjFanin0(pObj) == pFanin ? 0 : (Gia_ObjFanin1(pObj) == pFanin ? 1 : -1); } -static inline int Gia_ObjFanin0Copy( Gia_Obj_t * pObj ) { return Gia_LitNotCond( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) ); } -static inline int Gia_ObjFanin1Copy( Gia_Obj_t * pObj ) { return Gia_LitNotCond( Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC1(pObj) ); } +static inline int Gia_ObjFanin0Copy( Gia_Obj_t * pObj ) { return Gia_LitNotCond( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) ); } +static inline int Gia_ObjFanin1Copy( Gia_Obj_t * pObj ) { return Gia_LitNotCond( Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC1(pObj) ); } static inline Gia_Obj_t * Gia_ObjFromLit( Gia_Man_t * p, int iLit ) { return Gia_NotCond( Gia_ManObj(p, Gia_Lit2Var(iLit)), Gia_LitIsCompl(iLit) ); } -static inline int Gia_ObjToLit( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_LitNotCond( Gia_ObjId(p, pObj), Gia_IsComplement(pObj) ); } -static inline int Gia_ObjPhaseRealLit( Gia_Man_t * p, int iLit ) { return Gia_ObjPhaseReal( Gia_ObjFromLit(p, iLit) ); } +static inline int Gia_ObjToLit( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_Var2Lit( Gia_ObjId(p, pObj), Gia_IsComplement(pObj) ); } +static inline int Gia_ObjPhaseRealLit( Gia_Man_t * p, int iLit ) { return Gia_ObjPhaseReal( Gia_ObjFromLit(p, iLit) ); } static inline int Gia_ObjValue( Gia_Obj_t * pObj ) { return pObj->Value; } static inline int Gia_ObjLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert(p->pLevels);return p->pLevels[Gia_ObjId(p, pObj)]; } @@ -204,12 +246,12 @@ static inline void Gia_ObjRefFanin0Dec(Gia_Man_t * p, Gia_Obj_t * pObj){ static inline void Gia_ObjRefFanin1Dec(Gia_Man_t * p, Gia_Obj_t * pObj){ assert( p->pRefs); Gia_ObjRefDec(p, Gia_ObjFanin1(pObj)); } static inline void Gia_ManResetTravId( Gia_Man_t * p ) { extern void Gia_ManCleanValue( Gia_Man_t * p ); Gia_ManCleanValue( p ); p->nTravIds = 1; } -static inline void Gia_ManIncrementTravId( Gia_Man_t * p ) { p->nTravIds++; } -static inline void Gia_ObjSetTravId( Gia_Obj_t * pObj, int TravId ) { pObj->Value = TravId; } -static inline void Gia_ObjSetTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { pObj->Value = p->nTravIds; } -static inline void Gia_ObjSetTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { pObj->Value = p->nTravIds - 1; } -static inline int Gia_ObjIsTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { return ((int)pObj->Value == p->nTravIds); } -static inline int Gia_ObjIsTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { return ((int)pObj->Value == p->nTravIds - 1); } +static inline void Gia_ManIncrementTravId( Gia_Man_t * p ) { p->nTravIds++; } +static inline void Gia_ObjSetTravId( Gia_Obj_t * pObj, int TravId ) { pObj->Value = TravId; } +static inline void Gia_ObjSetTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { pObj->Value = p->nTravIds; } +static inline void Gia_ObjSetTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { pObj->Value = p->nTravIds - 1; } +static inline int Gia_ObjIsTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { return ((int)pObj->Value == p->nTravIds); } +static inline int Gia_ObjIsTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { return ((int)pObj->Value == p->nTravIds - 1); } // AIG construction extern void Gia_ObjAddFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout ); @@ -293,6 +335,54 @@ static inline int Gia_XsimAndCond( int Value0, int fCompl0, int Value1, int fCom return GIA_ONE; } +static inline Gia_Obj_t * Gia_ObjReprObj( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr == GIA_VOID ? NULL : Gia_ManObj( p, p->pReprs[Id].iRepr ); } +static inline int Gia_ObjRepr( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr; } +static inline void Gia_ObjSetRepr( Gia_Man_t * p, int Id, int Num ) { p->pReprs[Id].iRepr = Num; } + +static inline int Gia_ObjProved( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fProved; } +static inline void Gia_ObjSetProved( Gia_Man_t * p, int Id ) { p->pReprs[Id].fProved = 1; } + +static inline int Gia_ObjFailed( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fFailed; } +static inline void Gia_ObjSetFailed( Gia_Man_t * p, int Id ) { p->pReprs[Id].fFailed = 1; } + +static inline int Gia_ObjColor( Gia_Man_t * p, int Id, int c ) { return c? p->pReprs[Id].fColorB : p->pReprs[Id].fColorA; } +static inline int Gia_ObjColors( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fColorB * 2 + p->pReprs[Id].fColorA; } +static inline void Gia_ObjSetColor( Gia_Man_t * p, int Id, int c ) { if (c) p->pReprs[Id].fColorB = 1; else p->pReprs[Id].fColorA = 1; } +static inline void Gia_ObjSetColors( Gia_Man_t * p, int Id ) { p->pReprs[Id].fColorB = p->pReprs[Id].fColorA = 1; } +static inline int Gia_ObjVisitColor( Gia_Man_t * p, int Id, int c ) { int x; if (c) { x = p->pReprs[Id].fColorB; p->pReprs[Id].fColorB = 1; } else { x = p->pReprs[Id].fColorA; p->pReprs[Id].fColorA = 1; } return x; } +static inline int Gia_ObjDiffColors( Gia_Man_t * p, int i, int j ) { return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) && (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); } +static inline int Gia_ObjDiffColors2( Gia_Man_t * p, int i, int j ) { return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) || (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); } + +static inline int Gia_ObjNext( Gia_Man_t * p, int Id ) { return p->pNexts[Id]; } +static inline void Gia_ObjSetNext( Gia_Man_t * p, int Id, int Num ) { p->pNexts[Id] = Num; } + +static inline int Gia_ObjIsConst( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == 0; } +static inline int Gia_ObjIsHead( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) > 0; } +static inline int Gia_ObjIsNone( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) == 0; } +static inline int Gia_ObjIsTail( Gia_Man_t * p, int Id ) { return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) && Gia_ObjNext(p, Id) == 0; } +static inline int Gia_ObjIsClass( Gia_Man_t * p, int Id ) { return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) || Gia_ObjNext(p, Id) > 0; } + +#define Gia_ManForEachConst( p, i ) \ + for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsConst(p, i) ) {} else +#define Gia_ManForEachClass( p, i ) \ + for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else +#define Gia_ManForEachClassReverse( p, i ) \ + for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsHead(p, i) ) {} else +#define Gia_ClassForEachObj( p, i, iObj ) \ + for ( assert(Gia_ObjIsHead(p, i)), iObj = i; iObj; iObj = Gia_ObjNext(p, iObj) ) +#define Gia_ClassForEachObj1( p, i, iObj ) \ + for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj; iObj = Gia_ObjNext(p, iObj) ) + + +static inline int Gia_ObjIsGate( Gia_Man_t * p, int Id ) { return p->pMapping[Id] != 0; } +static inline int Gia_ObjGateSize( Gia_Man_t * p, int Id ) { return p->pMapping[p->pMapping[Id]]; } +static inline int * Gia_ObjGateFanins( Gia_Man_t * p, int Id ) { return p->pMapping + p->pMapping[Id] + 1; } + +#define Gia_ManForEachGate( p, i ) \ + for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsGate(p, i) ) {} else +#define Gia_GateForEachFanin( p, i, iFan, k ) \ + for ( k = 0; k < Gia_ObjGateSize(p,i) && ((iFan = Gia_ObjGateFanins(p,i)[k]),1); k++ ) + //////////////////////////////////////////////////////////////////////// /// MACRO DEFINITIONS /// //////////////////////////////////////////////////////////////////////// @@ -351,18 +441,30 @@ extern Gia_Man_t * Gia_ManDupDfsSkip( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManDupDfsCone( Gia_Man_t * p, Gia_Obj_t * pObj ); extern Gia_Man_t * Gia_ManDupDfsLitArray( Gia_Man_t * p, Vec_Int_t * vLits ); extern Gia_Man_t * Gia_ManDupNormalized( Gia_Man_t * p ); -extern Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p ); -extern Gia_Man_t * Gia_ManDupCofactored( Gia_Man_t * p, int iVar ); +extern Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p, int fTrimCis, int fTrimCos ); +extern Gia_Man_t * Gia_ManDupCofactored( Gia_Man_t * p, int iVar, int nLimFan ); extern Gia_Man_t * Gia_ManDupDfsCiMap( Gia_Man_t * p, int * pCi2Lit, Vec_Int_t * vLits ); extern Gia_Man_t * Gia_ManDupDfsClasses( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManDupTopAnd( Gia_Man_t * p, int fVerbose ); +extern Gia_Man_t * Gia_ManMiter( Gia_Man_t * pAig0, Gia_Man_t * pAig1, int fXorOuts, int fComb, int fVerbose ); +extern Gia_Man_t * Gia_ManTransformMiter( Gia_Man_t * p ); +/*=== giaEnable.c ==========================================================*/ +extern void Gia_ManDetectSeqSignals( Gia_Man_t * p, int fSetReset ); +/*=== giaEquiv.c ==========================================================*/ +extern int * Gia_ManDeriveNexts( Gia_Man_t * p ); +extern void Gia_ManEquivPrintOne( Gia_Man_t * p, int i, int Counter ); +extern void Gia_ManEquivPrintClasses( Gia_Man_t * p, int fVerbose, float Mem ); +extern Gia_Man_t * Gia_ManEquivReduceAndRemap( Gia_Man_t * p, int fSeq, int fMiterPairs ); +extern int Gia_ManEquivSetColors( Gia_Man_t * p, int fVerbose ); +extern Gia_Man_t * Gia_ManSpecReduce( Gia_Man_t * p ); +extern void Gia_ManEquivTransform( Gia_Man_t * p, int fVerbose ); /*=== giaFanout.c =========================================================*/ extern void Gia_ObjAddFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout ); extern void Gia_ObjRemoveFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout ); extern void Gia_ManFanoutStart( Gia_Man_t * p ); extern void Gia_ManFanoutStop( Gia_Man_t * p ); /*=== giaForce.c =========================================================*/ -extern void For_ManExperiment( Gia_Man_t * pGia ); +extern void For_ManExperiment( Gia_Man_t * pGia, int nIters, int fClustered, int fVerbose ); /*=== giaFrames.c =========================================================*/ extern void Gia_ManFraSetDefaultParams( Gia_ParFra_t * p ); extern Gia_Man_t * Gia_ManFrames( Gia_Man_t * pAig, Gia_ParFra_t * pPars ); @@ -380,7 +482,7 @@ extern int Gia_ManHashAndTry( Gia_Man_t * p, int iLit0, int iLit extern Gia_Man_t * Gia_ManRehash( Gia_Man_t * p ); /*=== giaLogic.c ===========================================================*/ extern void Gia_ManTestDistance( Gia_Man_t * p ); -extern void Gia_ManSolveProblem( Gia_Man_t * pGia, int nDims, int nSols, int fCluster, int fDump, int fVerbose ); +extern void Gia_ManSolveProblem( Gia_Man_t * pGia, Emb_Par_t * pPars ); /*=== giaMan.c ===========================================================*/ extern Gia_Man_t * Gia_ManStart( int nObjsMax ); extern void Gia_ManStop( Gia_Man_t * p ); @@ -388,13 +490,18 @@ extern void Gia_ManPrintStats( Gia_Man_t * p ); extern void Gia_ManPrintStatsShort( Gia_Man_t * p ); extern void Gia_ManPrintMiterStatus( Gia_Man_t * p ); extern void Gia_ManSetRegNum( Gia_Man_t * p, int nRegs ); +/*=== giaMap.c ===========================================================*/ +extern void Gia_ManPrintMappingStats( Gia_Man_t * p ); /*=== giaSat.c ============================================================*/ extern int Sat_ManTest( Gia_Man_t * pGia, Gia_Obj_t * pObj, int nConfsMax ); /*=== giaScl.c ============================================================*/ +extern int Gia_ManSeqMarkUsed( Gia_Man_t * p ); extern int Gia_ManCombMarkUsed( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManSeqCleanup( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManSeqStructSweep( Gia_Man_t * p, int fConst, int fEquiv, int fVerbose ); +/*=== giaSort.c ============================================================*/ +extern int * Gia_SortFloats( float * pArray, int * pPerm, int nSize ); /*=== giaSim.c ============================================================*/ extern int Gia_ManSimSimulate( Gia_Man_t * pAig, Gia_ParSim_t * pPars ); /*=== giaTsim.c ============================================================*/ @@ -411,6 +518,7 @@ extern void Gia_ManFillValue( Gia_Man_t * p ); extern void Gia_ManSetPhase( Gia_Man_t * p ); extern int Gia_ManLevelNum( Gia_Man_t * p ); extern void Gia_ManSetRefs( Gia_Man_t * p ); +extern int * Gia_ManCreateMuxRefs( Gia_Man_t * p ); extern void Gia_ManCreateRefs( Gia_Man_t * p ); extern int Gia_ManCrossCut( Gia_Man_t * p ); extern int Gia_ManIsNormalized( Gia_Man_t * p ); @@ -418,6 +526,7 @@ extern Vec_Int_t * Gia_ManCollectPoIds( Gia_Man_t * p ); extern int Gia_ObjIsMuxType( Gia_Obj_t * pNode ); extern int Gia_ObjRecognizeExor( Gia_Obj_t * pObj, Gia_Obj_t ** ppFan0, Gia_Obj_t ** ppFan1 ); extern Gia_Obj_t * Gia_ObjRecognizeMux( Gia_Obj_t * pNode, Gia_Obj_t ** ppNodeT, Gia_Obj_t ** ppNodeE ); +extern int Gia_ManVerifyCounterExample( Gia_Man_t * pAig, Gia_Cex_t * p, int fDoubleOuts ); #ifdef __cplusplus } diff --git a/src/aig/gia/giaAig.c b/src/aig/gia/giaAig.c index 8b59341a..544cfe0d 100644 --- a/src/aig/gia/giaAig.c +++ b/src/aig/gia/giaAig.c @@ -92,10 +92,9 @@ Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ) } // add logic for the POs Aig_ManForEachPo( p, pObj, i ) - { Gia_ManFromAig_rec( pNew, Aig_ObjFanin0(pObj) ); + Aig_ManForEachPo( p, pObj, i ) Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) ); - } Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) ); return pNew; } @@ -133,10 +132,9 @@ Gia_Man_t * Gia_ManFromAigSwitch( Aig_Man_t * p ) } // add logic for the POs Aig_ManForEachPo( p, pObj, i ) - { Gia_ManFromAig_rec( pNew, Aig_ObjFanin0(pObj) ); + Aig_ManForEachPo( p, pObj, i ) Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) ); - } Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) ); return pNew; } diff --git a/src/aig/gia/giaAiger.c b/src/aig/gia/giaAiger.c index 40c5329d..cfd2dc73 100644 --- a/src/aig/gia/giaAiger.c +++ b/src/aig/gia/giaAiger.c @@ -175,6 +175,120 @@ char * Gia_TimeStamp() /**Function************************************************************* + Synopsis [Read integer from the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ReadInt( unsigned char * pPos ) +{ + int i, Value = 0; + for ( i = 0; i < 4; i++ ) + Value = (Value << 8) | *pPos++; + return Value; +} + +/**Function************************************************************* + + Synopsis [Read equivalence classes from the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Rpr_t * Gia_ReadEquivClasses( unsigned char ** ppPos, int nSize ) +{ + Gia_Rpr_t * pReprs; + unsigned char * pStop; + int i, Item, fProved, iRepr, iNode; + pStop = *ppPos; + pStop += Gia_ReadInt( *ppPos ); *ppPos += 4; + pReprs = ABC_CALLOC( Gia_Rpr_t, nSize ); + for ( i = 0; i < nSize; i++ ) + pReprs[i].iRepr = GIA_VOID; + iRepr = iNode = 0; + while ( *ppPos < pStop ) + { + Item = Gia_ReadAigerDecode( ppPos ); + if ( Item & 1 ) + { + iRepr += (Item >> 1); + iNode = iRepr; +//printf( "\nRepr = %d ", iRepr ); + continue; + } + Item >>= 1; + fProved = (Item & 1); + Item >>= 1; + iNode += Item; + pReprs[iNode].fProved = fProved; + pReprs[iNode].iRepr = iRepr; +//printf( "Node = %d ", iNode ); + } + return pReprs; +} + +/**Function************************************************************* + + Synopsis [Reads decoded value.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +unsigned Gia_ReadDiffValue( char ** ppPos, int iPrev ) +{ + int Item = Gia_ReadAigerDecode( ppPos ); + if ( Item & 1 ) + return iPrev + (Item >> 1); + return iPrev - (Item >> 1); +} + +/**Function************************************************************* + + Synopsis [Read equivalence classes from the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int * Gia_ReadMapping( unsigned char ** ppPos, int nSize ) +{ + int * pMapping; + unsigned char * pStop; + int k, j, nFanins, nAlloc, iNode = 0, iOffset = nSize; + pStop = *ppPos; + pStop += Gia_ReadInt( *ppPos ); *ppPos += 4; + nAlloc = nSize + pStop - *ppPos; + pMapping = ABC_CALLOC( int, nAlloc ); + while ( *ppPos < pStop ) + { + k = iOffset; + pMapping[k++] = nFanins = Gia_ReadAigerDecode( ppPos ); + for ( j = 0; j <= nFanins; j++ ) + pMapping[k++] = iNode = Gia_ReadDiffValue( ppPos, iNode ); + pMapping[iNode] = iOffset; + iOffset = k; + } + assert( iOffset <= nAlloc ); + return pMapping; +} + +/**Function************************************************************* + Synopsis [Reads the AIG in the binary AIGER format.] Description [] @@ -328,6 +442,38 @@ Gia_Man_t * Gia_ReadAiger( char * pFileName, int fCheck ) // create the latches Gia_ManSetRegNum( pNew, nLatches ); + // check if there are other types of information to read + pCur = pSymbols; + if ( pCur + 1 < pContents + nFileSize && *pCur == 'c' ) + { + pCur++; + if ( *pCur == 'e' ) + { + pCur++; + // read equivalence classes + pNew->pReprs = Gia_ReadEquivClasses( &pCur, Gia_ManObjNum(pNew) ); + pNew->pNexts = Gia_ManDeriveNexts( pNew ); + } + if ( *pCur == 'm' ) + { + pCur++; + // read mapping + pNew->pMapping = Gia_ReadMapping( &pCur, Gia_ManObjNum(pNew) ); + } + if ( *pCur == 'p' ) + { + pCur++; + // read placement + } + if ( *pCur == 'n' ) + { + pCur++; + // read model name + ABC_FREE( pNew->pName ); + pNew->pName = Aig_UtilStrsav( pCur ); + } + } + // skipping the comments ABC_FREE( pContents ); Vec_IntFree( vNodes ); @@ -443,6 +589,144 @@ Vec_Str_t * Gia_WriteEncodeLiterals( Vec_Int_t * vLits ) /**Function************************************************************* + Synopsis [Write integer into the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_WriteInt( unsigned char * pPos, int Value ) +{ + int i; + for ( i = 3; i >= 0; i-- ) + *pPos++ = (Value >> (8*i)) & 255; +} + +/**Function************************************************************* + + Synopsis [Read equivalence classes from the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +unsigned char * Gia_WriteEquivClasses( Gia_Man_t * p, int * pEquivSize ) +{ + unsigned char * pBuffer; + int iRepr, iNode, iPrevRepr, iPrevNode, iLit, nItems, iPos; + assert( p->pReprs && p->pNexts ); + // count the number of entries to be written + nItems = 0; + for ( iRepr = 1; iRepr < Gia_ManObjNum(p); iRepr++ ) + { + nItems += Gia_ObjIsConst( p, iRepr ); + if ( !Gia_ObjIsHead(p, iRepr) ) + continue; + Gia_ClassForEachObj( p, iRepr, iNode ) + nItems++; + } + pBuffer = ABC_ALLOC( char, sizeof(int) * (nItems + 1) ); + // write constant class + iPos = Gia_WriteAigerEncode( pBuffer, 4, Gia_Var2Lit(0, 1) ); +//printf( "\nRepr = %d ", 0 ); + iPrevNode = 0; + for ( iNode = 1; iNode < Gia_ManObjNum(p); iNode++ ) + if ( Gia_ObjIsConst(p, iNode) ) + { +//printf( "Node = %d ", iNode ); + iLit = Gia_Var2Lit( iNode - iPrevNode, Gia_ObjProved(p, iNode) ); + iPrevNode = iNode; + iPos = Gia_WriteAigerEncode( pBuffer, iPos, Gia_Var2Lit(iLit, 0) ); + } + // write non-constant classes + iPrevRepr = 0; + Gia_ManForEachClass( p, iRepr ) + { +//printf( "\nRepr = %d ", iRepr ); + iPos = Gia_WriteAigerEncode( pBuffer, iPos, Gia_Var2Lit(iRepr - iPrevRepr, 1) ); + iPrevRepr = iPrevNode = iRepr; + Gia_ClassForEachObj1( p, iRepr, iNode ) + { +//printf( "Node = %d ", iNode ); + iLit = Gia_Var2Lit( iNode - iPrevNode, Gia_ObjProved(p, iNode) ); + iPrevNode = iNode; + iPos = Gia_WriteAigerEncode( pBuffer, iPos, Gia_Var2Lit(iLit, 0) ); + } + } + Gia_WriteInt( pBuffer, iPos ); + *pEquivSize = iPos; + return pBuffer; +} + +/**Function************************************************************* + + Synopsis [Reads decoded value.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_WriteDiffValue( char * pPos, int iPos, int iPrev, int iThis ) +{ + if ( iPrev < iThis ) + return Gia_WriteAigerEncode( pPos, iPos, Gia_Var2Lit(iThis - iPrev, 1) ); + return Gia_WriteAigerEncode( pPos, iPos, Gia_Var2Lit(iPrev - iThis, 0) ); +} + +/**Function************************************************************* + + Synopsis [Read equivalence classes from the string.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +unsigned char * Gia_WriteMapping( Gia_Man_t * p, int * pMapSize ) +{ + unsigned char * pBuffer; + int i, k, iPrev, iFan, nItems, iPos = 4; + assert( p->pMapping ); + // count the number of entries to be written + nItems = 0; + Gia_ManForEachGate( p, i ) + nItems += 2 + Gia_ObjGateSize( p, i ); + pBuffer = ABC_ALLOC( char, sizeof(int) * (nItems + 1) ); + // write non-constant classes + iPrev = 0; + Gia_ManForEachGate( p, i ) + { +//printf( "\nSize = %d ", Gia_ObjGateSize(p, i) ); + iPos = Gia_WriteAigerEncode( pBuffer, iPos, Gia_ObjGateSize(p, i) ); + Gia_GateForEachFanin( p, i, iFan, k ) + { +//printf( "Fan = %d ", iFan ); + iPos = Gia_WriteDiffValue( pBuffer, iPos, iPrev, iFan ); + iPrev = iFan; + } + iPos = Gia_WriteDiffValue( pBuffer, iPos, iPrev, i ); + iPrev = i; +//printf( "Node = %d ", i ); + } +//printf( "\n" ); + Gia_WriteInt( pBuffer, iPos ); + *pMapSize = iPos; + return pBuffer; +} + +/**Function************************************************************* + Synopsis [Writes the AIG in the binary AIGER format.] Description [] @@ -536,10 +820,29 @@ void Gia_WriteAiger( Gia_Man_t * pInit, char * pFileName, int fWriteSymbols, int ABC_FREE( pBuffer ); // write the comment - fprintf( pFile, "c\n" ); + fprintf( pFile, "c" ); + // write equivalences + if ( p->pReprs && p->pNexts ) + { + int nEquivSize; + unsigned char * pEquivs = Gia_WriteEquivClasses( p, &nEquivSize ); + fprintf( pFile, "e" ); + fwrite( pEquivs, 1, nEquivSize, pFile ); + ABC_FREE( pEquivs ); + } + // write mapping + if ( p->pMapping ) + { + int nMapSize; + unsigned char * pMaps = Gia_WriteMapping( p, &nMapSize ); + fprintf( pFile, "m" ); + fwrite( pMaps, 1, nMapSize, pFile ); + ABC_FREE( pMaps ); + } + // write placement if ( p->pName ) - fprintf( pFile, ".model %s\n", p->pName ); - fprintf( pFile, "This file was produced by the AIG package on %s\n", Gia_TimeStamp() ); + fprintf( pFile, "n%s%c", p->pName, '\0' ); + fprintf( pFile, "\nThis file was produced by the GIA package in ABC on %s\n", Gia_TimeStamp() ); fprintf( pFile, "For information about AIGER format, refer to %s\n", "http://fmv.jku.at/aiger" ); fclose( pFile ); if ( p != pInit ) diff --git a/src/aig/gia/giaCof.c b/src/aig/gia/giaCof.c index d58429cd..735aca72 100644 --- a/src/aig/gia/giaCof.c +++ b/src/aig/gia/giaCof.c @@ -41,6 +41,7 @@ struct Cof_Obj_t_ unsigned fMark1 : 1; // second user-controlled mark unsigned nFanins : 4; // the number of fanins unsigned nFanouts : 24; // total number of fanouts + unsigned nFanoutsM; // total number of MUX ctrl fanouts unsigned Value; // application specific data int Id; // ID of the node int iNext; // next one in the linked list @@ -124,6 +125,7 @@ Cof_Man_t * Cof_ManCreateLogicSimple( Gia_Man_t * pGia ) Cof_Man_t * p; Cof_Obj_t * pObjLog, * pFanLog; Gia_Obj_t * pObj; + int * pMuxRefs; int i, iHandle = 0; p = ABC_CALLOC( Cof_Man_t, 1 ); p->pGia = pGia; @@ -173,11 +175,14 @@ Cof_Man_t * Cof_ManCreateLogicSimple( Gia_Man_t * pGia ) p->nObjs++; } assert( iHandle == p->nObjData ); + pMuxRefs = Gia_ManCreateMuxRefs( pGia ); Gia_ManForEachObj( pGia, pObj, i ) { pObjLog = Cof_ManObj( p, Gia_ObjHandle(pObj) ); assert( pObjLog->nFanouts == pObjLog->Value ); + pObjLog->nFanoutsM = pMuxRefs[i]; } + ABC_FREE( pMuxRefs ); return p; } @@ -509,8 +514,7 @@ int Cof_ManCountRemoved( Cof_Man_t * p, Cof_Obj_t * pRoot, int fConst1 ) void Cof_ManPrintHighFanoutOne( Cof_Man_t * p, Cof_Obj_t * pObj ) { printf( "%7d : ", pObj->Id ); - printf( "fi =%2d ", Cof_ObjFaninNum(pObj) ); - printf( "fo =%5d ", Cof_ObjFanoutNum(pObj) ); + printf( "i/o/c =%2d %5d %5d ", Cof_ObjFaninNum(pObj), Cof_ObjFanoutNum(pObj), 2*pObj->nFanoutsM ); printf( "l =%4d ", Cof_ObjLevel(p, pObj) ); printf( "s =%5d ", Cof_ManSuppSize(p, &pObj, 1) ); printf( "TFI =%7d ", Cof_ManTfiSize(p, &pObj, 1) ); diff --git a/src/aig/gia/giaDup.c b/src/aig/gia/giaDup.c index d5c0862f..4821dba9 100644 --- a/src/aig/gia/giaDup.c +++ b/src/aig/gia/giaDup.c @@ -196,11 +196,11 @@ int Gia_ManDupDfs_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj ) { if ( ~pObj->Value ) return pObj->Value; - if ( p->pReprs && ~p->pReprs[Gia_ObjId(p, pObj)] ) + if ( p->pReprsOld && ~p->pReprsOld[Gia_ObjId(p, pObj)] ) { - Gia_Obj_t * pRepr = Gia_ManObj( p, p->pReprs[Gia_ObjId(p, pObj)] ); - pObj->Value = Gia_ManDupDfs_rec( pNew, p, pRepr ); - return pObj->Value = Gia_LitNotCond( pObj->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); + Gia_Obj_t * pRepr = Gia_ManObj( p, p->pReprsOld[Gia_ObjId(p, pObj)] ); + pRepr->Value = Gia_ManDupDfs_rec( pNew, p, pRepr ); + return pObj->Value = Gia_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); } if ( Gia_ObjIsCi(pObj) ) return pObj->Value = Gia_ManAppendCi(pNew); @@ -380,7 +380,7 @@ Gia_Man_t * Gia_ManDupNormalized( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p ) +Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p, int fTrimCis, int fTrimCos ) { Gia_Man_t * pNew; Gia_Obj_t * pObj; @@ -391,12 +391,12 @@ Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p ) Gia_ManSetRefs( p ); Gia_ManConst0(p)->Value = 0; Gia_ManForEachCi( p, pObj, i ) - if ( pObj->Value > 0 || Gia_ObjIsRo(p, pObj) ) + if ( !fTrimCis || pObj->Value > 0 || Gia_ObjIsRo(p, pObj) ) pObj->Value = Gia_ManAppendCi(pNew); Gia_ManForEachAnd( p, pObj, i ) pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) ); Gia_ManForEachCo( p, pObj, i ) - if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) || Gia_ObjIsRi(p, pObj) ) + if ( !fTrimCos || !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) || Gia_ObjIsRi(p, pObj) ) pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) ); return pNew; @@ -413,11 +413,16 @@ Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Gia_ManDupCofactored( Gia_Man_t * p, int iVar ) +Gia_Man_t * Gia_ManDupCofactored( Gia_Man_t * p, int iVar, int nLimFan ) { Gia_Man_t * pNew, * pTemp; Gia_Obj_t * pObj, * pPivot; int i, iCofVar = -1; + if ( nLimFan > 0 ) + { + printf( "This feature is not implemented.\n" ); + return NULL; + } if ( !(iVar > 0 && iVar < Gia_ManObjNum(p)) ) { printf( "Gia_ManDupCofactored(): Variable %d is out of range (%d; %d).\n", iVar, 0, Gia_ManObjNum(p) ); @@ -502,7 +507,7 @@ void Gia_ManPrintRepr( Gia_Man_t * p ) Gia_Obj_t * pObj; int i; Gia_ManForEachObj( p, pObj, i ) - if ( ~p->pReprs[i] ) + if ( ~p->pReprsOld[i] ) printf( "%d->%d ", i, p->pReprs[i] ); printf( "\n" ); } @@ -569,7 +574,7 @@ Gia_Man_t * Gia_ManDupDfsClasses( Gia_Man_t * p ) Gia_Man_t * pNew, * pTemp; Gia_Obj_t * pObj; int i; - assert( p->pReprs != NULL ); + assert( p->pReprsOld != NULL ); Gia_ManFillValue( p ); pNew = Gia_ManStart( Gia_ManObjNum(p) ); pNew->pName = Aig_UtilStrsav( p->pName ); @@ -719,6 +724,195 @@ Gia_Man_t * Gia_ManDupTopAnd( Gia_Man_t * p, int fVerbose ) } +/**Function************************************************************* + + Synopsis [Duplicates the AIG in the DFS order.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManMiter_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + if ( ~pObj->Value ) + return pObj->Value; + assert( Gia_ObjIsAnd(pObj) ); + Gia_ManMiter_rec( pNew, p, Gia_ObjFanin0(pObj) ); + Gia_ManMiter_rec( pNew, p, Gia_ObjFanin1(pObj) ); + return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) ); +} + +/**Function************************************************************* + + Synopsis [Creates miter of two designs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManMiter( Gia_Man_t * p0, Gia_Man_t * p1, int fXorOuts, int fComb, int fVerbose ) +{ + Gia_Man_t * pNew, * pTemp; + Gia_Obj_t * pObj; + int i, iLit; + if ( fComb ) + { + if ( Gia_ManCiNum(p0) != Gia_ManCiNum(p1) ) + { + printf( "Gia_ManMiter(): Designs have different number of CIs.\n" ); + return NULL; + } + if ( Gia_ManCoNum(p0) != Gia_ManCoNum(p1) ) + { + printf( "Gia_ManMiter(): Designs have different number of COs.\n" ); + return NULL; + } + } + else + { + if ( Gia_ManPiNum(p0) != Gia_ManPiNum(p1) ) + { + printf( "Gia_ManMiter(): Designs have different number of PIs.\n" ); + return NULL; + } + if ( Gia_ManPoNum(p0) != Gia_ManPoNum(p1) ) + { + printf( "Gia_ManMiter(): Designs have different number of POs.\n" ); + return NULL; + } + if ( Gia_ManRegNum(p0) == 0 || Gia_ManRegNum(p1) == 0 ) + { + printf( "Gia_ManMiter(): At least one of the designs has no registers.\n" ); + return NULL; + } + } + // start the manager + pNew = Gia_ManStart( Gia_ManObjNum(p0) + Gia_ManObjNum(p1) ); + pNew->pName = Aig_UtilStrsav( "miter" ); + // map combinational inputs + Gia_ManFillValue( p0 ); + Gia_ManFillValue( p1 ); + Gia_ManConst0(p0)->Value = 0; + Gia_ManConst0(p1)->Value = 0; + // map internal nodes and outputs + Gia_ManHashAlloc( pNew ); + if ( fComb ) + { + // create combinational inputs + Gia_ManForEachCi( p0, pObj, i ) + pObj->Value = Gia_ManAppendCi( pNew ); + Gia_ManForEachCi( p1, pObj, i ) + pObj->Value = Gia_ObjToLit( pNew, Gia_ManCi(pNew, i) ); + // create combinational outputs + Gia_ManForEachCo( p0, pObj, i ) + { + Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) ); + Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManCo(p1,i)) ); + if ( fXorOuts ) + { + iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) ); + Gia_ManAppendCo( pNew, iLit ); + } + else + { + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) ); + } + } + } + else + { + // create primary inputs + Gia_ManForEachPi( p0, pObj, i ) + pObj->Value = Gia_ManAppendCi( pNew ); + Gia_ManForEachPi( p1, pObj, i ) + pObj->Value = Gia_ObjToLit( pNew, Gia_ManPi(pNew, i) ); + // create latch outputs + Gia_ManForEachRo( p0, pObj, i ) + pObj->Value = Gia_ManAppendCi( pNew ); + Gia_ManForEachRo( p1, pObj, i ) + pObj->Value = Gia_ManAppendCi( pNew ); + // create primary outputs + Gia_ManForEachPo( p0, pObj, i ) + { + Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) ); + Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManPo(p1,i)) ); + if ( fXorOuts ) + { + iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) ); + Gia_ManAppendCo( pNew, iLit ); + } + else + { + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) ); + } + } + // create register inputs + Gia_ManForEachRi( p0, pObj, i ) + { + Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) ); + pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + } + Gia_ManForEachRi( p1, pObj, i ) + { + Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(pObj) ); + pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + } + Gia_ManSetRegNum( pNew, Gia_ManRegNum(p0) + Gia_ManRegNum(p1) ); + } + Gia_ManHashStop( pNew ); + pNew = Gia_ManCleanup( pTemp = pNew ); + Gia_ManStop( pTemp ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [Transforms the circuit into a regular miter.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManTransformMiter( Gia_Man_t * p ) +{ + Gia_Man_t * pNew, * pTemp; + Gia_Obj_t * pObj, * pObj2; + int i, iLit; + assert( (Gia_ManPoNum(p) & 1) == 0 ); + pNew = Gia_ManStart( Gia_ManObjNum(p) ); + pNew->pName = Aig_UtilStrsav( p->pName ); + Gia_ManConst0(p)->Value = 0; + Gia_ManHashAlloc( pNew ); + Gia_ManForEachCi( p, pObj, i ) + pObj->Value = Gia_ManAppendCi( pNew ); + Gia_ManForEachAnd( p, pObj, i ) + pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) ); + Gia_ManForEachPo( p, pObj, i ) + { + pObj2 = Gia_ManPo( p, ++i ); + iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) ); + Gia_ManAppendCo( pNew, iLit ); + } + Gia_ManForEachRi( p, pObj, i ) + pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + Gia_ManHashStop( pNew ); + Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) ); + pNew = Gia_ManCleanup( pTemp = pNew ); + Gia_ManStop( pTemp ); + return pNew; +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/gia/giaEmbed.c b/src/aig/gia/giaEmbed.c index 0469d1a4..6c2f00df 100644 --- a/src/aig/gia/giaEmbed.c +++ b/src/aig/gia/giaEmbed.c @@ -25,12 +25,18 @@ The code is based on the paper by D. Harel and Y. Koren, "Graph drawing by high-dimensional embedding", J. Graph Algs & Apps, Vol 8(2), pp. 195-217 (2004). + http://www.emis.de/journals/JGAA/accepted/2004/HarelKoren2004.8.2.pdf + + Iterative refinement is described in the paper: F. A. Aloul, I. L. Markov, and K. A. Sakallah. + "FORCE: A Fast and Easy-To-Implement Variable-Ordering Heuristic", Proc. GLSVLSI’03. + http://www.eecs.umich.edu/~imarkov/pubs/conf/glsvlsi03-force.pdf */ //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// + typedef float Emb_Dat_t; typedef struct Emb_Obj_t_ Emb_Obj_t; @@ -90,10 +96,10 @@ static inline Emb_Obj_t * Emb_ManCo( Emb_Man_t * p, int i ) static inline int Emb_ObjIsTerm( Emb_Obj_t * pObj ) { return pObj->fCi || pObj->fCo; } static inline int Emb_ObjIsCi( Emb_Obj_t * pObj ) { return pObj->fCi; } static inline int Emb_ObjIsCo( Emb_Obj_t * pObj ) { return pObj->fCo; } -static inline int Emb_ObjIsPi( Emb_Obj_t * pObj ) { return pObj->fCi && pObj->nFanins == 0; } -static inline int Emb_ObjIsPo( Emb_Obj_t * pObj ) { return pObj->fCo && pObj->nFanouts == 0; } +//static inline int Emb_ObjIsPi( Emb_Obj_t * pObj ) { return pObj->fCi && pObj->nFanins == 0; } +//static inline int Emb_ObjIsPo( Emb_Obj_t * pObj ) { return pObj->fCo && pObj->nFanouts == 0; } static inline int Emb_ObjIsNode( Emb_Obj_t * pObj ) { return!Emb_ObjIsTerm(pObj) && pObj->nFanins > 0; } -static inline int Emb_ObjIsConst0( Emb_Obj_t * pObj ) { return!Emb_ObjIsTerm(pObj) && pObj->nFanins == 0; } +//static inline int Emb_ObjIsConst0( Emb_Obj_t * pObj ) { return!Emb_ObjIsTerm(pObj) && pObj->nFanins == 0; } static inline int Emb_ObjSize( Emb_Obj_t * pObj ) { return sizeof(Emb_Obj_t) / 4 + pObj->nFanins + pObj->nFanouts; } static inline int Emb_ObjFaninNum( Emb_Obj_t * pObj ) { return pObj->nFanins; } @@ -109,8 +115,8 @@ static inline void Emb_ObjSetTravIdPrevious( Emb_Man_t * p, Emb_Obj_t * p static inline int Emb_ObjIsTravIdCurrent( Emb_Man_t * p, Emb_Obj_t * pObj ) { return ((int)pObj->TravId == p->nTravIds); } static inline int Emb_ObjIsTravIdPrevious( Emb_Man_t * p, Emb_Obj_t * pObj ) { return ((int)pObj->TravId == p->nTravIds - 1); } -static inline Emb_Dat_t * Emb_ManVec( Emb_Man_t * p, int v ) { return p->pVecs + v * p->nObjs; } -static inline float * Emb_ManSol( Emb_Man_t * p, int v ) { return p->pSols + v * p->nObjs; } +static inline Emb_Dat_t * Emb_ManVec( Emb_Man_t * p, int v ) { return p->pVecs + v * p->nObjs; } +static inline float * Emb_ManSol( Emb_Man_t * p, int v ) { return p->pSols + v * p->nObjs; } #define Emb_ManForEachObj( p, pObj, i ) \ for ( i = 0; (i < p->nObjData) && (pObj = Emb_ManObj(p,i)); i += Emb_ObjSize(pObj) ) @@ -171,13 +177,13 @@ Emb_Man_t * Emb_ManStartSimple( Gia_Man_t * pGia ) p->nRegs = Gia_ManRegNum(pGia); p->vCis = Vec_IntAlloc( Gia_ManCiNum(pGia) ); p->vCos = Vec_IntAlloc( Gia_ManCoNum(pGia) ); - p->nObjData = (sizeof(Emb_Obj_t) / 4) * Gia_ManObjNum(pGia) + 2 * (2 * Gia_ManAndNum(pGia) + Gia_ManCoNum(pGia) + Gia_ManRegNum(pGia)); + p->nObjData = (sizeof(Emb_Obj_t) / 4) * Gia_ManObjNum(pGia) + 2 * (2 * Gia_ManAndNum(pGia) + Gia_ManCoNum(pGia) + Gia_ManRegNum(pGia) + Gia_ManCoNum(pGia)); p->pObjData = ABC_CALLOC( int, p->nObjData ); // create constant node Gia_ManConst0(pGia)->Value = hHandle; pObjLog = Emb_ManObj( p, hHandle ); pObjLog->hHandle = hHandle; - pObjLog->nFanins = 0; + pObjLog->nFanins = Gia_ManCoNum(pGia); //0; pObjLog->nFanouts = Gia_ObjRefs( pGia, Gia_ManConst0(pGia) ); // count objects hHandle += Emb_ObjSize( pObjLog ); @@ -227,7 +233,7 @@ Emb_Man_t * Emb_ManStartSimple( Gia_Man_t * pGia ) pObjLog = Emb_ManObj( p, hHandle ); pObjLog->hHandle = hHandle; pObjLog->nFanins = 1; - pObjLog->nFanouts = Gia_ObjIsRi( pGia, pObj ); + pObjLog->nFanouts = 1 + Gia_ObjIsRi( pGia, pObj ); pObjLog->fCo = 1; // add fanins pFanLog = Emb_ManObj( p, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); @@ -249,8 +255,8 @@ Emb_Man_t * Emb_ManStartSimple( Gia_Man_t * pGia ) if ( !~Gia_ObjValue(pObj) ) continue; pObjLog = Emb_ManObj( p, Gia_ObjValue(pObj) ); - assert( pObjLog->nFanins == pObjLog->iFanin ); - assert( pObjLog->nFanouts == pObjLog->iFanout ); + assert( pObjLog->nFanins == pObjLog->iFanin || Gia_ObjIsConst0(pObj) ); + assert( pObjLog->nFanouts == pObjLog->iFanout || Gia_ObjIsCo(pObj) ); pObjLog->iFanin = pObjLog->iFanout = 0; } ABC_FREE( pGia->pRefs ); @@ -496,13 +502,13 @@ Emb_Man_t * Emb_ManStart( Gia_Man_t * pGia ) p->nRegs = Gia_ManRegNum(pGia); p->vCis = Vec_IntAlloc( Gia_ManCiNum(pGia) ); p->vCos = Vec_IntAlloc( Gia_ManCoNum(pGia) ); - p->nObjData = (sizeof(Emb_Obj_t) / 4) * nObjs + 2 * (nFanios + Gia_ManRegNum(pGia)); + p->nObjData = (sizeof(Emb_Obj_t) / 4) * nObjs + 2 * (nFanios + Gia_ManRegNum(pGia) + Gia_ManCoNum(pGia)); p->pObjData = ABC_CALLOC( int, p->nObjData ); // create constant node Gia_ManConst0(pGia)->Value = hHandle; pObjLog = Emb_ManObj( p, hHandle ); pObjLog->hHandle = hHandle; - pObjLog->nFanins = 0; + pObjLog->nFanins = Gia_ManCoNum(pGia); //0; pObjLog->nFanouts = Gia_ObjRefs( pGia, Gia_ManConst0(pGia) ); // count objects hHandle += Emb_ObjSize( pObjLog ); @@ -563,7 +569,7 @@ Emb_Man_t * Emb_ManStart( Gia_Man_t * pGia ) pObjLog = Emb_ManObj( p, hHandle ); pObjLog->hHandle = hHandle; pObjLog->nFanins = 1; - pObjLog->nFanouts = Gia_ObjIsRi( pGia, pObj ); + pObjLog->nFanouts = 1 + Gia_ObjIsRi( pGia, pObj ); pObjLog->fCo = 1; // add fanins pFanLog = Emb_ManObj( p, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); @@ -587,8 +593,8 @@ Emb_Man_t * Emb_ManStart( Gia_Man_t * pGia ) if ( !~Gia_ObjValue(pObj) ) continue; pObjLog = Emb_ManObj( p, Gia_ObjValue(pObj) ); - assert( pObjLog->nFanins == pObjLog->iFanin ); - assert( pObjLog->nFanouts == pObjLog->iFanout ); + assert( pObjLog->nFanins == pObjLog->iFanin || Gia_ObjIsConst0(pObj) ); + assert( pObjLog->nFanouts == pObjLog->iFanout || Gia_ObjIsCo(pObj) ); pObjLog->iFanin = pObjLog->iFanout = 0; } ABC_FREE( pGia->pRefs ); @@ -904,7 +910,7 @@ ABC_PRT( "Time", clock() - clk ); /**Function************************************************************* - Synopsis [Computes the distances from the given set of objects.] + Synopsis [Perform BFS from the set of nodes.] Description [Returns one of the most distant objects.] @@ -913,20 +919,11 @@ ABC_PRT( "Time", clock() - clk ); SeeAlso [] ***********************************************************************/ -Emb_Obj_t * Emb_ManFindDistances( Emb_Man_t * p, Vec_Int_t * vStart, Emb_Dat_t * pDist ) +Emb_Obj_t * Emb_ManPerformBfs( Emb_Man_t * p, Vec_Int_t * vThis, Vec_Int_t * vNext, Emb_Dat_t * pDist ) { - Vec_Int_t * vThis, * vNext, * vTemp; + Vec_Int_t * vTemp; Emb_Obj_t * pThis, * pNext, * pResult; int i, k; - p->nReached = p->nDistMax = 0; - vThis = Vec_IntAlloc( 1000 ); - vNext = Vec_IntAlloc( 1000 ); - Emb_ManIncrementTravId( p ); - Emb_ManForEachObjVec( vStart, p, pThis, i ) - { - Emb_ObjSetTravIdCurrent( p, pThis ); - Vec_IntPush( vThis, pThis->hHandle ); - } assert( Vec_IntSize(vThis) > 0 ); for ( p->nDistMax = 0; Vec_IntSize(vThis) > 0; p->nDistMax++ ) { @@ -955,6 +952,74 @@ Emb_Obj_t * Emb_ManFindDistances( Emb_Man_t * p, Vec_Int_t * vStart, Emb_Dat_t * assert( Vec_IntSize(vNext) > 0 ); pResult = Emb_ManObj( p, Vec_IntEntry(vNext, 0) ); assert( pDist == NULL || pDist[pResult->Value] == p->nDistMax - 1 ); + return pResult; +} + +/**Function************************************************************* + + Synopsis [Computes the distances from the given set of objects.] + + Description [Returns one of the most distant objects.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Vec_Int_t * Emb_ManConnectedComponents( Emb_Man_t * p ) +{ + Gia_Obj_t * pObj; + Vec_Int_t * vThis, * vNext, * vResult; + Emb_Obj_t * pThis; + int i; + vResult = Vec_IntAlloc( 1000 ); + vThis = Vec_IntAlloc( 1000 ); + vNext = Vec_IntAlloc( 1000 ); + p->nReached = 0; + Emb_ManIncrementTravId( p ); + Gia_ManForEachCo( p->pGia, pObj, i ) + { + pThis = Emb_ManObj( p, Gia_ObjValue(pObj) ); + if ( Emb_ObjIsTravIdCurrent(p, pThis) ) + continue; + Emb_ObjSetTravIdCurrent( p, pThis ); + Vec_IntPush( vResult, pThis->hHandle ); + // perform BFS from this node + Vec_IntClear( vThis ); + Vec_IntPush( vThis, pThis->hHandle ); + Emb_ManPerformBfs( p, vThis, vNext, NULL ); + } + Vec_IntFree( vThis ); + Vec_IntFree( vNext ); + return vResult; +} + +/**Function************************************************************* + + Synopsis [Computes the distances from the given set of objects.] + + Description [Returns one of the most distant objects.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Emb_Obj_t * Emb_ManFindDistances( Emb_Man_t * p, Vec_Int_t * vStart, Emb_Dat_t * pDist ) +{ + Vec_Int_t * vThis, * vNext; + Emb_Obj_t * pThis, * pResult; + int i; + p->nReached = p->nDistMax = 0; + vThis = Vec_IntAlloc( 1000 ); + vNext = Vec_IntAlloc( 1000 ); + Emb_ManIncrementTravId( p ); + Emb_ManForEachObjVec( vStart, p, pThis, i ) + { + Emb_ObjSetTravIdCurrent( p, pThis ); + Vec_IntPush( vThis, pThis->hHandle ); + } + pResult = Emb_ManPerformBfs( p, vThis, vNext, pDist ); Vec_IntFree( vThis ); Vec_IntFree( vNext ); return pResult; @@ -1029,13 +1094,28 @@ void Emb_DumpGraphIntoFile( Emb_Man_t * p ) void Emb_ManComputeDimensions( Emb_Man_t * p, int nDims ) { Emb_Obj_t * pRandom, * pPivot; - Vec_Int_t * vStart; + Vec_Int_t * vStart, * vComps; int d, nReached; - int i, Counter; + int i;//, Counter; + // connect unconnected components + vComps = Emb_ManConnectedComponents( p ); +// printf( "Components = %d. Considered %d objects (out of %d).\n", Vec_IntSize(vComps), p->nReached, Emb_ManObjNum(p) ); + if ( Vec_IntSize(vComps) > 1 ) + { + Emb_Obj_t * pFanin, * pObj = Emb_ManObj( p, 0 ); + Emb_ManForEachObjVec( vComps, p, pFanin, i ) + { + assert( Emb_ObjIsCo(pFanin) ); + pFanin->Fanios[pFanin->nFanins + pFanin->nFanouts-1] = + pObj->Fanios[i] = pObj->hHandle - pFanin->hHandle; + } + } + Vec_IntFree( vComps ); + // allocate memory for vectors assert( p->pVecs == NULL ); - p->pVecs = ABC_ALLOC( Emb_Dat_t, p->nObjs * nDims ); - for ( i = 0; i < p->nObjs * nDims; i++ ) - p->pVecs[i] = ABC_INFINITY; + p->pVecs = ABC_CALLOC( Emb_Dat_t, p->nObjs * nDims ); +// for ( i = 0; i < p->nObjs * nDims; i++ ) +// p->pVecs[i] = ABC_INFINITY; vStart = Vec_IntAlloc( nDims ); // get the pivot vertex pRandom = Emb_ManRandomVertex( p ); @@ -1046,7 +1126,7 @@ void Emb_ManComputeDimensions( Emb_Man_t * p, int nDims ) nReached = p->nReached; if ( nReached < Emb_ManObjNum(p) ) { - printf( "Considering a connected component with %d objects (out of %d).\n", p->nReached, Emb_ManObjNum(p) ); +// printf( "Considering a connected component with %d objects (out of %d).\n", p->nReached, Emb_ManObjNum(p) ); } // start dimensions with this vertex Vec_IntClear( vStart ); @@ -1061,11 +1141,11 @@ void Emb_ManComputeDimensions( Emb_Man_t * p, int nDims ) } Vec_IntFree( vStart ); // make sure the number of reached objects is correct - Counter = 0; - for ( i = 0; i < p->nObjs; i++ ) - if ( p->pVecs[i] < ABC_INFINITY ) - Counter++; - assert( Counter == nReached ); +// Counter = 0; +// for ( i = 0; i < p->nObjs; i++ ) +// if ( p->pVecs[i] < ABC_INFINITY ) +// Counter++; +// assert( Counter == nReached ); } /**Function************************************************************* @@ -1338,7 +1418,6 @@ void Emb_ManComputeSolutions( Emb_Man_t * p, int nDims, int nSols ) ***********************************************************************/ void Emb_ManDerivePlacement( Emb_Man_t * p, int nSols ) { - extern int * Gia_SortFloats( float * pArray, int nSize ); float * pY0, * pY1, Max0, Max1, Min0, Min1, Str0, Str1; int * pPerm0, * pPerm1; int k; @@ -1373,10 +1452,10 @@ void Emb_ManDerivePlacement( Emb_Man_t * p, int nSols ) pY1[k] = (pY1[k] != 0.0) ? ((pY1[k] - Min1) * Str1) : 0.0; // derive the order of these numbers - pPerm0 = Gia_SortFloats( pY0, p->nObjs ); - pPerm1 = Gia_SortFloats( pY1, p->nObjs ); + pPerm0 = Gia_SortFloats( pY0, NULL, p->nObjs ); + pPerm1 = Gia_SortFloats( pY1, NULL, p->nObjs ); - // average solutions and project them into 32K by 32K square + // average solutions and project them into square [0;0xffff] x [0;0xffff] p->pPlacement = ABC_ALLOC( unsigned short, 2 * p->nObjs ); for ( k = 0; k < p->nObjs; k++ ) { @@ -1387,6 +1466,127 @@ void Emb_ManDerivePlacement( Emb_Man_t * p, int nSols ) ABC_FREE( pPerm1 ); } + +/**Function************************************************************* + + Synopsis [Computes wire-length.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +double Emb_ManComputeHPWL( Emb_Man_t * p ) +{ + double Result = 0.0; + Emb_Obj_t * pThis, * pNext; + int i, k, iMinX, iMaxX, iMinY, iMaxY; + if ( p->pPlacement == NULL ) + return 0.0; + Emb_ManForEachObj( p, pThis, i ) + { + iMinX = iMaxX = p->pPlacement[2*pThis->Value+0]; + iMinY = iMaxY = p->pPlacement[2*pThis->Value+1]; + Emb_ObjForEachFanout( pThis, pNext, k ) + { + iMinX = ABC_MIN( iMinX, p->pPlacement[2*pNext->Value+0] ); + iMaxX = ABC_MAX( iMaxX, p->pPlacement[2*pNext->Value+0] ); + iMinY = ABC_MIN( iMinY, p->pPlacement[2*pNext->Value+1] ); + iMaxY = ABC_MAX( iMaxY, p->pPlacement[2*pNext->Value+1] ); + } + Result += (iMaxX - iMinX) + (iMaxY - iMinY); + } + return Result; +} + + +/**Function************************************************************* + + Synopsis [Performs iterative refinement of the given placement.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Emb_ManPlacementRefine( Emb_Man_t * p, int nIters, int fVerbose ) +{ + Emb_Obj_t * pThis, * pNext; + double CostThis, CostPrev; + float * pEdgeX, * pEdgeY; + float * pVertX, * pVertY; + float VertX, VertY; + int * pPermX, * pPermY; + int i, k, Iter, iMinX, iMaxX, iMinY, iMaxY; + int clk = clock(); + if ( p->pPlacement == NULL ) + return; + pEdgeX = ABC_ALLOC( float, p->nObjs ); + pEdgeY = ABC_ALLOC( float, p->nObjs ); + pVertX = ABC_ALLOC( float, p->nObjs ); + pVertY = ABC_ALLOC( float, p->nObjs ); + // refine placement + CostPrev = 0.0; + for ( Iter = 0; Iter < nIters; Iter++ ) + { + // compute centers of hyperedges + CostThis = 0.0; + Emb_ManForEachObj( p, pThis, i ) + { + iMinX = iMaxX = p->pPlacement[2*pThis->Value+0]; + iMinY = iMaxY = p->pPlacement[2*pThis->Value+1]; + Emb_ObjForEachFanout( pThis, pNext, k ) + { + iMinX = ABC_MIN( iMinX, p->pPlacement[2*pNext->Value+0] ); + iMaxX = ABC_MAX( iMaxX, p->pPlacement[2*pNext->Value+0] ); + iMinY = ABC_MIN( iMinY, p->pPlacement[2*pNext->Value+1] ); + iMaxY = ABC_MAX( iMaxY, p->pPlacement[2*pNext->Value+1] ); + } + pEdgeX[pThis->Value] = 0.5 * (iMaxX + iMinX); + pEdgeY[pThis->Value] = 0.5 * (iMaxY + iMinY); + CostThis += (iMaxX - iMinX) + (iMaxY - iMinY); + } + // compute new centers of objects + Emb_ManForEachObj( p, pThis, i ) + { + VertX = pEdgeX[pThis->Value]; + VertY = pEdgeY[pThis->Value]; + Emb_ObjForEachFanin( pThis, pNext, k ) + { + VertX += pEdgeX[pNext->Value]; + VertY += pEdgeY[pNext->Value]; + } + pVertX[pThis->Value] = VertX / (Emb_ObjFaninNum(pThis) + 1); + pVertY[pThis->Value] = VertY / (Emb_ObjFaninNum(pThis) + 1); + } + // sort these numbers + pPermX = Gia_SortFloats( pVertX, NULL, p->nObjs ); + pPermY = Gia_SortFloats( pVertY, NULL, p->nObjs ); + for ( k = 0; k < p->nObjs; k++ ) + { + p->pPlacement[2*pPermX[k]+0] = (unsigned short)(int)(1.0 * k * 0xffff / p->nObjs); + p->pPlacement[2*pPermY[k]+1] = (unsigned short)(int)(1.0 * k * 0xffff / p->nObjs); + } + ABC_FREE( pPermX ); + ABC_FREE( pPermY ); + // evaluate cost + if ( fVerbose ) + { + printf( "%2d : HPWL = %e ", Iter+1, CostThis ); + ABC_PRT( "Time", clock() - clk ); + } + } + ABC_FREE( pEdgeX ); + ABC_FREE( pEdgeY ); + ABC_FREE( pVertX ); + ABC_FREE( pVertY ); +} + + /**Function************************************************************* Synopsis [Derives solutions from original vectors and eigenvectors.] @@ -1413,6 +1613,68 @@ void Emb_ManPrintSolutions( Emb_Man_t * p, int nSols ) /**Function************************************************************* + Synopsis [Prepares image for dumping.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Vec_Int_t * Emb_ManDumpGnuplotPrepare( Emb_Man_t * p ) +{ +// int nRows = 496; +// int nCols = 710; + int nRows = 500; + int nCols = 700; + Vec_Int_t * vLines; + Emb_Obj_t * pThis; + char * pBuffer, ** ppRows; + int i, k, placeX, placeY; + int fStart; + // alloc memory + pBuffer = ABC_CALLOC( char, nRows * (nCols+1) ); + ppRows = ABC_ALLOC( char *, nRows ); + for ( i = 0; i < nRows; i++ ) + ppRows[i] = pBuffer + i*(nCols+1); + // put data into them + Emb_ManForEachObj( p, pThis, i ) + { + placeX = p->pPlacement[2*pThis->Value+0] * nCols / (1<<16); + placeY = p->pPlacement[2*pThis->Value+1] * nRows / (1<<16); + assert( placeX < nCols && placeY < nRows ); + ppRows[placeY][placeX] = 1; + } + // select lines + vLines = Vec_IntAlloc( 1000 ); + for ( i = 0; i < nRows; i++ ) + { + fStart = 0; + for ( k = 0; k <= nCols; k++ ) + { + if ( ppRows[i][k] && !fStart ) + { + Vec_IntPush( vLines, k ); + Vec_IntPush( vLines, i ); + fStart = 1; + } + if ( !ppRows[i][k] && fStart ) + { + Vec_IntPush( vLines, k-1 ); + Vec_IntPush( vLines, i ); + fStart = 0; + } + } + assert( fStart == 0 ); + } + ABC_FREE( pBuffer ); + ABC_FREE( ppRows ); + return vLines; +} + +/**Function************************************************************* + Synopsis [Derives solutions from original vectors and eigenvectors.] Description [] @@ -1422,71 +1684,89 @@ void Emb_ManPrintSolutions( Emb_Man_t * p, int nSols ) SeeAlso [] ***********************************************************************/ -void Emb_ManDumpGnuplot( Emb_Man_t * p, int nSols, char * pName ) +void Emb_ManDumpGnuplot( Emb_Man_t * p, char * pName, int fDumpLarge, int fShowImage ) { - int fDumpImage = 1; + extern void Gia_ManGnuplotShow( char * pPlotFileName ); // char * pDirectory = "place\\"; char * pDirectory = ""; extern char * Ioa_TimeStamp(); FILE * pFile; char Buffer[1000]; Emb_Obj_t * pThis, * pNext; - float * pSol0, * pSol1; int i, k; - if ( nSols < 2 ) - return; if ( p->pPlacement == NULL ) { printf( "Emb_ManDumpGnuplot(): Placement is not available.\n" ); return; } - pSol0 = Emb_ManSol( p, 0 ); - pSol1 = Emb_ManSol( p, 1 ); sprintf( Buffer, "%s%s", pDirectory, Aig_FileNameGenericAppend(pName, ".plt") ); pFile = fopen( Buffer, "w" ); fprintf( pFile, "# This Gnuplot file was produced by ABC on %s\n", Ioa_TimeStamp() ); fprintf( pFile, "\n" ); - if ( fDumpImage ) - { fprintf( pFile, "set nokey\n" ); + fprintf( pFile, "\n" ); + if ( !fShowImage ) + { // fprintf( pFile, "set terminal postscript\n" ); -// fprintf( pFile, "set output \'%s\'\n", Aig_FileNameGenericAppend(pName, ".ps") ); fprintf( pFile, "set terminal gif font \'arial\' 10 size 800,600 xffffff x000000 x000000 x000000\n" ); fprintf( pFile, "set output \'%s\'\n", Aig_FileNameGenericAppend(pName, ".gif") ); fprintf( pFile, "\n" ); } - fprintf( pFile, "set title \"%s : PI = %d PO = %d FF = %d Node = %d Obj = %d\\n", - pName, Emb_ManPiNum(p), Emb_ManPoNum(p), Emb_ManRegNum(p), Emb_ManNodeNum(p), Emb_ManObjNum(p) ); + fprintf( pFile, "set title \"%s : PI = %d PO = %d FF = %d Node = %d Obj = %d HPWL = %.2e\\n", + pName, Emb_ManPiNum(p), Emb_ManPoNum(p), Emb_ManRegNum(p), Emb_ManNodeNum(p), Emb_ManObjNum(p), Emb_ManComputeHPWL(p) ); fprintf( pFile, "(image generated by ABC and Gnuplot on %s)\"", Ioa_TimeStamp() ); fprintf( pFile, "font \"Times, 12\"\n" ); fprintf( pFile, "\n" ); fprintf( pFile, "plot [:] '-' w l\n" ); fprintf( pFile, "\n" ); - Emb_ManForEachObj( p, pThis, i ) + if ( fDumpLarge ) { - if ( !Emb_ObjIsTravIdCurrent(p, pThis) ) - continue; - Emb_ObjForEachFanout( pThis, pNext, k ) + int begX, begY, endX, endY; + Vec_Int_t * vLines = Emb_ManDumpGnuplotPrepare( p ); + Vec_IntForEachEntry( vLines, begX, i ) { - assert( Emb_ObjIsTravIdCurrent(p, pNext) ); -// fprintf( pFile, "%d %d\n", (int)pSol0[pThis->Value], (int)pSol1[pThis->Value] ); -// fprintf( pFile, "%d %d\n", (int)pSol0[pNext->Value], (int)pSol1[pNext->Value] ); -// fprintf( pFile, "%5.2f %5.2f\n", pSol0[pThis->Value], pSol1[pThis->Value] ); -// fprintf( pFile, "%5.2f %5.2f\n", pSol0[pNext->Value], pSol1[pNext->Value] ); - fprintf( pFile, "%5d %5d\n", p->pPlacement[2*pThis->Value+0], p->pPlacement[2*pThis->Value+1] ); - fprintf( pFile, "%5d %5d\n", p->pPlacement[2*pNext->Value+0], p->pPlacement[2*pNext->Value+1] ); + begY = Vec_IntEntry( vLines, i+1 ); + endX = Vec_IntEntry( vLines, i+2 ); + endY = Vec_IntEntry( vLines, i+3 ); + i += 3; + fprintf( pFile, "%5d %5d\n", begX, begY ); + fprintf( pFile, "%5d %5d\n", endX, endY ); fprintf( pFile, "\n" ); } + Vec_IntFree( vLines ); + } + else + { + Emb_ManForEachObj( p, pThis, i ) + { + if ( !Emb_ObjIsTravIdCurrent(p, pThis) ) + continue; + Emb_ObjForEachFanout( pThis, pNext, k ) + { + assert( Emb_ObjIsTravIdCurrent(p, pNext) ); + fprintf( pFile, "%5d %5d\n", p->pPlacement[2*pThis->Value+0], p->pPlacement[2*pThis->Value+1] ); + fprintf( pFile, "%5d %5d\n", p->pPlacement[2*pNext->Value+0], p->pPlacement[2*pNext->Value+1] ); + fprintf( pFile, "\n" ); + } + } } fprintf( pFile, "EOF\n" ); fprintf( pFile, "\n" ); - if ( !fDumpImage ) + if ( fShowImage ) { - fprintf( pFile, "pause -1 \"Hit return to continue\"\n" ); + fprintf( pFile, "pause -1 \"Close window\"\n" ); // Hit return to continue fprintf( pFile, "reset\n" ); fprintf( pFile, "\n" ); } + else + { + fprintf( pFile, "# pause -1 \"Close window\"\n" ); // Hit return to continue + fprintf( pFile, "# reset\n" ); + fprintf( pFile, "\n" ); + } fclose( pFile ); + if ( fShowImage ) + Gia_ManGnuplotShow( Buffer ); } /**Function************************************************************* @@ -1500,7 +1780,7 @@ void Emb_ManDumpGnuplot( Emb_Man_t * p, int nSols, char * pName ) SeeAlso [] ***********************************************************************/ -void Gia_ManSolveProblem( Gia_Man_t * pGia, int nDims, int nSols, int fCluster, int fDump, int fVerbose ) +void Gia_ManSolveProblem( Gia_Man_t * pGia, Emb_Par_t * pPars ) { Emb_Man_t * p; int clk, clkSetup; @@ -1508,18 +1788,18 @@ void Gia_ManSolveProblem( Gia_Man_t * pGia, int nDims, int nSols, int fCluster, // transform AIG into internal data-structure clk = clock(); - if ( fCluster ) + if ( pPars->fCluster ) { p = Emb_ManStart( pGia ); - if ( fVerbose ) + if ( pPars->fVerbose ) { - printf( "After clustering: " ); + printf( "Clustered: " ); Emb_ManPrintStats( p ); } } else p = Emb_ManStartSimple( pGia ); - p->fVerbose = fVerbose; + p->fVerbose = pPars->fVerbose; // Emb_ManPrintFanio( p ); // prepare data-structure @@ -1529,26 +1809,40 @@ clk = clock(); clkSetup = clock() - clk; clk = clock(); - Emb_ManComputeDimensions( p, nDims ); -if ( fVerbose ) + Emb_ManComputeDimensions( p, pPars->nDims ); +if ( pPars->fVerbose ) ABC_PRT( "Setup ", clkSetup ); -if ( fVerbose ) +if ( pPars->fVerbose ) ABC_PRT( "Dimensions", clock() - clk ); clk = clock(); - Emb_ManComputeCovariance( p, nDims ); -if ( fVerbose ) + Emb_ManComputeCovariance( p, pPars->nDims ); +if ( pPars->fVerbose ) ABC_PRT( "Matrix ", clock() - clk ); clk = clock(); - Emb_ManComputeEigenvectors( p, nDims, nSols ); - Emb_ManComputeSolutions( p, nDims, nSols ); - Emb_ManDerivePlacement( p, nSols ); -if ( fVerbose ) + Emb_ManComputeEigenvectors( p, pPars->nDims, pPars->nSols ); + Emb_ManComputeSolutions( p, pPars->nDims, pPars->nSols ); + Emb_ManDerivePlacement( p, pPars->nSols ); +if ( pPars->fVerbose ) ABC_PRT( "Eigenvecs ", clock() - clk ); - if ( fDump ) - Emb_ManDumpGnuplot( p, nSols, pGia->pName ); + if ( pPars->fRefine ) + { +clk = clock(); + Emb_ManPlacementRefine( p, pPars->nIters, pPars->fVerbose ); +if ( pPars->fVerbose ) +ABC_PRT( "Refinement", clock() - clk ); + } + + if ( (pPars->fDump || pPars->fDumpLarge) && pPars->nSols == 2 ) + { +clk = clock(); + Emb_ManDumpGnuplot( p, pGia->pName, pPars->fDumpLarge, pPars->fShowImage ); +if ( pPars->fVerbose ) +ABC_PRT( "Image dump", clock() - clk ); + } + Emb_ManStop( p ); } diff --git a/src/aig/gia/giaEnable.c b/src/aig/gia/giaEnable.c new file mode 100644 index 00000000..d05dc5a9 --- /dev/null +++ b/src/aig/gia/giaEnable.c @@ -0,0 +1,210 @@ +/**CFile**************************************************************** + + FileName [gia.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Scalable AIG package.] + + Synopsis [Structural detection of enables, sets and resets.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: gia.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "gia.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Collects the supergate.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_CollectSuper_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper ) +{ + // if the new node is complemented or a PI, another gate begins + if ( Gia_IsComplement(pObj) || Gia_ObjIsCi(pObj) ) + { + Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_Regular(pObj)) ); + return; + } + assert( Gia_ObjIsAnd(pObj) ); + // go through the branches + Gia_CollectSuper_rec( p, Gia_ObjChild0(pObj), vSuper ); + Gia_CollectSuper_rec( p, Gia_ObjChild1(pObj), vSuper ); +} + +/**Function************************************************************* + + Synopsis [Collects the supergate.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_CollectSuper( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper ) +{ + assert( !Gia_IsComplement(pObj) ); + Vec_IntClear( vSuper ); +// Gia_CollectSuper_rec( p, pObj, vSuper ); + if ( Gia_ObjIsAnd(pObj) ) + { + Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_ObjFanin0(pObj)) ); + Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_ObjFanin1(pObj)) ); + } + else + Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_Regular(pObj)) ); + +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManPrintSignals( Gia_Man_t * p, int * pFreq, char * pStr ) +{ + Vec_Int_t * vObjs; + int i, Counter = 0, nTotal = 0; + vObjs = Vec_IntAlloc( 100 ); + for ( i = 0; i < Gia_ManObjNum(p); i++ ) + if ( pFreq[i] > 1 ) + { + nTotal += pFreq[i]; + Counter++; + } + printf( "%s (total = %d driven = %d)\n", pStr, Counter, nTotal ); + Counter = 0; + for ( i = 0; i < Gia_ManObjNum(p); i++ ) + if ( pFreq[i] > 1 ) + { + printf( "%3d : Obj = %6d Refs = %6d Freq = %6d\n", + ++Counter, i, Gia_ObjRefs(p, Gia_ManObj(p,i)), pFreq[i] ); + Vec_IntPush( vObjs, i ); + } + Vec_IntFree( vObjs ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManDetectSeqSignals( Gia_Man_t * p, int fSetReset ) +{ + Vec_Int_t * vSuper; + Gia_Obj_t * pFlop, * pObjC, * pObj0, * pObj1, * pNode, * pTemp; + int i, k, Ent, * pSets, * pResets, * pEnables; + int nHaveSetReset = 0, nHaveEnable = 0; + assert( Gia_ManRegNum(p) > 0 ); + pSets = ABC_CALLOC( int, Gia_ManObjNum(p) ); + pResets = ABC_CALLOC( int, Gia_ManObjNum(p) ); + pEnables = ABC_CALLOC( int, Gia_ManObjNum(p) ); + vSuper = Vec_IntAlloc( 100 ); + Gia_ManForEachRi( p, pFlop, i ) + { + pNode = Gia_ObjFanin0(pFlop); + if ( !Gia_ObjIsAnd(pNode) ) + continue; + // detect sets/resets + Gia_CollectSuper( p, pNode, vSuper ); + if ( Gia_ObjFaninC0(pFlop) ) + Vec_IntForEachEntry( vSuper, Ent, k ) + pSets[Ent]++; + else + Vec_IntForEachEntry( vSuper, Ent, k ) + pResets[Ent]++; + // detect enables + if ( !Gia_ObjIsMuxType(pNode) ) + continue; + pObjC = Gia_ObjRecognizeMux( pNode, &pObj0, &pObj1 ); + pTemp = Gia_ObjRiToRo( p, pFlop ); + if ( Gia_Regular(pObj0) != pTemp && Gia_Regular(pObj1) != pTemp ) + continue; + if ( !Gia_ObjFaninC0(pFlop) ) + { + pObj0 = Gia_Not(pObj0); + pObj1 = Gia_Not(pObj1); + } + if ( Gia_IsComplement(pObjC) ) + { + pObjC = Gia_Not(pObjC); + pTemp = pObj0; + pObj0 = pObj1; + pObj1 = pTemp; + } + // detect controls +// Gia_CollectSuper( p, pObjC, vSuper ); +// Vec_IntForEachEntry( vSuper, Ent, k ) +// pEnables[Ent]++; + pEnables[Gia_ObjId(p, pObjC)]++; + nHaveEnable++; + } + Gia_ManForEachRi( p, pFlop, i ) + { + pNode = Gia_ObjFanin0(pFlop); + if ( !Gia_ObjIsAnd(pNode) ) + continue; + // detect sets/resets + Gia_CollectSuper( p, pNode, vSuper ); + Vec_IntForEachEntry( vSuper, Ent, k ) + if ( pSets[Ent] > 1 || pResets[Ent] > 1 ) + { + nHaveSetReset++; + break; + } + } + Vec_IntFree( vSuper ); + Gia_ManCreateRefs( p ); + printf( "Flops with set/reset = %6d. Flops with enable = %6d.\n", nHaveSetReset, nHaveEnable ); + if ( fSetReset ) + { + Gia_ManPrintSignals( p, pSets, "Set signals" ); + Gia_ManPrintSignals( p, pResets, "Reset signals" ); + } + Gia_ManPrintSignals( p, pEnables, "Enable signals" ); + ABC_FREE( p->pRefs ); + ABC_FREE( pSets ); + ABC_FREE( pResets ); + ABC_FREE( pEnables ); +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/gia/giaEquiv.c b/src/aig/gia/giaEquiv.c new file mode 100644 index 00000000..9e190da3 --- /dev/null +++ b/src/aig/gia/giaEquiv.c @@ -0,0 +1,618 @@ +/**CFile**************************************************************** + + FileName [giaEquiv.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Scalable AIG package.] + + Synopsis [Manipulation of equivalence classes.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: giaEquiv.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "gia.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Given representatives, derives pointers to the next objects.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int * Gia_ManDeriveNexts( Gia_Man_t * p ) +{ + unsigned * pNexts, * pTails; + int i; + assert( p->pReprs ); + pNexts = ABC_CALLOC( unsigned, Gia_ManObjNum(p) ); + pTails = ABC_ALLOC( unsigned, Gia_ManObjNum(p) ); + for ( i = 0; i < Gia_ManObjNum(p); i++ ) + pTails[i] = i; + for ( i = 0; i < Gia_ManObjNum(p); i++ ) + { + if ( !p->pReprs[i].iRepr || p->pReprs[i].iRepr == GIA_VOID ) + continue; + pNexts[ pTails[p->pReprs[i].iRepr] ] = i; + pTails[p->pReprs[i].iRepr] = i; + } + ABC_FREE( pTails ); + return (int *)pNexts; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManEquivCountOne( Gia_Man_t * p, int i ) +{ + int Ent, nLits = 1; + Gia_ClassForEachObj1( p, i, Ent ) + { + assert( Gia_ObjRepr(p, Ent) == i ); + nLits++; + } + return nLits; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivPrintOne( Gia_Man_t * p, int i, int Counter ) +{ + int Ent; + printf( "Class %4d : Num = %2d {", Counter, Gia_ManEquivCountOne(p, i) ); + Gia_ClassForEachObj( p, i, Ent ) + { + printf(" %d", Ent ); + if ( p->pReprs[Ent].fColorA || p->pReprs[Ent].fColorB ) + printf(" <%d%d>", p->pReprs[Ent].fColorA, p->pReprs[Ent].fColorB ); + } + printf( " }\n" ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManEquivCountLitsAll( Gia_Man_t * p ) +{ + int i, nLits = 0; + for ( i = 0; i < Gia_ManObjNum(p); i++ ) + nLits += (Gia_ObjRepr(p, i) != GIA_VOID); + return nLits; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManEquivCheckLits( Gia_Man_t * p, int nLits ) +{ + int nLitsReal = Gia_ManEquivCountLitsAll( p ); + if ( nLitsReal != nLits ) + printf( "Detected a mismatch in counting equivalence classes (%d).\n", nLitsReal - nLits ); + return 1; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivPrintClasses( Gia_Man_t * p, int fVerbose, float Mem ) +{ + int i, Counter = 0, Counter1 = 0, CounterX = 0, Proved = 0, nLits; + for ( i = 1; i < Gia_ManObjNum(p); i++ ) + { + if ( Gia_ObjIsHead(p, i) ) + Counter++; + else if ( Gia_ObjIsConst(p, i) ) + Counter1++; + else if ( Gia_ObjIsNone(p, i) ) + CounterX++; + if ( Gia_ObjProved(p, i) ) + Proved++; + } + CounterX -= Gia_ManCoNum(p); + nLits = Gia_ManCiNum(p) + Gia_ManAndNum(p) - Counter - CounterX; + printf( "cls =%7d cst =%8d lit =%8d unused =%8d proof =%6d mem =%5.2f Mb\n", + Counter, Counter1, nLits, CounterX, Proved, (Mem == 0.0) ? 8.0*Gia_ManObjNum(p)/(1<<20) : Mem ); + assert( Gia_ManEquivCheckLits( p, nLits ) ); + if ( fVerbose ) + { + Counter = 0; + Gia_ManForEachClass( p, i ) + Gia_ManEquivPrintOne( p, i, ++Counter ); + } +} + +/**Function************************************************************* + + Synopsis [Returns representative node.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline Gia_Obj_t * Gia_ManEquivRepr( Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + if ( !Gia_ObjProved(p, Gia_ObjId(p,pObj)) ) + return NULL; + return Gia_ManObj( p, Gia_ObjRepr(p, Gia_ObjId(p,pObj)) ); +} + +/**Function************************************************************* + + Synopsis [Duplicates the AIG in the DFS order.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivReduce_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + Gia_Obj_t * pRepr; + if ( ~pObj->Value ) + return; + assert( Gia_ObjIsAnd(pObj) ); + if ( (pRepr = Gia_ManEquivRepr(p, pObj)) ) + { + Gia_ManEquivReduce_rec( pNew, p, pRepr ); + pObj->Value = Gia_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); + return; + } + Gia_ManEquivReduce_rec( pNew, p, Gia_ObjFanin0(pObj) ); + Gia_ManEquivReduce_rec( pNew, p, Gia_ObjFanin1(pObj) ); + pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) ); +} + +/**Function************************************************************* + + Synopsis [Reduces AIG using equivalence classes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManEquivReduce( Gia_Man_t * p ) +{ + Gia_Man_t * pNew; + Gia_Obj_t * pObj, * pRepr; + int i; + Gia_ManSetPhase( p ); + pNew = Gia_ManStart( Gia_ManObjNum(p) ); + pNew->pName = Aig_UtilStrsav( p->pName ); + Gia_ManFillValue( p ); + Gia_ManConst0(p)->Value = 0; + Gia_ManForEachCi( p, pObj, i ) + { + pObj->Value = Gia_ManAppendCi(pNew); + if ( (pRepr = Gia_ManEquivRepr(p, pObj)) ) + pObj->Value = Gia_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); + } + Gia_ManHashAlloc( pNew ); + Gia_ManForEachCo( p, pObj, i ) + Gia_ManEquivReduce_rec( pNew, p, Gia_ObjFanin0(pObj) ); + Gia_ManForEachCo( p, pObj, i ) + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + Gia_ManHashStop( pNew ); + Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [Reduces AIG using equivalence classes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivFixOutputPairs( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj0, * pObj1; + int i; + assert( (Gia_ManPoNum(p) & 1) == 0 ); + Gia_ManForEachPo( p, pObj0, i ) + { + pObj1 = Gia_ManPo( p, ++i ); + if ( Gia_ObjChild0(pObj0) != Gia_ObjChild0(pObj1) ) + continue; + pObj0->iDiff0 = Gia_ObjId(p, pObj0); + pObj0->fCompl0 = 0; + pObj1->iDiff0 = Gia_ObjId(p, pObj1); + pObj1->fCompl0 = 0; + } +} + +/**Function************************************************************* + + Synopsis [Removes pointers to the unmarked nodes..] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivUpdatePointers( Gia_Man_t * p, Gia_Man_t * pNew ) +{ + Gia_Obj_t * pObj, * pObjNew; + int i; + Gia_ManForEachObj( p, pObj, i ) + { + if ( !~pObj->Value ) + continue; + pObjNew = Gia_ManObj( pNew, Gia_Lit2Var(pObj->Value) ); + if ( pObjNew->fMark0 ) + pObj->Value = ~0; + } +} + +/**Function************************************************************* + + Synopsis [Removes pointers to the unmarked nodes..] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivDeriveReprs( Gia_Man_t * p, Gia_Man_t * pNew, Gia_Man_t * pFinal ) +{ + Vec_Int_t * vClass; + Gia_Obj_t * pObj, * pObjNew; + int i, k, iNode, iRepr, iPrev; + // start representatives + pFinal->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pFinal) ); + for ( i = 0; i < Gia_ManObjNum(pFinal); i++ ) + Gia_ObjSetRepr( pFinal, i, GIA_VOID ); + // iterate over constant candidates + Gia_ManForEachConst( p, i ) + { + pObj = Gia_ManObj( p, i ); + if ( !~pObj->Value ) + continue; + pObjNew = Gia_ManObj( pNew, Gia_Lit2Var(pObj->Value) ); + if ( Gia_Lit2Var(pObjNew->Value) == 0 ) + continue; + Gia_ObjSetRepr( pFinal, Gia_Lit2Var(pObjNew->Value), 0 ); + } + // iterate over class candidates + vClass = Vec_IntAlloc( 100 ); + Gia_ManForEachClass( p, i ) + { + Vec_IntClear( vClass ); + Gia_ClassForEachObj( p, i, k ) + { + pObj = Gia_ManObj( p, k ); + if ( !~pObj->Value ) + continue; + pObjNew = Gia_ManObj( pNew, Gia_Lit2Var(pObj->Value) ); + Vec_IntPushUnique( vClass, Gia_Lit2Var(pObjNew->Value) ); + } + if ( Vec_IntSize( vClass ) < 2 ) + continue; + Vec_IntSort( vClass, 0 ); + iRepr = iPrev = Vec_IntEntry( vClass, 0 ); + Vec_IntForEachEntryStart( vClass, iNode, k, 1 ) + { + Gia_ObjSetRepr( pFinal, iNode, iRepr ); + assert( iPrev < iNode ); + iPrev = iNode; + } + } + Vec_IntFree( vClass ); + pFinal->pNexts = Gia_ManDeriveNexts( pFinal ); +} + +/**Function************************************************************* + + Synopsis [Reduces AIG while remapping equivalence classes.] + + Description [Drops the pairs of outputs if they are proved equivalent.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManEquivReduceAndRemap( Gia_Man_t * p, int fSeq, int fMiterPairs ) +{ + Gia_Man_t * pNew, * pFinal; + pNew = Gia_ManEquivReduce( p ); + if ( fMiterPairs ) + Gia_ManEquivFixOutputPairs( pNew ); + if ( fSeq ) + Gia_ManSeqMarkUsed( pNew ); + else + Gia_ManCombMarkUsed( pNew ); + Gia_ManEquivUpdatePointers( p, pNew ); + pFinal = Gia_ManDupMarked( pNew ); + Gia_ManEquivDeriveReprs( p, pNew, pFinal ); + Gia_ManStop( pNew ); + return pFinal; +} + +/**Function************************************************************* + + Synopsis [Marks CIs/COs/ANDs unreachable from POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManEquivSetColor_rec( Gia_Man_t * p, Gia_Obj_t * pObj, int fOdds ) +{ + if ( Gia_ObjVisitColor( p, Gia_ObjId(p,pObj), fOdds ) ) + return 0; + if ( Gia_ObjIsRo(p, pObj) ) + return 1 + Gia_ManEquivSetColor_rec( p, Gia_ObjFanin0(Gia_ObjRoToRi(p, pObj)), fOdds ); + assert( Gia_ObjIsAnd(pObj) ); + return 1 + Gia_ManEquivSetColor_rec( p, Gia_ObjFanin0(pObj), fOdds ) + + Gia_ManEquivSetColor_rec( p, Gia_ObjFanin1(pObj), fOdds ); +} + +/**Function************************************************************* + + Synopsis [Marks CIs/COs/ANDs unreachable from POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManEquivSetColors( Gia_Man_t * p, int fVerbose ) +{ + Gia_Obj_t * pObj; + int i, nNodes[2] = {0,0}, nDiffs[2]; + assert( (Gia_ManPoNum(p) & 1) == 0 ); + Gia_ObjSetColors( p, 0 ); + Gia_ManForEachPi( p, pObj, i ) + Gia_ObjSetColors( p, Gia_ObjId(p,pObj) ); + Gia_ManForEachPo( p, pObj, i ) + nNodes[i&1] += Gia_ManEquivSetColor_rec( p, Gia_ObjFanin0(pObj), i&1 ); +// Gia_ManForEachObj( p, pObj, i ) +// if ( Gia_ObjIsCi(pObj) || Gia_ObjIsAnd(pObj) ) +// assert( Gia_ObjColors(p, i) ); + nDiffs[0] = Gia_ManCiNum(p) + Gia_ManAndNum(p) - (Gia_ManPiNum(p) + nNodes[0]); + nDiffs[1] = Gia_ManCiNum(p) + Gia_ManAndNum(p) - (Gia_ManPiNum(p) + nNodes[1]); + if ( fVerbose ) + { + printf( "CI+AND = %7d A = %7d B = %7d Ad = %7d Bd = %7d AB = %7d.\n", + Gia_ManCiNum(p) + Gia_ManAndNum(p), + Gia_ManPiNum(p) + nNodes[0], Gia_ManPiNum(p) + nNodes[1], + nDiffs[0], nDiffs[1], + Gia_ManCiNum(p) + Gia_ManAndNum(p) - nDiffs[0] - nDiffs[1] ); + } + return (nDiffs[0] + nDiffs[1]) / 2; +} + +/**Function************************************************************* + + Synopsis [Duplicates the AIG in the DFS order.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManSpecReduce_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vXorLits ) +{ + Gia_Obj_t * pRepr; + int iLitNew; + if ( ~pObj->Value ) + return; + assert( Gia_ObjIsAnd(pObj) ); + Gia_ManSpecReduce_rec( pNew, p, Gia_ObjFanin0(pObj), vXorLits ); + Gia_ManSpecReduce_rec( pNew, p, Gia_ObjFanin1(pObj), vXorLits ); + pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) ); + pRepr = Gia_ObjReprObj( p, Gia_ObjId(p,pObj) ); + if ( pRepr == NULL ) + return; + iLitNew = Gia_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); + if ( pObj->Value != (unsigned)iLitNew && !Gia_ObjProved(p, Gia_ObjId(p,pObj)) ) + Vec_IntPush( vXorLits, Gia_ManHashXor(pNew, pObj->Value, iLitNew) ); + pObj->Value = iLitNew; +} + +/**Function************************************************************* + + Synopsis [Reduces AIG using equivalence classes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManSpecReduce( Gia_Man_t * p ) +{ + Gia_Man_t * pNew, * pTemp; + Gia_Obj_t * pObj, * pRepr; + Vec_Int_t * vXorLits; + int i, iLitNew; + if ( !p->pReprs ) + return NULL; + vXorLits = Vec_IntAlloc( 1000 ); + Gia_ManSetPhase( p ); + pNew = Gia_ManStart( Gia_ManObjNum(p) ); + pNew->pName = Aig_UtilStrsav( p->pName ); + Gia_ManFillValue( p ); + Gia_ManConst0(p)->Value = 0; + Gia_ManForEachCi( p, pObj, i ) + pObj->Value = Gia_ManAppendCi(pNew); + Gia_ManHashAlloc( pNew ); + Gia_ManForEachCi( p, pObj, i ) + { + pRepr = Gia_ObjReprObj( p, Gia_ObjId(p,pObj) ); + if ( pRepr == NULL ) + continue; + iLitNew = Gia_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) ); + if ( pObj->Value != (unsigned)iLitNew && !Gia_ObjProved(p, Gia_ObjId(p,pObj)) ) + Vec_IntPush( vXorLits, Gia_ManHashXor(pNew, pObj->Value, iLitNew) ); + pObj->Value = iLitNew; + } + Gia_ManForEachCo( p, pObj, i ) + Gia_ManSpecReduce_rec( pNew, p, Gia_ObjFanin0(pObj), vXorLits ); + Vec_IntForEachEntry( vXorLits, iLitNew, i ) + Gia_ManAppendCo( pNew, iLitNew ); + if ( Vec_IntSize(vXorLits) == 0 ) + { + printf( "Speculatively reduced model has no primary outputs.\n" ); + Gia_ManAppendCo( pNew, 0 ); + } + Gia_ManForEachRi( p, pObj, i ) + Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); + Vec_IntFree( vXorLits ); + Gia_ManHashStop( pNew ); + Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) ); + pNew = Gia_ManCleanup( pTemp = pNew ); + Gia_ManStop( pTemp ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [Transforms equiv classes by removing the AB nodes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManEquivTransform( Gia_Man_t * p, int fVerbose ) +{ + extern void Cec_ManSimClassCreate( Gia_Man_t * p, Vec_Int_t * vClass ); + Vec_Int_t * vClass, * vClassNew; + int iRepr, iNode, Ent, k; + int nRemovedLits = 0, nRemovedClas = 0; + int nTotalLits = 0, nTotalClas = 0; + Gia_Obj_t * pObj; + int i; + assert( p->pReprs && p->pNexts ); + vClass = Vec_IntAlloc( 100 ); + vClassNew = Vec_IntAlloc( 100 ); + Gia_ManForEachObj( p, pObj, i ) + if ( Gia_ObjIsCi(pObj) || Gia_ObjIsAnd(pObj) ) + assert( Gia_ObjColors(p, i) ); + Gia_ManForEachClassReverse( p, iRepr ) + { + nTotalClas++; + Vec_IntClear( vClass ); + Vec_IntClear( vClassNew ); + Gia_ClassForEachObj( p, iRepr, iNode ) + { + nTotalLits++; + Vec_IntPush( vClass, iNode ); + assert( Gia_ObjColors(p, iNode) ); + if ( Gia_ObjColors(p, iNode) != 3 ) + Vec_IntPush( vClassNew, iNode ); + else + nRemovedLits++; + } + Vec_IntForEachEntry( vClass, Ent, k ) + { + p->pReprs[Ent].fFailed = p->pReprs[Ent].fProved = 0; + p->pReprs[Ent].iRepr = GIA_VOID; + p->pNexts[Ent] = 0; + } + if ( Vec_IntSize(vClassNew) < 2 ) + { + nRemovedClas++; + continue; + } + Cec_ManSimClassCreate( p, vClassNew ); + } + Vec_IntFree( vClass ); + Vec_IntFree( vClassNew ); + if ( fVerbose ) + printf( "Removed classes = %6d (out of %6d). Removed literals = %6d (out of %6d).\n", + nRemovedClas, nTotalClas, nRemovedLits, nTotalLits ); +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/gia/giaForce.c b/src/aig/gia/giaForce.c index c2d2d33f..cf4c4aa5 100644 --- a/src/aig/gia/giaForce.c +++ b/src/aig/gia/giaForce.c @@ -23,47 +23,100 @@ /* The code is based on the paper by F. A. Aloul, I. L. Markov, and K. A. Sakallah. "FORCE: A Fast and Easy-To-Implement Variable-Ordering Heuristic", Proc. GLSVLSI’03. + http://www.eecs.umich.edu/~imarkov/pubs/conf/glsvlsi03-force.pdf */ //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// -typedef struct For_Obj_t_ For_Obj_t; -struct For_Obj_t_ +typedef struct Frc_Obj_t_ Frc_Obj_t; +struct Frc_Obj_t_ { - int iObj; - float lNode; + unsigned fCi : 1; // terminal node CI + unsigned fCo : 1; // terminal node CO + unsigned fMark0 : 1; // first user-controlled mark + unsigned fMark1 : 1; // second user-controlled mark + unsigned nFanins : 28; // the number of fanins + unsigned nFanouts; // the number of fanouts + unsigned iFanout; // the current number of fanouts + int hHandle; // the handle of the node + int pPlace; // the placement of each node + union { + float fEdgeCenter; // center-of-gravity of the edge + unsigned iFanin; + }; + int Fanios[0]; // the array of fanins/fanouts }; -typedef struct For_Man_t_ For_Man_t; -struct For_Man_t_ +typedef struct Frc_Man_t_ Frc_Man_t; +struct Frc_Man_t_ { Gia_Man_t * pGia; // the original AIG manager + Vec_Int_t * vCis; // the vector of CIs (PIs + LOs) + Vec_Int_t * vCos; // the vector of COs (POs + LIs) int nObjs; // the number of objects - int iObj; // the last added object - int * pPlace; // coordinates of objects - int * piNext; // array of next pointers - int * piRoot; // array of root pointers - float * plEdge; // edge coordinates - For_Obj_t * pNodes; // the array of nodes + int nRegs; // the number of registers + int * pObjData; // the array containing data for objects + int nObjData; // the size of array to store the logic network + int fVerbose; // verbose output flag + int nCutCur; // current cut + int nCutMax; // max cut seen }; -static inline int Gia_ObjPlace( For_Man_t * p, Gia_Obj_t * pObj ) { return p->pPlace[Gia_ObjId(p->pGia, pObj)]; } -static inline int Gia_ObjPlaceFanin0( For_Man_t * p, Gia_Obj_t * pObj ) { return p->pPlace[Gia_ObjFaninId0p(p->pGia, pObj)]; } -static inline int Gia_ObjPlaceFanin1( For_Man_t * p, Gia_Obj_t * pObj ) { return p->pPlace[Gia_ObjFaninId1p(p->pGia, pObj)]; } - -static inline int Gia_ObjEdge( For_Man_t * p, Gia_Obj_t * pObj ) { return p->plEdge[Gia_ObjId(p->pGia, pObj)]; } -static inline int Gia_ObjEdgeFanin0( For_Man_t * p, Gia_Obj_t * pObj ) { return p->plEdge[Gia_ObjFaninId0p(p->pGia, pObj)]; } -static inline int Gia_ObjEdgeFanin1( For_Man_t * p, Gia_Obj_t * pObj ) { return p->plEdge[Gia_ObjFaninId1p(p->pGia, pObj)]; } +static inline int Frc_ManRegNum( Frc_Man_t * p ) { return p->nRegs; } +static inline int Frc_ManCiNum( Frc_Man_t * p ) { return Vec_IntSize(p->vCis); } +static inline int Frc_ManCoNum( Frc_Man_t * p ) { return Vec_IntSize(p->vCos); } +static inline int Frc_ManPiNum( Frc_Man_t * p ) { return Vec_IntSize(p->vCis) - p->nRegs; } +static inline int Frc_ManPoNum( Frc_Man_t * p ) { return Vec_IntSize(p->vCos) - p->nRegs; } +static inline int Frc_ManObjNum( Frc_Man_t * p ) { return p->nObjs; } +static inline int Frc_ManNodeNum( Frc_Man_t * p ) { return p->nObjs - Vec_IntSize(p->vCis) - Vec_IntSize(p->vCos); } + +static inline Frc_Obj_t * Frc_ManObj( Frc_Man_t * p, int hHandle ) { return (Frc_Obj_t *)(p->pObjData + hHandle); } +static inline Frc_Obj_t * Frc_ManCi( Frc_Man_t * p, int i ) { return Frc_ManObj( p, Vec_IntEntry(p->vCis,i) ); } +static inline Frc_Obj_t * Frc_ManCo( Frc_Man_t * p, int i ) { return Frc_ManObj( p, Vec_IntEntry(p->vCos,i) ); } + +static inline int Frc_ObjIsTerm( Frc_Obj_t * pObj ) { return pObj->fCi || pObj->fCo; } +static inline int Frc_ObjIsCi( Frc_Obj_t * pObj ) { return pObj->fCi; } +static inline int Frc_ObjIsCo( Frc_Obj_t * pObj ) { return pObj->fCo; } +static inline int Frc_ObjIsPi( Frc_Obj_t * pObj ) { return pObj->fCi && pObj->nFanins == 0; } +static inline int Frc_ObjIsPo( Frc_Obj_t * pObj ) { return pObj->fCo && pObj->nFanouts == 0; } +static inline int Frc_ObjIsNode( Frc_Obj_t * pObj ) { return!Frc_ObjIsTerm(pObj) && pObj->nFanins > 0; } +static inline int Frc_ObjIsConst0( Frc_Obj_t * pObj ) { return!Frc_ObjIsTerm(pObj) && pObj->nFanins == 0; } + +static inline int Frc_ObjSize( Frc_Obj_t * pObj ) { return sizeof(Frc_Obj_t) / 4 + pObj->nFanins + pObj->nFanouts; } +static inline int Frc_ObjFaninNum( Frc_Obj_t * pObj ) { return pObj->nFanins; } +static inline int Frc_ObjFanoutNum( Frc_Obj_t * pObj ) { return pObj->nFanouts; } +static inline Frc_Obj_t * Frc_ObjFanin( Frc_Obj_t * pObj, int i ) { return (Frc_Obj_t *)(((int *)pObj) - pObj->Fanios[i]); } +static inline Frc_Obj_t * Frc_ObjFanout( Frc_Obj_t * pObj, int i ) { return (Frc_Obj_t *)(((int *)pObj) + pObj->Fanios[pObj->nFanins+i]); } + +#define Frc_ManForEachObj( p, pObj, i ) \ + for ( i = 0; (i < p->nObjData) && (pObj = Frc_ManObj(p,i)); i += Frc_ObjSize(pObj) ) +#define Frc_ManForEachObjVec( vVec, p, pObj, i ) \ + for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Frc_ManObj(p, Vec_IntEntry(vVec,i))); i++ ) + +#define Frc_ManForEachNode( p, pObj, i ) \ + for ( i = 0; (i < p->nObjData) && (pObj = Frc_ManObj(p,i)); i += Frc_ObjSize(pObj) ) if ( Frc_ObjIsTerm(pObj) ) {} else +#define Frc_ManForEachCi( p, pObj, i ) \ + for ( i = 0; (i < Vec_IntSize(p->vCis)) && (pObj = Frc_ManObj(p,Vec_IntEntry(p->vCis,i))); i++ ) +#define Frc_ManForEachCo( p, pObj, i ) \ + for ( i = 0; (i < Vec_IntSize(p->vCos)) && (pObj = Frc_ManObj(p,Vec_IntEntry(p->vCos,i))); i++ ) + +#define Frc_ObjForEachFanin( pObj, pNext, i ) \ + for ( i = 0; (i < (int)pObj->nFanins) && (pNext = Frc_ObjFanin(pObj,i)); i++ ) +#define Frc_ObjForEachFaninReverse( pObj, pNext, i ) \ + for ( i = (int)pObj->nFanins - 1; (i >= 0) && (pNext = Frc_ObjFanin(pObj,i)); i-- ) +#define Frc_ObjForEachFanout( pObj, pNext, i ) \ + for ( i = 0; (i < (int)pObj->nFanouts) && (pNext = Frc_ObjFanout(pObj,i)); i++ ) //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// + /**Function************************************************************* - Synopsis [] + Synopsis [Creates fanin/fanout pair.] Description [] @@ -72,23 +125,128 @@ static inline int Gia_ObjEdgeFanin1( For_Man_t * p, Gia_Obj_t * pObj ) { retu SeeAlso [] ***********************************************************************/ -For_Man_t * For_ManStart( Gia_Man_t * pGia ) +void Frc_ObjAddFanin( Frc_Obj_t * pObj, Frc_Obj_t * pFanin ) +{ + assert( pObj->iFanin < pObj->nFanins ); + assert( pFanin->iFanout < pFanin->nFanouts ); + pFanin->Fanios[pFanin->nFanins + pFanin->iFanout++] = + pObj->Fanios[pObj->iFanin++] = pObj->hHandle - pFanin->hHandle; +} + +/**Function************************************************************* + + Synopsis [Creates logic network isomorphic to the given AIG.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Frc_Man_t * Frc_ManStartSimple( Gia_Man_t * pGia ) { - For_Man_t * p; - p = ABC_CALLOC( For_Man_t, 1 ); - p->pGia = pGia; - p->nObjs = Gia_ManObjNum(pGia); - p->pPlace = ABC_ALLOC( int, p->nObjs ); - p->piNext = ABC_ALLOC( int, p->nObjs ); - p->piRoot = ABC_ALLOC( int, p->nObjs ); - p->plEdge = ABC_ALLOC( float, p->nObjs ); - p->pNodes = ABC_ALLOC( For_Obj_t, p->nObjs ); + Frc_Man_t * p; + Frc_Obj_t * pObjLog, * pFanLog; + Gia_Obj_t * pObj;//, * pObjRi, * pObjRo; + int i, nNodes, hHandle = 0; + // prepare the AIG + Gia_ManCreateRefs( pGia ); + // create logic network + p = ABC_CALLOC( Frc_Man_t, 1 ); + p->pGia = pGia; + p->nRegs = Gia_ManRegNum(pGia); + p->vCis = Vec_IntAlloc( Gia_ManCiNum(pGia) ); + p->vCos = Vec_IntAlloc( Gia_ManCoNum(pGia) ); + p->nObjData = (sizeof(Frc_Obj_t) / 4) * Gia_ManObjNum(pGia) + 2 * (2 * Gia_ManAndNum(pGia) + Gia_ManCoNum(pGia)); + p->pObjData = ABC_CALLOC( int, p->nObjData ); + // create constant node + Gia_ManConst0(pGia)->Value = hHandle; + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 0; + pObjLog->nFanouts = Gia_ObjRefs( pGia, Gia_ManConst0(pGia) ); + // count objects + hHandle += Frc_ObjSize( pObjLog ); + nNodes = 1; + p->nObjs++; + // create the PIs + Gia_ManForEachCi( pGia, pObj, i ) + { + // create PI object + pObj->Value = hHandle; + Vec_IntPush( p->vCis, hHandle ); + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 0; + pObjLog->nFanouts = Gia_ObjRefs( pGia, pObj ); + pObjLog->fCi = 0; + // count objects + hHandle += Frc_ObjSize( pObjLog ); + p->nObjs++; + } + // create internal nodes + Gia_ManForEachAnd( pGia, pObj, i ) + { + assert( Gia_ObjRefs( pGia, pObj ) > 0 ); + // create node object + pObj->Value = hHandle; + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 2; + pObjLog->nFanouts = Gia_ObjRefs( pGia, pObj ); + // add fanins + pFanLog = Frc_ManObj( p, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); + Frc_ObjAddFanin( pObjLog, pFanLog ); + pFanLog = Frc_ManObj( p, Gia_ObjValue(Gia_ObjFanin1(pObj)) ); + Frc_ObjAddFanin( pObjLog, pFanLog ); + // count objects + hHandle += Frc_ObjSize( pObjLog ); + nNodes++; + p->nObjs++; + } + // create the POs + Gia_ManForEachCo( pGia, pObj, i ) + { + // create PO object + pObj->Value = hHandle; + Vec_IntPush( p->vCos, hHandle ); + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 1; + pObjLog->nFanouts = 0; + pObjLog->fCo = 1; + // add fanins + pFanLog = Frc_ManObj( p, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); + Frc_ObjAddFanin( pObjLog, pFanLog ); + // count objects + hHandle += Frc_ObjSize( pObjLog ); + p->nObjs++; + } + // connect registers +// Gia_ManForEachRiRo( pGia, pObjRi, pObjRo, i ) +// Frc_ObjAddFanin( Frc_ManObj(p,Gia_ObjValue(pObjRo)), Frc_ManObj(p,Gia_ObjValue(pObjRi)) ); + assert( nNodes == Frc_ManNodeNum(p) ); + assert( hHandle == p->nObjData ); + if ( hHandle != p->nObjData ) + printf( "Frc_ManStartSimple(): Fatal error in internal representation.\n" ); + // make sure the fanin/fanout counters are correct + Gia_ManForEachObj( pGia, pObj, i ) + { + if ( !~Gia_ObjValue(pObj) ) + continue; + pObjLog = Frc_ManObj( p, Gia_ObjValue(pObj) ); + assert( pObjLog->nFanins == pObjLog->iFanin ); + assert( pObjLog->nFanouts == pObjLog->iFanout ); + pObjLog->iFanin = pObjLog->iFanout = 0; + } + ABC_FREE( pGia->pRefs ); return p; } /**Function************************************************************* - Synopsis [] + Synopsis [Collect the fanin IDs.] Description [] @@ -97,19 +255,50 @@ For_Man_t * For_ManStart( Gia_Man_t * pGia ) SeeAlso [] ***********************************************************************/ -void For_ManStop( For_Man_t * p ) +void Frc_ManCollectSuper_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper, Vec_Int_t * vVisit ) { - ABC_FREE( p->pPlace ); - ABC_FREE( p->piNext ); - ABC_FREE( p->piRoot ); - ABC_FREE( p->plEdge ); - ABC_FREE( p->pNodes ); - ABC_FREE( p ); + if ( pObj->fMark1 ) + return; + pObj->fMark1 = 1; + Vec_IntPush( vVisit, Gia_ObjId(p, pObj) ); + if ( pObj->fMark0 ) + { + Vec_IntPush( vSuper, Gia_ObjId(p, pObj) ); + return; + } + assert( Gia_ObjIsAnd(pObj) ); + Frc_ManCollectSuper_rec( p, Gia_ObjFanin0(pObj), vSuper, vVisit ); + Frc_ManCollectSuper_rec( p, Gia_ObjFanin1(pObj), vSuper, vVisit ); + } /**Function************************************************************* - Synopsis [Derives random ordering of nodes.] + Synopsis [Collect the fanin IDs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Frc_ManCollectSuper( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper, Vec_Int_t * vVisit ) +{ + int Entry, i; + Vec_IntClear( vSuper ); + Vec_IntClear( vVisit ); + assert( pObj->fMark0 == 1 ); + pObj->fMark0 = 0; + Frc_ManCollectSuper_rec( p, pObj, vSuper, vVisit ); + pObj->fMark0 = 1; + Vec_IntForEachEntry( vVisit, Entry, i ) + Gia_ManObj(p, Entry)->fMark1 = 0; +} + +/**Function************************************************************* + + Synopsis [Assigns references while removing the MUX/XOR ones.] Description [] @@ -118,24 +307,44 @@ void For_ManStop( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -void For_ManSetInitPlaceRandom( For_Man_t * p ) +void Frc_ManCreateRefsSpecial( Gia_Man_t * p ) { - int i, Temp, iNext; - Aig_ManRandom( 1 ); - for ( i = 0; i < p->nObjs; i++ ) - p->pPlace[i] = i; - for ( i = 0; i < p->nObjs; i++ ) + Gia_Obj_t * pObj, * pFan0, * pFan1; + Gia_Obj_t * pObjC, * pObjD0, * pObjD1; + int i; + assert( p->pRefs == NULL ); + Gia_ManCleanMark0( p ); + Gia_ManCreateRefs( p ); + Gia_ManForEachAnd( p, pObj, i ) { - iNext = Aig_ManRandom( 0 ) % p->nObjs; - Temp = p->pPlace[i]; - p->pPlace[i] = p->pPlace[iNext]; - p->pPlace[iNext] = Temp; + assert( pObj->fMark0 == 0 ); + pFan0 = Gia_ObjFanin0(pObj); + pFan1 = Gia_ObjFanin1(pObj); + // skip nodes whose fanins are PIs or are already marked + if ( Gia_ObjIsCi(pFan0) || pFan0->fMark0 || + Gia_ObjIsCi(pFan1) || pFan1->fMark0 ) + continue; + // skip nodes that are not MUX type + if ( !Gia_ObjIsMuxType(pObj) ) + continue; + // the node is MUX type, mark it and its fanins + pObj->fMark0 = 1; + pFan0->fMark0 = 1; + pFan1->fMark0 = 1; + // deref the control + pObjC = Gia_ObjRecognizeMux( pObj, &pObjD1, &pObjD0 ); + Gia_ObjRefDec( p, Gia_Regular(pObjC) ); + if ( Gia_Regular(pObjD0) == Gia_Regular(pObjD1) ) + Gia_ObjRefDec( p, Gia_Regular(pObjD0) ); } + Gia_ManForEachAnd( p, pObj, i ) + assert( Gia_ObjRefs(p, pObj) > 0 ); + Gia_ManCleanMark0( p ); } /**Function************************************************************* - Synopsis [] + Synopsis [Assigns references while removing the MUX/XOR ones.] Description [] @@ -144,39 +353,196 @@ void For_ManSetInitPlaceRandom( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -void For_ManSetInitPlaceDfs_rec( For_Man_t * p, Gia_Obj_t * pObj, int fRev ) +void Frc_ManTransformRefs( Gia_Man_t * p, int * pnObjs, int * pnFanios ) { - if ( pObj->fMark0 ) - return; - pObj->fMark0 = 1; - if ( Gia_ObjIsCi(pObj) || Gia_ObjIsConst0(pObj) ) + Vec_Int_t * vSuper, * vVisit; + Gia_Obj_t * pObj, * pFanin; + int i, k, Counter; + assert( p->pRefs != NULL ); + + // mark nodes to be used in the logic network + Gia_ManCleanMark0( p ); + Gia_ManConst0(p)->fMark0 = 1; + // mark the inputs + Gia_ManForEachCi( p, pObj, i ) + pObj->fMark0 = 1; + // mark those nodes that have ref count more than 1 + Gia_ManForEachAnd( p, pObj, i ) + pObj->fMark0 = (Gia_ObjRefs(p, pObj) > 1); + // mark the output drivers + Gia_ManForEachCoDriver( p, pObj, i ) + pObj->fMark0 = 1; + + // count the number of nodes + Counter = 0; + Gia_ManForEachObj( p, pObj, i ) + Counter += pObj->fMark0; + *pnObjs = Counter + Gia_ManCoNum(p); + + // reset the references + ABC_FREE( p->pRefs ); + p->pRefs = ABC_CALLOC( int, Gia_ManObjNum(p) ); + // reference from internal nodes + Counter = 0; + vSuper = Vec_IntAlloc( 100 ); + vVisit = Vec_IntAlloc( 100 ); + Gia_ManCleanMark1( p ); + Gia_ManForEachAnd( p, pObj, i ) { - p->pPlace[ Gia_ObjId(p->pGia, pObj) ] = p->iObj++; - return; + if ( pObj->fMark0 == 0 ) + continue; + Frc_ManCollectSuper( p, pObj, vSuper, vVisit ); + Gia_ManForEachObjVec( vSuper, p, pFanin, k ) + { + assert( pFanin->fMark0 ); + Gia_ObjRefInc( p, pFanin ); + } + Counter += Vec_IntSize( vSuper ); } - if ( Gia_ObjIsCo(pObj) ) + Gia_ManCheckMark1( p ); + Vec_IntFree( vSuper ); + Vec_IntFree( vVisit ); + // reference from outputs + Gia_ManForEachCoDriver( p, pObj, i ) { - For_ManSetInitPlaceDfs_rec( p, Gia_ObjFanin0(pObj), fRev ); - p->pPlace[ Gia_ObjId(p->pGia, pObj) ] = p->iObj++; - return; + assert( pObj->fMark0 ); + Gia_ObjRefInc( p, pObj ); } - assert( Gia_ObjIsAnd(pObj) ); - if ( fRev ) + *pnFanios = Counter + Gia_ManCoNum(p); +} + +/**Function************************************************************* + + Synopsis [Creates logic network isomorphic to the given AIG.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Frc_Man_t * Frc_ManStart( Gia_Man_t * pGia ) +{ + Frc_Man_t * p; + Frc_Obj_t * pObjLog, * pFanLog; + Gia_Obj_t * pObj, * pFanin;//, * pObjRi, * pObjRo; + Vec_Int_t * vSuper, * vVisit; + int nObjs, nFanios, nNodes = 0; + int i, k, hHandle = 0; + // prepare the AIG +// Gia_ManCreateRefs( pGia ); + Frc_ManCreateRefsSpecial( pGia ); + Frc_ManTransformRefs( pGia, &nObjs, &nFanios ); + Gia_ManFillValue( pGia ); + // create logic network + p = ABC_CALLOC( Frc_Man_t, 1 ); + p->pGia = pGia; + p->nRegs = Gia_ManRegNum(pGia); + p->vCis = Vec_IntAlloc( Gia_ManCiNum(pGia) ); + p->vCos = Vec_IntAlloc( Gia_ManCoNum(pGia) ); + p->nObjData = (sizeof(Frc_Obj_t) / 4) * nObjs + 2 * nFanios; + p->pObjData = ABC_CALLOC( int, p->nObjData ); + // create constant node + Gia_ManConst0(pGia)->Value = hHandle; + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 0; + pObjLog->nFanouts = Gia_ObjRefs( pGia, Gia_ManConst0(pGia) ); + // count objects + hHandle += Frc_ObjSize( pObjLog ); + nNodes++; + p->nObjs++; + // create the PIs + Gia_ManForEachCi( pGia, pObj, i ) { - For_ManSetInitPlaceDfs_rec( p, Gia_ObjFanin1(pObj), fRev ); - For_ManSetInitPlaceDfs_rec( p, Gia_ObjFanin0(pObj), fRev ); + // create PI object + pObj->Value = hHandle; + Vec_IntPush( p->vCis, hHandle ); + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 0; + pObjLog->nFanouts = Gia_ObjRefs( pGia, pObj ); + pObjLog->fCi = 1; + // count objects + hHandle += Frc_ObjSize( pObjLog ); + p->nObjs++; } - else + // create internal nodes + vSuper = Vec_IntAlloc( 100 ); + vVisit = Vec_IntAlloc( 100 ); + Gia_ManForEachAnd( pGia, pObj, i ) { - For_ManSetInitPlaceDfs_rec( p, Gia_ObjFanin0(pObj), fRev ); - For_ManSetInitPlaceDfs_rec( p, Gia_ObjFanin1(pObj), fRev ); + if ( pObj->fMark0 == 0 ) + { + assert( Gia_ObjRefs( pGia, pObj ) == 0 ); + continue; + } + assert( Gia_ObjRefs( pGia, pObj ) > 0 ); + Frc_ManCollectSuper( pGia, pObj, vSuper, vVisit ); + // create node object + pObj->Value = hHandle; + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = Vec_IntSize( vSuper ); + pObjLog->nFanouts = Gia_ObjRefs( pGia, pObj ); + // add fanins + Gia_ManForEachObjVec( vSuper, pGia, pFanin, k ) + { + pFanLog = Frc_ManObj( p, Gia_ObjValue(pFanin) ); + Frc_ObjAddFanin( pObjLog, pFanLog ); + } + // count objects + hHandle += Frc_ObjSize( pObjLog ); + nNodes++; + p->nObjs++; + } + Vec_IntFree( vSuper ); + Vec_IntFree( vVisit ); + // create the POs + Gia_ManForEachCo( pGia, pObj, i ) + { + // create PO object + pObj->Value = hHandle; + Vec_IntPush( p->vCos, hHandle ); + pObjLog = Frc_ManObj( p, hHandle ); + pObjLog->hHandle = hHandle; + pObjLog->nFanins = 1; + pObjLog->nFanouts = 0; + pObjLog->fCo = 1; + // add fanins + pFanLog = Frc_ManObj( p, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); + Frc_ObjAddFanin( pObjLog, pFanLog ); + // count objects + hHandle += Frc_ObjSize( pObjLog ); + p->nObjs++; } - p->pPlace[ Gia_ObjId(p->pGia, pObj) ] = p->iObj++; + // connect registers +// Gia_ManForEachRiRo( pGia, pObjRi, pObjRo, i ) +// Frc_ObjAddFanin( Frc_ManObj(p,Gia_ObjValue(pObjRo)), Frc_ManObj(p,Gia_ObjValue(pObjRi)) ); + Gia_ManCleanMark0( pGia ); + assert( nNodes == Frc_ManNodeNum(p) ); + assert( nObjs == p->nObjs ); + assert( hHandle == p->nObjData ); + if ( hHandle != p->nObjData ) + printf( "Frc_ManStart(): Fatal error in internal representation.\n" ); + // make sure the fanin/fanout counters are correct + Gia_ManForEachObj( pGia, pObj, i ) + { + if ( !~Gia_ObjValue(pObj) ) + continue; + pObjLog = Frc_ManObj( p, Gia_ObjValue(pObj) ); + assert( pObjLog->nFanins == pObjLog->iFanin ); + assert( pObjLog->nFanouts == pObjLog->iFanout ); + pObjLog->iFanin = pObjLog->iFanout = 0; + } + ABC_FREE( pGia->pRefs ); + return p; } /**Function************************************************************* - Synopsis [Derives DFS ordering of nodes.] + Synopsis [Creates logic network isomorphic to the given AIG.] Description [] @@ -185,25 +551,25 @@ void For_ManSetInitPlaceDfs_rec( For_Man_t * p, Gia_Obj_t * pObj, int fRev ) SeeAlso [] ***********************************************************************/ -void For_ManSetInitPlaceDfs( For_Man_t * p, int fRev ) +void Frc_ManPrintStats( Frc_Man_t * p ) { - Gia_Obj_t * pObj; - int i; - p->iObj = 0; - Gia_ManCleanMark0( p->pGia ); - For_ManSetInitPlaceDfs_rec( p, Gia_ManConst0(p->pGia), fRev ); - Gia_ManForEachCo( p->pGia, pObj, i ) - For_ManSetInitPlaceDfs_rec( p, pObj, fRev ); - Gia_ManForEachCi( p->pGia, pObj, i ) - if ( pObj->fMark0 == 0 ) - For_ManSetInitPlaceDfs_rec( p, pObj, fRev ); - assert( p->iObj == p->nObjs ); - Gia_ManCleanMark0( p->pGia ); +// if ( p->pName ) +// printf( "%8s : ", p->pName ); + printf( "i/o =%7d/%7d ", Frc_ManPiNum(p), Frc_ManPoNum(p) ); + if ( Frc_ManRegNum(p) ) + printf( "ff =%7d ", Frc_ManRegNum(p) ); + printf( "node =%8d ", Frc_ManNodeNum(p) ); + printf( "obj =%8d ", Frc_ManObjNum(p) ); +// printf( "lev =%5d ", Frc_ManLevelNum(p) ); +// printf( "cut =%5d ", Frc_ManCrossCut(p) ); + printf( "mem =%5.2f Mb", 4.0*p->nObjData/(1<<20) ); +// printf( "obj =%5d ", Frc_ManObjNum(p) ); + printf( "\n" ); } /**Function************************************************************* - Synopsis [Computes span for the given placement.] + Synopsis [Creates logic network isomorphic to the given AIG.] Description [] @@ -212,29 +578,72 @@ void For_ManSetInitPlaceDfs( For_Man_t * p, int fRev ) SeeAlso [] ***********************************************************************/ -double For_ManGetEdgeSpan( For_Man_t * p ) +void Frc_ManStop( Frc_Man_t * p ) { - double Result = 0.0; - Gia_Obj_t * pObj; - int i, Diff; - Gia_ManForEachAnd( p->pGia, pObj, i ) + Vec_IntFree( p->vCis ); + Vec_IntFree( p->vCos ); + ABC_FREE( p->pObjData ); + ABC_FREE( p ); +} + + +/**Function************************************************************* + + Synopsis [Computes cross cut size for the given order of POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Frc_ManCrossCut_rec( Frc_Man_t * p, Frc_Obj_t * pObj ) +{ + assert( pObj->iFanout > 0 ); + if ( pObj->iFanout-- == pObj->nFanouts ) { - Diff = Gia_ObjPlace(p, pObj) - Gia_ObjPlaceFanin0(p, pObj); - Result += (double)ABC_ABS(Diff); - Diff = Gia_ObjPlace(p, pObj) - Gia_ObjPlaceFanin1(p, pObj); - Result += (double)ABC_ABS(Diff); + Frc_Obj_t * pFanin; + int i; + p->nCutCur++; + p->nCutMax = ABC_MAX( p->nCutMax, p->nCutCur ); + if ( !Frc_ObjIsCi(pObj) ) + Frc_ObjForEachFanin( pObj, pFanin, i ) + p->nCutCur -= Frc_ManCrossCut_rec( p, pFanin ); } - Gia_ManForEachCo( p->pGia, pObj, i ) + return pObj->iFanout == 0; +} + +/**Function************************************************************* + + Synopsis [Computes cross cut size for the given order of POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Frc_ManCrossCut2_rec( Frc_Man_t * p, Frc_Obj_t * pObj ) +{ + assert( pObj->iFanout > 0 ); + if ( pObj->iFanout-- == pObj->nFanouts ) { - Diff = Gia_ObjPlace(p, pObj) - Gia_ObjPlaceFanin0(p, pObj); - Result += (double)ABC_ABS(Diff); + Frc_Obj_t * pFanin; + int i; + p->nCutCur++; + p->nCutMax = ABC_MAX( p->nCutMax, p->nCutCur ); + if ( !Frc_ObjIsCi(pObj) ) + Frc_ObjForEachFaninReverse( pObj, pFanin, i ) + p->nCutCur -= Frc_ManCrossCut2_rec( p, pFanin ); } - return Result; + return pObj->iFanout == 0; } /**Function************************************************************* - Synopsis [Computes max cut of the given placement.] + Synopsis [Computes cross cut size for the given order of POs.] Description [] @@ -243,68 +652,138 @@ double For_ManGetEdgeSpan( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -int For_ManGetMaxCut( For_Man_t * p ) +int Frc_ManCrossCut( Frc_Man_t * p, Vec_Int_t * vOrder, int fReverse ) { - Gia_Obj_t * pObj; - int i, iObj, iFan, * pTemp; - int nCutCut, nCutMax; - pTemp = ABC_CALLOC( int, p->nObjs ); - Gia_ManForEachAnd( p->pGia, pObj, i ) + Frc_Obj_t * pObj; + int i; + assert( Vec_IntSize(vOrder) == Frc_ManCoNum(p) ); + p->nCutCur = 0; + p->nCutMax = 0; + Frc_ManForEachObj( p, pObj, i ) + pObj->iFanout = pObj->nFanouts; + Frc_ManForEachObjVec( vOrder, p, pObj, i ) { - iObj = Gia_ObjPlace(p, pObj); - iFan = Gia_ObjPlaceFanin0(p, pObj); - if ( iObj < iFan ) - { - pTemp[iObj]++; - pTemp[iFan]--; - } - else - { - pTemp[iObj]--; - pTemp[iFan]++; - } - iObj = Gia_ObjPlace(p, pObj); - iFan = Gia_ObjPlaceFanin1(p, pObj); - if ( iObj < iFan ) - { - pTemp[iObj]++; - pTemp[iFan]--; - } + assert( Frc_ObjIsCo(pObj) ); + if ( fReverse ) + p->nCutCur -= Frc_ManCrossCut2_rec( p, Frc_ObjFanin(pObj,0) ); else - { - pTemp[iObj]--; - pTemp[iFan]++; - } + p->nCutCur -= Frc_ManCrossCut_rec( p, Frc_ObjFanin(pObj,0) ); } - Gia_ManForEachCo( p->pGia, pObj, i ) + assert( p->nCutCur == 0 ); +// Frc_ManForEachObj( p, pObj, i ) +// assert( pObj->iFanout == 0 ); + return p->nCutMax; +} + +/**Function************************************************************* + + Synopsis [Collects CO handles.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Vec_Int_t * Frc_ManCollectCos( Frc_Man_t * p ) +{ + Vec_Int_t * vCoOrder; + Frc_Obj_t * pObj; + int i; + vCoOrder = Vec_IntAlloc( Frc_ManCoNum(p) ); + Frc_ManForEachCo( p, pObj, i ) + Vec_IntPush( vCoOrder, pObj->hHandle ); + return vCoOrder; +} + +/**Function************************************************************* + + Synopsis [Computes cross cut size for the given order of POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Frc_ManCrossCutTest( Frc_Man_t * p, Vec_Int_t * vOrderInit ) +{ + Vec_Int_t * vOrder; + int clk = clock(); + vOrder = vOrderInit? vOrderInit : Frc_ManCollectCos( p ); + printf( "CrossCut = %6d\n", Frc_ManCrossCut( p, vOrder, 0 ) ); + printf( "CrossCut = %6d\n", Frc_ManCrossCut( p, vOrder, 1 ) ); + Vec_IntReverseOrder( vOrder ); + printf( "CrossCut = %6d\n", Frc_ManCrossCut( p, vOrder, 0 ) ); + printf( "CrossCut = %6d\n", Frc_ManCrossCut( p, vOrder, 1 ) ); + Vec_IntReverseOrder( vOrder ); + if ( vOrder != vOrderInit ) + Vec_IntFree( vOrder ); +// ABC_PRT( "Time", clock() - clk ); +} + + + +/**Function************************************************************* + + Synopsis [Generates random placement.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Frc_ManPlaceRandom( Frc_Man_t * p ) +{ + Frc_Obj_t * pThis; + int * pPlacement; + int i, h, Temp, iNext, Counter; + pPlacement = ABC_ALLOC( int, p->nObjs ); + for ( i = 0; i < p->nObjs; i++ ) + pPlacement[i] = i; + for ( i = 0; i < p->nObjs; i++ ) { - iObj = Gia_ObjPlace(p, pObj); - iFan = Gia_ObjPlaceFanin0(p, pObj); - if ( iObj < iFan ) - { - pTemp[iObj]++; - pTemp[iFan]--; - } - else - { - pTemp[iObj]--; - pTemp[iFan]++; - } + iNext = Aig_ManRandom( 0 ) % p->nObjs; + Temp = pPlacement[i]; + pPlacement[i] = pPlacement[iNext]; + pPlacement[iNext] = Temp; } - nCutCut = nCutMax = 0; - for ( i = 0; i < p->nObjs; i++ ) + Counter = 0; + Frc_ManForEachObj( p, pThis, h ) + pThis->pPlace = pPlacement[Counter++]; + ABC_FREE( pPlacement ); +} + +/**Function************************************************************* + + Synopsis [Shuffles array of random integers.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Frc_ManArrayShuffle( Vec_Int_t * vArray ) +{ + int i, iNext, Temp; + for ( i = 0; i < vArray->nSize; i++ ) { - nCutCut += pTemp[i]; - nCutMax = ABC_MAX( nCutCut, nCutMax ); + iNext = Aig_ManRandom( 0 ) % vArray->nSize; + Temp = vArray->pArray[i]; + vArray->pArray[i] = vArray->pArray[iNext]; + vArray->pArray[iNext] = Temp; } - ABC_FREE( pTemp ); - assert( nCutCut == 0 ); - return nCutMax; } /**Function************************************************************* - Synopsis [Computes hyper-edge centers.] + Synopsis [Computes cross cut size for the given order of POs.] Description [] @@ -313,31 +792,23 @@ int For_ManGetMaxCut( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -void For_ManEdgeCenters( For_Man_t * p ) +void Frc_ManPlaceDfs_rec( Frc_Man_t * p, Frc_Obj_t * pObj, int * piPlace ) { - Gia_Obj_t * pObj; - int i; - memset( p->plEdge, 0, sizeof(float) * p->nObjs ); - Gia_ManForEachObj( p->pGia, pObj, i ) + assert( pObj->iFanout > 0 ); + if ( pObj->iFanout-- == pObj->nFanouts ) { - p->plEdge[i] = Gia_ObjPlace(p, pObj); - if ( Gia_ObjIsAnd(pObj) ) - { - p->plEdge[Gia_ObjFaninId0p(p->pGia, pObj)] += Gia_ObjPlace(p, pObj); - p->plEdge[Gia_ObjFaninId1p(p->pGia, pObj)] += Gia_ObjPlace(p, pObj); - } - else if ( Gia_ObjIsCo(pObj) ) - { - p->plEdge[Gia_ObjFaninId0p(p->pGia, pObj)] += Gia_ObjPlace(p, pObj); - } + Frc_Obj_t * pFanin; + int i; + if ( !Frc_ObjIsCi(pObj) ) + Frc_ObjForEachFanin( pObj, pFanin, i ) + Frc_ManPlaceDfs_rec( p, pFanin, piPlace ); + pObj->pPlace = (*piPlace)++; } - Gia_ManForEachObj( p->pGia, pObj, i ) - p->plEdge[i] /= 1.0 + Gia_ObjRefs( p->pGia, pObj ); } /**Function************************************************************* - Synopsis [Computes object centers.] + Synopsis [Generates DFS placement.] Description [] @@ -346,30 +817,156 @@ void For_ManEdgeCenters( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -void For_ManObjCenters( For_Man_t * p ) +void Frc_ManPlaceDfs( Frc_Man_t * p, Vec_Int_t * vCoOrder ) { - Gia_Obj_t * pObj; - int i; - Gia_ManForEachObj( p->pGia, pObj, i ) + Frc_Obj_t * pObj; + int i, nPlaces = 0; + Frc_ManForEachObj( p, pObj, i ) { - p->pNodes[i].lNode = Gia_ObjEdge(p, pObj); - if ( Gia_ObjIsAnd(pObj) ) + pObj->iFanout = pObj->nFanouts; + if ( pObj->nFanouts == 0 && !Frc_ObjIsCo(pObj) ) + pObj->pPlace = nPlaces++; + } + Frc_ManForEachObjVec( vCoOrder, p, pObj, i ) + { + assert( Frc_ObjIsCo(pObj) ); + Frc_ManPlaceDfs_rec( p, Frc_ObjFanin(pObj,0), &nPlaces ); + pObj->pPlace = nPlaces++; + } + assert( nPlaces == p->nObjs ); +} + +/**Function************************************************************* + + Synopsis [Generates DFS placement by trying both orders.] + + Description [Returns the cross cut size of the best order. ] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Frc_ManPlaceDfsBoth( Frc_Man_t * p, Vec_Int_t * vCoOrder, int * piCutSize2 ) +{ + int nCutStart1, nCutStart2; + nCutStart1 = Frc_ManCrossCut( p, vCoOrder, 0 ); + Vec_IntReverseOrder( vCoOrder ); + nCutStart2 = Frc_ManCrossCut( p, vCoOrder, 0 ); + if ( nCutStart1 <= nCutStart2 ) + { + Vec_IntReverseOrder( vCoOrder ); // undo + Frc_ManPlaceDfs( p, vCoOrder ); + *piCutSize2 = nCutStart2; + return nCutStart1; + } + else + { + Frc_ManPlaceDfs( p, vCoOrder ); + Vec_IntReverseOrder( vCoOrder ); // undo + *piCutSize2 = nCutStart1; + return nCutStart2; + } +} + +/**Function************************************************************* + + Synopsis [Performs iterative refinement of the given placement.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Frc_ManPlacementRefine( Frc_Man_t * p, int nIters, int fVerbose ) +{ + int fRandomize = 0; + Vec_Int_t * vCoOrder; + Frc_Obj_t * pThis, * pNext; + double CostThis, CostPrev; + float * pVertX, VertX; + int * pPermX, * pHandles; + int k, h, Iter, iMinX, iMaxX, Counter, nCutStart, nCutCur, nCutCur2, nCutPrev; + int clk = clock(), clk2, clk2Total = 0; + // create starting one-dimensional placement + vCoOrder = Frc_ManCollectCos( p ); + if ( fRandomize ) + Frc_ManArrayShuffle( vCoOrder ); + nCutStart = Frc_ManPlaceDfsBoth( p, vCoOrder, &nCutCur2 ); + // refine placement + CostPrev = 0.0; + nCutPrev = nCutStart; + pHandles = ABC_ALLOC( int, p->nObjs ); + pVertX = ABC_ALLOC( float, p->nObjs ); + for ( Iter = 0; Iter < nIters; Iter++ ) + { + // compute centers of hyperedges + CostThis = 0.0; + Frc_ManForEachObj( p, pThis, h ) + { + iMinX = iMaxX = pThis->pPlace; + Frc_ObjForEachFanout( pThis, pNext, k ) + { + iMinX = ABC_MIN( iMinX, pNext->pPlace ); + iMaxX = ABC_MAX( iMaxX, pNext->pPlace ); + } + pThis->fEdgeCenter = 0.5 * (iMaxX + iMinX); + CostThis += (iMaxX - iMinX); + } + // compute new centers of objects + Counter = 0; + Frc_ManForEachObj( p, pThis, h ) { - p->pNodes[i].lNode += Gia_ObjEdgeFanin0(p, pObj); - p->pNodes[i].lNode += Gia_ObjEdgeFanin1(p, pObj); - p->pNodes[i].lNode /= 3.0; + VertX = pThis->fEdgeCenter; + Frc_ObjForEachFanin( pThis, pNext, k ) + VertX += pNext->fEdgeCenter; + pVertX[Counter] = VertX / (Frc_ObjFaninNum(pThis) + 1); + pHandles[Counter++] = h; } - else if ( Gia_ObjIsCo(pObj) ) + assert( Counter == Frc_ManObjNum(p) ); + // sort these numbers + clk2 = clock(); + pPermX = Gia_SortFloats( pVertX, pHandles, p->nObjs ); + clk2Total += clock() - clk2; + assert( pPermX == pHandles ); + Vec_IntClear( vCoOrder ); + for ( k = 0; k < p->nObjs; k++ ) { - p->pNodes[i].lNode += Gia_ObjEdgeFanin0(p, pObj); - p->pNodes[i].lNode /= 2.0; + pThis = Frc_ManObj( p, pPermX[k] ); + pThis->pPlace = k; + if ( Frc_ObjIsCo(pThis) ) + Vec_IntPush( vCoOrder, pThis->hHandle ); } +/* + printf( "Ordering of PIs:\n" ); + Frc_ManForEachCi( p, pThis, k ) + printf( "PI number = %7d. Object handle = %7d, Coordinate = %7d.\n", + k, pThis->hHandle, pThis->pPlace ); +*/ + nCutCur = Frc_ManPlaceDfsBoth( p, vCoOrder, &nCutCur2 ); + // evaluate cost + if ( fVerbose ) + { + printf( "%2d : Span = %e ", Iter+1, CostThis ); + printf( "Cut = %6d (%5.2f %%) CutR = %6d ", nCutCur, 100.0*(nCutStart-nCutCur)/nCutStart, nCutCur2 ); + ABC_PRTn( "Total", clock() - clk ); + ABC_PRT( "Sort", clk2Total ); +// Frc_ManCrossCutTest( p, vCoOrder ); + } +// if ( 1.0 * nCutPrev / nCutCur < 1.001 ) +// break; + nCutPrev = nCutCur; } + ABC_FREE( pHandles ); + ABC_FREE( pVertX ); + Vec_IntFree( vCoOrder ); } /**Function************************************************************* - Synopsis [Sorts objects by their new centers.] + Synopsis [Returns 1 if all fanouts are COsw.] Description [] @@ -378,65 +975,56 @@ void For_ManObjCenters( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -int For_ObjCompare( For_Obj_t ** pp0, For_Obj_t ** pp1 ) +int Frc_ObjFanoutsAreCos( Frc_Obj_t * pThis ) { - if ( (*pp0)->lNode < (*pp1)->lNode ) - return -1; - if ( (*pp0)->lNode > (*pp1)->lNode ) - return 1; - return 0; + Frc_Obj_t * pNext; + int i; + Frc_ObjForEachFanout( pThis, pNext, i ) + if ( !Frc_ObjIsCo(pNext) ) + return 0; + return 1; } /**Function************************************************************* - Synopsis [Sorts objects by their new centers.] + Synopsis [Computes the distances from the given set of objects.] - Description [] + Description [Returns one of the most distant objects.] SideEffects [] SeeAlso [] - + ***********************************************************************/ -void For_ManSortObjects( For_Man_t * p ) +void Frc_DumpGraphIntoFile( Frc_Man_t * p ) { - For_Obj_t * pNode, * pPrev; - Vec_Ptr_t * vArray; - int i, k, iPlace; - // link the nodes into lists by cost - memset( p->piRoot, 0xff, sizeof(int) * p->nObjs ); - for ( i = 0; i < p->nObjs; i++ ) + FILE * pFile; + Frc_Obj_t * pThis, * pNext; + int i, k, Counter = 0; + // assign numbers to CIs and internal nodes + Frc_ManForEachObj( p, pThis, i ) { - p->pNodes[i].iObj = i; - iPlace = (int)p->pNodes[i].lNode; - assert( iPlace >= 0 && iPlace < p->nObjs ); - p->piNext[i] = p->piRoot[iPlace]; - p->piRoot[iPlace] = i; + if ( i && ((Frc_ObjIsCi(pThis) && !Frc_ObjFanoutsAreCos(pThis)) || Frc_ObjIsNode(pThis)) ) + pThis->iFanin = Counter++; + else + pThis->iFanin = ~0; } - // reconstruct the order - p->iObj = 0; - pPrev = NULL; - vArray = Vec_PtrAlloc( 100 ); - for ( i = 0; i < p->nObjs; i++ ) + // assign numbers to all other nodes + pFile = fopen( "x\\large\\aig\\dg1.g", "w" ); + Frc_ManForEachObj( p, pThis, i ) { - Vec_PtrClear( vArray ); - for ( k = p->piRoot[i]; ~((unsigned)k); k = p->piNext[k] ) - Vec_PtrPush( vArray, p->pNodes + k ); - Vec_PtrSort( vArray, (int (*)())For_ObjCompare ); - Vec_PtrForEachEntry( vArray, pNode, k ) + Frc_ObjForEachFanout( pThis, pNext, k ) { - p->pPlace[ pNode->iObj ] = p->iObj++; - assert( !pPrev || pPrev->lNode <= pNode->lNode ); - pPrev = pNode; + if ( ~pThis->iFanin && ~pNext->iFanin ) + fprintf( pFile, "%d %d\n", pThis->iFanin, pNext->iFanin ); } } - Vec_PtrFree( vArray ); - assert( p->iObj == p->nObjs ); + fclose( pFile ); } /**Function************************************************************* - Synopsis [] + Synopsis [Experiment with the FORCE algorithm.] Description [] @@ -445,33 +1033,25 @@ void For_ManSortObjects( For_Man_t * p ) SeeAlso [] ***********************************************************************/ -void For_ManPlaceByForce( For_Man_t * p ) +void For_ManExperiment( Gia_Man_t * pGia, int nIters, int fClustered, int fVerbose ) { - int clk, Iter, fUseCut = 1; - double iCostThis, iCostPrev; - iCostThis = fUseCut? For_ManGetMaxCut(p) : For_ManGetEdgeSpan(p); - printf( "Init = %12.0f. \n", iCostThis ); - Iter = 0; - do { - Iter++; - iCostPrev = iCostThis; -clk = clock(); - For_ManEdgeCenters( p ); -//ABC_PRT( "Time", clock() - clk ); -clk = clock(); - For_ManObjCenters( p ); -//ABC_PRT( "Time", clock() - clk ); -clk = clock(); - For_ManSortObjects( p ); -//ABC_PRT( "Time", clock() - clk ); - iCostThis = fUseCut? For_ManGetMaxCut(p) : For_ManGetEdgeSpan(p); - printf( "%4d = %12.0f. \n", Iter, iCostThis ); - } while ( iCostPrev > iCostThis ); + Frc_Man_t * p; + Aig_ManRandom( 1 ); + if ( fClustered ) + p = Frc_ManStart( pGia ); + else + p = Frc_ManStartSimple( pGia ); +// Frc_DumpGraphIntoFile( p ); + if ( fVerbose ) + Frc_ManPrintStats( p ); +// Frc_ManCrossCutTest( p, NULL ); + Frc_ManPlacementRefine( p, nIters, fVerbose ); + Frc_ManStop( p ); } /**Function************************************************************* - Synopsis [] + Synopsis [Experiment with the FORCE algorithm.] Description [] @@ -480,51 +1060,40 @@ clk = clock(); SeeAlso [] ***********************************************************************/ -void For_ManExperiment( Gia_Man_t * pGia ) +void For_ManFileExperiment() { - For_Man_t * p; + FILE * pFile; + int * pBuffer; + int i, Size, Exp = 25; int clk = clock(); - p = For_ManStart( pGia ); - Gia_ManCreateRefs( pGia ); - - // use DSF order -clk = clock(); - For_ManSetInitPlaceDfs( p, 0 ); - printf( "Tot span = %12.0f ", For_ManGetEdgeSpan(p) ); - printf( "Max span = %8d ", For_ManGetMaxCut(p) ); -ABC_PRT( "Time", clock() - clk ); - -clk = clock(); - For_ManPlaceByForce( p ); -ABC_PRT( "Time", clock() - clk ); - // use modified DFS order -clk = clock(); - For_ManSetInitPlaceDfs( p, 1 ); - printf( "Tot span = %12.0f ", For_ManGetEdgeSpan(p) ); - printf( "Max span = %8d ", For_ManGetMaxCut(p) ); -ABC_PRT( "Time", clock() - clk ); + Size = (1 << Exp); + printf( "2^%d machine words (%d bytes).\n", Exp, sizeof(int) * Size ); -clk = clock(); - For_ManPlaceByForce( p ); -ABC_PRT( "Time", clock() - clk ); + pBuffer = ABC_ALLOC( int, Size ); + for ( i = 0; i < Size; i++ ) + pBuffer[i] = i; +ABC_PRT( "Fillup", clock() - clk ); - // use random order clk = clock(); - For_ManSetInitPlaceRandom( p ); - printf( "Tot span = %12.0f ", For_ManGetEdgeSpan(p) ); - printf( "Max span = %8d ", For_ManGetMaxCut(p) ); -ABC_PRT( "Time", clock() - clk ); + pFile = fopen( "test.txt", "rb" ); + fread( pBuffer, 1, sizeof(int) * Size, pFile ); + fclose( pFile ); +ABC_PRT( "Read ", clock() - clk ); clk = clock(); - For_ManPlaceByForce( p ); -ABC_PRT( "Time", clock() - clk ); - - For_ManStop( p ); + pFile = fopen( "test.txt", "wb" ); + fwrite( pBuffer, 1, sizeof(int) * Size, pFile ); + fclose( pFile ); +ABC_PRT( "Write ", clock() - clk ); +/* +2^25 machine words (134217728 bytes). +Fillup = 0.06 sec +Read = 0.08 sec +Write = 1.81 sec +*/ } //////////////////////////////////////////////////////////////////////// /// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - +////////////////////////////////////////////////////////////////////////
\ No newline at end of file diff --git a/src/aig/gia/giaMan.c b/src/aig/gia/giaMan.c index e6e45cb5..95bffee8 100644 --- a/src/aig/gia/giaMan.c +++ b/src/aig/gia/giaMan.c @@ -68,8 +68,13 @@ void Gia_ManStop( Gia_Man_t * p ) { Vec_IntFree( p->vCis ); Vec_IntFree( p->vCos ); + ABC_FREE( p->pCexComb ); + ABC_FREE( p->pIso ); + ABC_FREE( p->pMapping ); ABC_FREE( p->pFanData ); + ABC_FREE( p->pReprsOld ); ABC_FREE( p->pReprs ); + ABC_FREE( p->pNexts ); ABC_FREE( p->pName ); ABC_FREE( p->pRefs ); ABC_FREE( p->pLevels ); @@ -98,12 +103,16 @@ void Gia_ManPrintStats( Gia_Man_t * p ) printf( "ff =%7d ", Gia_ManRegNum(p) ); printf( "and =%8d ", Gia_ManAndNum(p) ); printf( "lev =%5d ", Gia_ManLevelNum(p) ); -// printf( "cut =%5d ", Gia_ManCrossCut(p) ); + printf( "cut =%5d ", Gia_ManCrossCut(p) ); printf( "mem =%5.2f Mb", 12.0*Gia_ManObjNum(p)/(1<<20) ); // printf( "obj =%5d ", Gia_ManObjNum(p) ); printf( "\n" ); // Gia_ManSatExperiment( p ); + if ( p->pReprs && p->pNexts ) + Gia_ManEquivPrintClasses( p, 0, 0.0 ); + if ( p->pMapping ) + Gia_ManPrintMappingStats( p ); } /**Function************************************************************* diff --git a/src/aig/gia/giaMap.c b/src/aig/gia/giaMap.c new file mode 100644 index 00000000..72bdb001 --- /dev/null +++ b/src/aig/gia/giaMap.c @@ -0,0 +1,305 @@ +/**CFile**************************************************************** + + FileName [giaMap.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Scalable AIG package.] + + Synopsis [Manipulation of mapping associated with the AIG.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: giaMap.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "gia.h" +#include "if.h" + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Load the network into FPGA manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManSetIfParsDefault( If_Par_t * pPars ) +{ +// extern void * Abc_FrameReadLibLut(); + // set defaults + memset( pPars, 0, sizeof(If_Par_t) ); + // user-controlable paramters +// pPars->nLutSize = -1; + pPars->nLutSize = 6; + pPars->nCutsMax = 8; + pPars->nFlowIters = 1; + pPars->nAreaIters = 2; + pPars->DelayTarget = -1; + pPars->Epsilon = (float)0.005; + pPars->fPreprocess = 1; + pPars->fArea = 0; + pPars->fFancy = 0; + pPars->fExpRed = 1; //// + pPars->fLatchPaths = 0; + pPars->fEdge = 1; + pPars->fPower = 0; + pPars->fCutMin = 0; + pPars->fSeqMap = 0; + pPars->fVerbose = 0; + // internal parameters + pPars->fTruth = 0; + pPars->nLatches = 0; + pPars->fLiftLeaves = 0; +// pPars->pLutLib = Abc_FrameReadLibLut(); + pPars->pLutLib = NULL; + pPars->pTimesArr = NULL; + pPars->pTimesArr = NULL; + pPars->pFuncCost = NULL; +} + +/**Function************************************************************* + + Synopsis [Load the network into FPGA manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +If_Man_t * Gia_ManToIf( Gia_Man_t * p, If_Par_t * pPars, Vec_Ptr_t * vAigToIf ) +{ +// extern Vec_Int_t * SGia_ManComputeSwitchProbs( Gia_Man_t * p, int nFrames, int nPref, int fProbOne ); +// Vec_Int_t * vSwitching = NULL, * vSwitching2 = NULL; +// float * pSwitching, * pSwitching2; + If_Man_t * pIfMan; + If_Obj_t * pIfObj; + Gia_Obj_t * pNode; + int i, clk = clock(); + Gia_ManLevelNum( p ); +/* + // set the number of registers (switch activity will be combinational) + Gia_ManSetRegNum( p, 0 ); + if ( pPars->fPower ) + { + vSwitching = SGia_ManComputeSwitchProbs( p, 48, 16, 0 ); + if ( pPars->fVerbose ) + { + ABC_PRT( "Computing switching activity", clock() - clk ); + } + pSwitching = (float *)vSwitching->pArray; + vSwitching2 = Vec_IntStart( Gia_ManObjNumMax(p) ); + pSwitching2 = (float *)vSwitching2->pArray; + } +*/ + // start the mapping manager and set its parameters + pIfMan = If_ManStart( pPars ); +// pIfMan->vSwitching = vSwitching2; + // load the AIG into the mapper + Gia_ManForEachObj( p, pNode, i ) + { + if ( Gia_ObjIsAnd(pNode) ) + pIfObj = If_ManCreateAnd( pIfMan, + If_NotCond( Vec_PtrEntry(vAigToIf, Gia_ObjFaninId0(pNode, i)), Gia_ObjFaninC0(pNode) ), + If_NotCond( Vec_PtrEntry(vAigToIf, Gia_ObjFaninId1(pNode, i)), Gia_ObjFaninC1(pNode) ) ); + else if ( Gia_ObjIsCi(pNode) ) + { + pIfObj = If_ManCreateCi( pIfMan ); + If_ObjSetLevel( pIfObj, Gia_ObjLevel(p,pNode) ); +// printf( "pi=%d ", pIfObj->Level ); + if ( pIfMan->nLevelMax < (int)pIfObj->Level ) + pIfMan->nLevelMax = (int)pIfObj->Level; + } + else if ( Gia_ObjIsCo(pNode) ) + { + pIfObj = If_ManCreateCo( pIfMan, If_NotCond( Vec_PtrEntry(vAigToIf, Gia_ObjFaninId0(pNode, i)), Gia_ObjFaninC0(pNode) ) ); +// printf( "po=%d ", pIfObj->Level ); + } + else if ( Gia_ObjIsConst0(pNode) ) + pIfObj = If_Not(If_ManConst1( pIfMan )); + else // add the node to the mapper + assert( 0 ); + // save the result + assert( Vec_PtrEntry(vAigToIf, i) == NULL ); + Vec_PtrWriteEntry( vAigToIf, i, pIfObj ); +// if ( vSwitching2 ) +// pSwitching2[pIfObj->Id] = pSwitching[pNode->Id]; +/* // set up the choice node + if ( Gia_ObjIsChoice( p, pNode ) ) + { + pIfMan->nChoices++; + for ( pPrev = pNode, pFanin = Gia_ObjEquiv(p, pNode); pFanin; pPrev = pFanin, pFanin = Gia_ObjEquiv(p, pFanin) ) + If_ObjSetChoice( pPrev->pData, pFanin->pData ); + If_ManCreateChoice( pIfMan, pNode->pData ); + } +// assert( If_ObjLevel(pIfObj) == Gia_ObjLevel(pNode) ); +*/ + } +// if ( vSwitching ) +// Vec_IntFree( vSwitching ); + return pIfMan; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int * Gia_ManFromIf( If_Man_t * pIfMan, Gia_Man_t * p, Vec_Ptr_t * vAigToIf ) +{ + int * pMapping, iOffset; + Vec_Ptr_t * vIfToAig; + Gia_Obj_t * pObj, * pObjRepr; + If_Obj_t * pIfObj; + If_Cut_t * pCutBest; + int i, k, j, nLeaves, * ppLeaves; + int nItems = 0; + assert( Gia_ManCiNum(p) == If_ManCiNum(pIfMan) ); + assert( Gia_ManCoNum(p) == If_ManCoNum(pIfMan) ); + assert( Gia_ManAndNum(p) == If_ManAndNum(pIfMan) ); + // create mapping of IF to AIG + vIfToAig = Vec_PtrStart( If_ManObjNum(pIfMan) ); + Gia_ManForEachObj( p, pObj, i ) + { + pIfObj = Vec_PtrEntry( vAigToIf, i ); + Vec_PtrWriteEntry( vIfToAig, pIfObj->Id, pObj ); + if ( !Gia_ObjIsAnd(pObj) || pIfObj->nRefs == 0 ) + continue; + nItems += 2 + If_CutLeaveNum( If_ObjCutBest(pIfObj) ); + } + // construct the network + pMapping = ABC_CALLOC( int, Gia_ManObjNum(p) + nItems ); + iOffset = Gia_ManObjNum(p); + Gia_ManForEachObj( p, pObj, i ) + { + pIfObj = Vec_PtrEntry( vAigToIf, i ); + if ( !Gia_ObjIsAnd(pObj) || pIfObj->nRefs == 0 ) + continue; + pCutBest = If_ObjCutBest( pIfObj ); + nLeaves = If_CutLeaveNum( pCutBest ); + ppLeaves = If_CutLeaves( pCutBest ); + // create node + k = iOffset; + pMapping[k++] = nLeaves; + for ( j = 0; j < nLeaves; j++ ) + { + pObjRepr = Vec_PtrEntry( vIfToAig, ppLeaves[j] ); + pMapping[k++] = Gia_ObjId( p, pObjRepr ); + } + pMapping[k++] = i; + pMapping[i] = iOffset; + iOffset = k; + } + assert( iOffset <= Gia_ManObjNum(p) + nItems ); + Vec_PtrFree( vIfToAig ); +// pNtk->pManTime = Tim_ManDup( pIfMan->pManTim, 0 ); + return pMapping; +} + +/**Function************************************************************* + + Synopsis [Interface with the FPGA mapping package.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_MappingIf( Gia_Man_t * p, If_Par_t * pPars ) +{ + If_Man_t * pIfMan; + Vec_Ptr_t * vAigToIf; + // set the arrival times + pPars->pTimesArr = ABC_ALLOC( float, Gia_ManCiNum(p) ); + memset( pPars->pTimesArr, 0, sizeof(float) * Gia_ManCiNum(p) ); + // translate into the mapper + vAigToIf = Vec_PtrStart( Gia_ManObjNum(p) ); + pIfMan = Gia_ManToIf( p, pPars, vAigToIf ); + if ( pIfMan == NULL ) + return 0; +// pIfMan->pManTim = Tim_ManDup( pManTime, 0 ); + if ( !If_ManPerformMapping( pIfMan ) ) + { + If_ManStop( pIfMan ); + return 0; + } + // transform the result of mapping into the new network + ABC_FREE( p->pMapping ); + p->pMapping = Gia_ManFromIf( pIfMan, p, vAigToIf ); +// if ( pPars->fBidec && pPars->nLutSize <= 8 ) +// Gia_ManBidecResyn( pNtk, 0 ); + If_ManStop( pIfMan ); + Vec_PtrFree( vAigToIf ); + return 1; +} + + +/**Function************************************************************* + + Synopsis [Prints mapping statistics.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManPrintMappingStats( Gia_Man_t * p ) +{ + int * pLevels; + int i, k, iFan, nLutSize = 0, nLuts = 0, nFanins = 0, LevelMax = 0; + if ( !p->pMapping ) + return; + pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_ManForEachGate( p, i ) + { + nLuts++; + nFanins += Gia_ObjGateSize(p, i); + nLutSize = ABC_MAX( nLutSize, Gia_ObjGateSize(p, i) ); + Gia_GateForEachFanin( p, i, iFan, k ) + pLevels[i] = ABC_MAX( pLevels[i], pLevels[iFan] ); + pLevels[i]++; + LevelMax = ABC_MAX( LevelMax, pLevels[i] ); + } + ABC_FREE( pLevels ); + printf( "mapping : " ); + printf( "%d=lut =%7d ", nLutSize, nLuts ); + printf( "edge =%8d ", nFanins ); + printf( "lev =%5d ", LevelMax ); + printf( "mem =%5.2f Mb", 4.0*(Gia_ManObjNum(p) + 2*nLuts + nFanins)/(1<<20) ); + printf( "\n" ); +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + diff --git a/src/aig/gia/giaScl.c b/src/aig/gia/giaScl.c index 3f72b0b9..9058af7d 100644 --- a/src/aig/gia/giaScl.c +++ b/src/aig/gia/giaScl.c @@ -30,7 +30,7 @@ /**Function************************************************************* - Synopsis [Returns the number of unmarked nodes.] + Synopsis [Marks unreachable internal nodes and returned their number.] Description [] @@ -45,13 +45,13 @@ int Gia_ManCombMarkUsed_rec( Gia_Man_t * p, Gia_Obj_t * pObj ) return 0; pObj->fMark0 = 0; assert( Gia_ObjIsAnd(pObj) ); - return Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin0(pObj) ) + - Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin1(pObj) ) + 1; + return 1 + Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin0(pObj) ) + + Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin1(pObj) ); } /**Function************************************************************* - Synopsis [Returns the number of unused nodes.] + Synopsis [Marks unreachable internal nodes and returned their number.] Description [] @@ -90,7 +90,7 @@ Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p ) /**Function************************************************************* - Synopsis [Marks CIs/COs reachable from POs.] + Synopsis [Marks CIs/COs/ANDs unreachable from POs.] Description [] @@ -99,29 +99,26 @@ Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -void Gia_ManSeqMarkUsed_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vRoots ) +int Gia_ManSeqMarkUsed_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vRoots ) { if ( !pObj->fMark0 ) - return; + return 0; pObj->fMark0 = 0; if ( Gia_ObjIsCo(pObj) ) - { - Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin0(pObj), vRoots ); - return; - } + return Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin0(pObj), vRoots ); if ( Gia_ObjIsRo(p, pObj) ) { Vec_IntPush( vRoots, Gia_ObjId(p, Gia_ObjRoToRi(p, pObj)) ); - return; + return 0; } assert( Gia_ObjIsAnd(pObj) ); - Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin0(pObj), vRoots ); - Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin1(pObj), vRoots ); + return 1 + Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin0(pObj), vRoots ) + + Gia_ManSeqMarkUsed_rec( p, Gia_ObjFanin1(pObj), vRoots ); } /**Function************************************************************* - Synopsis [Performs sequential cleanup.] + Synopsis [Marks CIs/COs/ANDs unreachable from POs.] Description [] @@ -130,19 +127,38 @@ void Gia_ManSeqMarkUsed_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vRoots SeeAlso [] ***********************************************************************/ -Gia_Man_t * Gia_ManSeqCleanup( Gia_Man_t * p ) +int Gia_ManSeqMarkUsed( Gia_Man_t * p ) { Vec_Int_t * vRoots; Gia_Obj_t * pObj; - int i; + int i, nNodes = 0; Gia_ManSetMark0( p ); Gia_ManConst0(p)->fMark0 = 0; Gia_ManForEachPi( p, pObj, i ) pObj->fMark0 = 0; + Gia_ManForEachPo( p, pObj, i ) + pObj->fMark0 = 0; vRoots = Gia_ManCollectPoIds( p ); Gia_ManForEachObjVec( vRoots, p, pObj, i ) - Gia_ManSeqMarkUsed_rec( p, pObj, vRoots ); + nNodes += Gia_ManSeqMarkUsed_rec( p, pObj, vRoots ); Vec_IntFree( vRoots ); + return nNodes; +} + +/**Function************************************************************* + + Synopsis [Performs sequential cleanup.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManSeqCleanup( Gia_Man_t * p ) +{ + Gia_ManSeqMarkUsed( p ); return Gia_ManDupMarked( p ); } diff --git a/src/aig/gia/giaSort.c b/src/aig/gia/giaSort.c index aec98fd8..8574297d 100644 --- a/src/aig/gia/giaSort.c +++ b/src/aig/gia/giaSort.c @@ -245,12 +245,15 @@ void minisat_sort3(float* array, int* perm, int size) SeeAlso [] ***********************************************************************/ -int * Gia_SortFloats( float * pArray, int nSize ) +int * Gia_SortFloats( float * pArray, int * pPerm, int nSize ) { - int i, * pPerm; - pPerm = ABC_ALLOC( int, nSize ); - for ( i = 0; i < nSize; i++ ) - pPerm[i] = i; + int i; + if ( pPerm == NULL ) + { + pPerm = ABC_ALLOC( int, nSize ); + for ( i = 0; i < nSize; i++ ) + pPerm[i] = i; + } minisat_sort3( pArray, pPerm, nSize ); // for ( i = 1; i < nSize; i++ ) // assert( pArray[i-1] <= pArray[i] ); diff --git a/src/aig/gia/giaUtil.c b/src/aig/gia/giaUtil.c index 64f191f1..cc1a3861 100644 --- a/src/aig/gia/giaUtil.c +++ b/src/aig/gia/giaUtil.c @@ -300,6 +300,34 @@ void Gia_ManCreateRefs( Gia_Man_t * p ) /**Function************************************************************* + Synopsis [Assigns references.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int * Gia_ManCreateMuxRefs( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj, * pCtrl, * pFan0, * pFan1; + int i, * pMuxRefs; + pMuxRefs = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_ManForEachObj( p, pObj, i ) + { + if ( Gia_ObjRecognizeExor( pObj, &pFan0, &pFan1 ) ) + continue; + if ( !Gia_ObjIsMuxType(pObj) ) + continue; + pCtrl = Gia_ObjRecognizeMux( pObj, &pFan0, &pFan1 ); + pMuxRefs[ Gia_ObjId(p, Gia_Regular(pCtrl)) ]++; + } + return pMuxRefs; +} + +/**Function************************************************************* + Synopsis [Computes the maximum frontier size.] Description [] @@ -549,6 +577,45 @@ Gia_Obj_t * Gia_ObjRecognizeMux( Gia_Obj_t * pNode, Gia_Obj_t ** ppNodeT, Gia_Ob return NULL; } + +/**Function************************************************************* + + Synopsis [Resimulates the counter-example.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Gia_ManVerifyCounterExample( Gia_Man_t * pAig, Gia_Cex_t * p, int fDoubleOuts ) +{ + Gia_Obj_t * pObj, * pObjRi, * pObjRo; + int RetValue, i, k, iBit = 0; + Gia_ManForEachRo( pAig, pObj, i ) + pObj->fMark0 = Aig_InfoHasBit(p->pData, iBit++); + for ( i = 0; i <= p->iFrame; i++ ) + { + Gia_ManForEachPi( pAig, pObj, k ) + pObj->fMark0 = Aig_InfoHasBit(p->pData, iBit++); + Gia_ManForEachAnd( pAig, pObj, k ) + pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & + (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj)); + Gia_ManForEachCo( pAig, pObj, k ) + pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj); + Gia_ManForEachRiRo( pAig, pObjRi, pObjRo, k ) + pObjRo->fMark0 = pObjRi->fMark0; + } + assert( iBit == p->nBits ); + if ( fDoubleOuts ) + RetValue = Gia_ManPo(pAig, 2*p->iPo)->fMark0 ^ Gia_ManPo(pAig, 2*p->iPo+1)->fMark0; + else + RetValue = Gia_ManPo(pAig, p->iPo)->fMark0; + Gia_ManCleanMark0(pAig); + return RetValue; +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/gia/module.make b/src/aig/gia/module.make index 7a68b554..4410b497 100644 --- a/src/aig/gia/module.make +++ b/src/aig/gia/module.make @@ -5,6 +5,8 @@ SRC += src/aig/gia/gia.c \ src/aig/gia/giaDfs.c \ src/aig/gia/giaDup.c \ src/aig/gia/giaEmbed.c \ + src/aig/gia/giaEnable.c \ + src/aig/gia/giaEquiv.c \ src/aig/gia/giaFanout.c \ src/aig/gia/giaForce.c \ src/aig/gia/giaFrames.c \ @@ -12,6 +14,7 @@ SRC += src/aig/gia/gia.c \ src/aig/gia/giaGlitch.c \ src/aig/gia/giaHash.c \ src/aig/gia/giaMan.c \ + src/aig/gia/giaMap.c \ src/aig/gia/giaScl.c \ src/aig/gia/giaSim.c \ src/aig/gia/giaSort.c \ diff --git a/src/aig/ioa/ioaReadAig.c b/src/aig/ioa/ioaReadAig.c index 11c866f4..b81414a5 100644 --- a/src/aig/ioa/ioaReadAig.c +++ b/src/aig/ioa/ioaReadAig.c @@ -341,6 +341,18 @@ Aig_Man_t * Ioa_ReadAiger( char * pFileName, int fCheck ) Aig_ManShortNames( pNew ); } */ + pCur = pSymbols; + if ( pCur + 1 < pContents + nFileSize && *pCur == 'c' ) + { + pCur++; + if ( *pCur == 'n' ) + { + pCur++; + // read model name + ABC_FREE( pNew->pName ); + pNew->pName = Aig_UtilStrsav( pCur ); + } + } // skipping the comments ABC_FREE( pContents ); diff --git a/src/aig/ioa/ioaWriteAig.c b/src/aig/ioa/ioaWriteAig.c index 3d37c0a7..42aa42db 100644 --- a/src/aig/ioa/ioaWriteAig.c +++ b/src/aig/ioa/ioaWriteAig.c @@ -375,10 +375,10 @@ void Ioa_WriteAiger( Aig_Man_t * pMan, char * pFileName, int fWriteSymbols, int } */ // write the comment - fprintf( pFile, "c\n" ); + fprintf( pFile, "c" ); if ( pMan->pName ) - fprintf( pFile, ".model %s\n", pMan->pName ); - fprintf( pFile, "This file was produced by the AIG package on %s\n", Ioa_TimeStamp() ); + fprintf( pFile, "n%s%c", pMan->pName, '\0' ); + fprintf( pFile, "\nThis file was produced by the IOA package in ABC on %s\n", Ioa_TimeStamp() ); fprintf( pFile, "For information about AIGER format, refer to %s\n", "http://fmv.jku.at/aiger" ); fclose( pFile ); } diff --git a/src/aig/saig/saigMiter.c b/src/aig/saig/saigMiter.c index 174a3e97..71bdadf6 100644 --- a/src/aig/saig/saigMiter.c +++ b/src/aig/saig/saigMiter.c @@ -568,13 +568,17 @@ int Saig_ManDemiterSimpleDiff( Aig_Man_t * p, Aig_Man_t ** ppAig0, Aig_Man_t ** printf( "The output number %d of the miter is constant 1.\n", i ); Counter++; continue; - } + } if ( !Aig_ObjIsNode(pFanin) || !Aig_ObjRecognizeExor( pFanin, &pObj0, &pObj1 ) ) { +/* printf( "The miter cannot be demitered.\n" ); Vec_PtrFree( vSet0 ); Vec_PtrFree( vSet1 ); return 0; +*/ + printf( "The output number %d cannot be demitered.\n", i ); + continue; } if ( Aig_ObjFaninC0(pObj) ) pObj0 = Aig_Not(pObj0); diff --git a/src/aig/ssw/sswCore.c b/src/aig/ssw/sswCore.c index 16430ace..9d09d4e7 100644 --- a/src/aig/ssw/sswCore.c +++ b/src/aig/ssw/sswCore.c @@ -179,7 +179,8 @@ clk = clock(); printf( "Cex =%5d. ", p->nSatCallsSat-nSatCallsSat ); printf( "R =%4d. ", p->nRecycles-nRecycles ); } - printf( "F =%5d. ", p->nSatFailsReal-nSatFailsReal ); + printf( "F =%5d. %s ", p->nSatFailsReal-nSatFailsReal, + (Saig_ManPoNum(p->pAig)==1 && Ssw_ObjIsConst1Cand(p->pAig,Aig_ObjFanin0(Aig_ManPo(p->pAig,0))))? "+" : "-" ); ABC_PRT( "T", clock() - clk ); } // if ( p->pPars->fDynamic && p->nSatCallsSat-nSatCallsSat < 100 ) |