/**CFile**************************************************************** FileName [abcExact.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Network and node package.] Synopsis [Find minimum size networks with a SAT solver.] Author [Mathias Soeken] Affiliation [EPFL] Date [Ver. 1.0. Started - July 15, 2016.] Revision [$Id: abcFanio.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] ***********************************************************************/ /* This implementation is based on Exercises 477 and 478 in * Donald E. Knuth TAOCP Fascicle 6 (Satisfiability) Section 7.2.2.2 */ #include "base/abc/abc.h" #include "aig/gia/gia.h" #include "misc/util/utilTruth.h" #include "misc/vec/vecInt.h" #include "misc/vec/vecPtr.h" #include "proof/cec/cec.h" #include "sat/bsat/satSolver.h" ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// /*********************************************************************** Synopsis [Some truth table helper functions.] ***********************************************************************/ static word s_Truths8[32] = { ABC_CONST(0xAAAAAAAAAAAAAAAA), ABC_CONST(0xAAAAAAAAAAAAAAAA), ABC_CONST(0xAAAAAAAAAAAAAAAA), ABC_CONST(0xAAAAAAAAAAAAAAAA), ABC_CONST(0xCCCCCCCCCCCCCCCC), ABC_CONST(0xCCCCCCCCCCCCCCCC), ABC_CONST(0xCCCCCCCCCCCCCCCC), ABC_CONST(0xCCCCCCCCCCCCCCCC), ABC_CONST(0xF0F0F0F0F0F0F0F0), ABC_CONST(0xF0F0F0F0F0F0F0F0), ABC_CONST(0xF0F0F0F0F0F0F0F0), ABC_CONST(0xF0F0F0F0F0F0F0F0), ABC_CONST(0xFF00FF00FF00FF00), ABC_CONST(0xFF00FF00FF00FF00), ABC_CONST(0xFF00FF00FF00FF00), ABC_CONST(0xFF00FF00FF00FF00), ABC_CONST(0xFFFF0000FFFF0000), ABC_CONST(0xFFFF0000FFFF0000), ABC_CONST(0xFFFF0000FFFF0000), ABC_CONST(0xFFFF0000FFFF0000), ABC_CONST(0xFFFFFFFF00000000), ABC_CONST(0xFFFFFFFF00000000), ABC_CONST(0xFFFFFFFF00000000), ABC_CONST(0xFFFFFFFF00000000), ABC_CONST(0x0000000000000000), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0x0000000000000000), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0x0000000000000000), ABC_CONST(0x0000000000000000), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0xFFFFFFFFFFFFFFFF) }; static word s_Truths8Neg[32] = { ABC_CONST(0x5555555555555555), ABC_CONST(0x5555555555555555), ABC_CONST(0x5555555555555555), ABC_CONST(0x5555555555555555), ABC_CONST(0x3333333333333333), ABC_CONST(0x3333333333333333), ABC_CONST(0x3333333333333333), ABC_CONST(0x3333333333333333), ABC_CONST(0x0F0F0F0F0F0F0F0F), ABC_CONST(0x0F0F0F0F0F0F0F0F), ABC_CONST(0x0F0F0F0F0F0F0F0F), ABC_CONST(0x0F0F0F0F0F0F0F0F), ABC_CONST(0x00FF00FF00FF00FF), ABC_CONST(0x00FF00FF00FF00FF), ABC_CONST(0x00FF00FF00FF00FF), ABC_CONST(0x00FF00FF00FF00FF), ABC_CONST(0x0000FFFF0000FFFF), ABC_CONST(0x0000FFFF0000FFFF), ABC_CONST(0x0000FFFF0000FFFF), ABC_CONST(0x0000FFFF0000FFFF), ABC_CONST(0x00000000FFFFFFFF), ABC_CONST(0x00000000FFFFFFFF), ABC_CONST(0x00000000FFFFFFFF), ABC_CONST(0x00000000FFFFFFFF), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0x0000000000000000), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0x0000000000000000), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0xFFFFFFFFFFFFFFFF), ABC_CONST(0x0000000000000000), ABC_CONST(0x0000000000000000) }; static int Abc_TtIsSubsetWithMask( word * pSmall, word * pLarge, word * pMask, int nWords ) { int w; for ( w = 0; w < nWords; ++w ) if ( ( pSmall[w] & pLarge[w] & pMask[w] ) != ( pSmall[w] & pMask[w] ) ) return 0; return 1; } static int Abc_TtCofsOppositeWithMask( word * pTruth, word * pMask, int nWords, int iVar ) { if ( iVar < 6 ) { int w, Shift = ( 1 << iVar ); for ( w = 0; w < nWords; ++w ) if ( ( ( pTruth[w] << Shift ) & s_Truths6[iVar] & pMask[w] ) != ( ~pTruth[w] & s_Truths6[iVar] & pMask[w] ) ) return 0; return 1; } else { int w, Step = ( 1 << ( iVar - 6 ) ); word * p = pTruth, * m = pMask, * pLimit = pTruth + nWords; for ( ; p < pLimit; p += 2 * Step, m += 2 * Step ) for ( w = 0; w < Step; ++w ) if ( ( p[w] & m[w] ) != ( ~p[w + Step] & m[w + Step] ) ) return 0; return 1; } } // checks whether we can decompose as OP(x^p, g) where OP in {AND, OR} and p in {0, 1} // returns p if OP = AND, and 2 + p if OP = OR static int Abc_TtIsTopDecomposable( word * pTruth, word * pMask, int nWords, int iVar ) { assert( iVar < 8 ); if ( Abc_TtIsSubsetWithMask( pTruth, &s_Truths8[iVar << 2], pMask, nWords ) ) return 1; if ( Abc_TtIsSubsetWithMask( pTruth, &s_Truths8Neg[iVar << 2], pMask, nWords ) ) return 2; if ( Abc_TtIsSubsetWithMask( &s_Truths8[iVar << 2], pTruth, pMask, nWords ) ) return 3; if ( Abc_TtIsSubsetWithMask( &s_Truths8Neg[iVar << 2], pTruth, pMask, nWords ) ) return 4; if ( Abc_TtCofsOppositeWithMask( pTruth, pMask, nWords, iVar ) ) return 5; return 0; } // checks whether we can decompose as OP(x1, OP(x2, OP(x3, ...))) where pVars = {x1, x2, x3, ...} // OP can be different and vars can be complemented static int Abc_TtIsStairDecomposable( word * pTruth, int nWords, int * pVars, int nSize, int * pStairFunc ) { int i, d; word pMask[4]; word pCopy[4]; Abc_TtCopy( pCopy, pTruth, nWords, 0 ); Abc_TtMask( pMask, nWords, nWords * 64 ); for ( i = 0; i < nSize; ++i ) { d = Abc_TtIsTopDecomposable( pCopy, pMask, nWords, pVars[i] ); if ( !d ) return 0; /* not decomposable */ pStairFunc[i] = d; switch ( d ) { case 1: /* AND(x, g) */ case 4: /* OR(!x, g) */ Abc_TtAnd( pMask, pMask, &s_Truths8[pVars[i] << 2], nWords, 0 ); break; case 2: /* AND(!x, g) */ case 3: /* OR(x, g) */ Abc_TtAnd( pMask, pMask, &s_Truths8Neg[pVars[i] << 2], nWords, 0 ); break; case 5: Abc_TtXor( pCopy, pCopy, &s_Truths8[pVars[i] << 2], nWords, 0 ); break; } } return 1; /* decomposable */ } /*********************************************************************** Synopsis [Some printing utilities.] ***********************************************************************/ static inline void Abc_DebugPrint( const char* str, int fCond ) { if ( fCond ) { printf( "%s", str ); fflush( stdout ); } } static inline void Abc_DebugPrintInt( const char* fmt, int n, int fCond ) { if ( fCond ) { printf( fmt, n ); fflush( stdout ); } } static inline void Abc_DebugPrintIntInt( const char* fmt, int n1, int n2, int fCond ) { if ( fCond ) { printf( fmt, n1, n2 ); fflush( stdout ); } } static inline void Abc_DebugErase( int n, int fCond ) { int i; if ( fCond ) { for ( i = 0; i < n; ++i ) printf( "\b" ); fflush( stdout ); } } /*********************************************************************** Synopsis [BMS.] ***********************************************************************/ #define ABC_EXACT_SOL_NVARS 0 #define ABC_EXACT_SOL_NFUNC 1 #define ABC_EXACT_SOL_NGATES 2 #define ANSI_COLOR_RED "\x1b[31m" #define ANSI_COLOR_GREEN "\x1b[32m" #define ANSI_COLOR_YELLOW "\x1b[33m" #define ANSI_COLOR_BLUE "\x1b[34m" #define ANSI_COLOR_MAGENTA "\x1b[35m" #define ANSI_COLOR_CYAN "\x1b[36m" #define ANSI_COLOR_RESET "\x1b[0m" typedef struct Ses_Man_t_ Ses_Man_t; struct Ses_Man_t_ { sat_solver * pSat; /* SAT solver */ word * pSpec; /* specification */ int bSpecInv; /* remembers whether spec was inverted for normalization */ int nSpecVars; /* number of variables in specification */ int nSpecFunc; /* number of functions to synthesize */ int nSpecWords; /* number of words for function */ int nRows; /* number of rows in the specification (without 0) */ int nMaxDepth; /* maximum depth (-1 if depth is not constrained) */ int nMaxDepthTmp; /* temporary copy to modify nMaxDepth temporarily */ int * pArrTimeProfile; /* arrival times of inputs (NULL if arrival times are ignored) */ int pArrTimeProfileTmp[8]; /* temporary copy to modify pArrTimeProfile temporarily */ int nArrTimeDelta; /* delta to the original arrival times (arrival times are normalized to have 0 as minimum element) */ int nArrTimeMax; /* maximum normalized arrival time */ int nBTLimit; /* conflict limit */ int fMakeAIG; /* create AIG instead of general network */ int fVerbose; /* be verbose */ int fVeryVerbose; /* be very verbose */ int fExtractVerbose; /* be verbose about solution extraction */ int fSatVerbose; /* be verbose about SAT solving */ int fReasonVerbose; /* be verbose about give-up reasons */ word pTtValues[4]; /* truth table values to assign */ Vec_Int_t * vPolar; /* variables with positive polarity */ Vec_Int_t * vAssump; /* assumptions */ int nRandRowAssigns; /* number of random row assignments to initialize CEGAR */ int fKeepRowAssigns; /* if 1, keep counter examples in CEGAR for next number of gates */ int nGates; /* number of gates */ int nStartGates; /* number of gates to start search (-1), i.e., to start from 1 gate, one needs to specify 0 */ int nMaxGates; /* maximum number of gates given max. delay and arrival times */ int fDecStructure; /* set to 1 or higher if nSpecFunc = 1 and f = x_i OP g(X \ {x_i}), otherwise 0 (determined when solving) */ int pDecVars; /* mask of variables that can be decomposed at top-level */ Vec_Int_t * vStairDecVars; /* list of stair decomposable variables */ int pStairDecFunc[8]; /* list of stair decomposable functions */ word pTtObjs[100]; /* temporary truth tables */ int nSimVars; /* number of simulation vars x(i, t) */ int nOutputVars; /* number of output variables g(h, i) */ int nGateVars; /* number of gate variables f(i, p, q) */ int nSelectVars; /* number of select variables s(i, j, k) */ int nDepthVars; /* number of depth variables d(i, j) */ int nSimOffset; /* offset where gate variables start */ int nOutputOffset; /* offset where output variables start */ int nGateOffset; /* offset where gate variables start */ int nSelectOffset; /* offset where select variables start */ int nDepthOffset; /* offset where depth variables start */ int fHitResLimit; /* SAT solver gave up due to resource limit */ abctime timeSat; /* SAT runtime */ abctime timeSatSat; /* SAT runtime (sat instance) */ abctime timeSatUnsat; /* SAT runtime (unsat instance) */ abctime timeSatUndef; /* SAT runtime (undef instance) */ abctime timeInstance; /* creating instance runtime */ abctime timeTotal; /* all runtime */ int nSatCalls; /* number of SAT calls */ int nUnsatCalls; /* number of UNSAT calls */ int nUndefCalls; /* number of UNDEF calls */ int nDebugOffset; /* for debug printing */ }; /*********************************************************************** Synopsis [Store truth tables based on normalized arrival times.] ***********************************************************************/ // The hash table is a list of pointers to Ses_TruthEntry_t elements, which // are arranged in a linked list, each of which pointing to a linked list // of Ses_TimesEntry_t elements which contain the char* representation of the // optimum netlist according to then normalized arrival times: typedef struct Ses_TimesEntry_t_ Ses_TimesEntry_t; struct Ses_TimesEntry_t_ { int pArrTimeProfile[8]; /* normalized arrival time profile */ int fResLimit; /* solution found after resource limit */ Ses_TimesEntry_t * next; /* linked list pointer */ char * pNetwork; /* pointer to char array representation of optimum network */ }; typedef struct Ses_TruthEntry_t_ Ses_TruthEntry_t; struct Ses_TruthEntry_t_ { word pTruth[4]; /* truth table for comparison */ int nVars; /* number of variables */ Ses_TruthEntry_t * next; /* linked list pointer */ Ses_TimesEntry_t * head; /* pointer to head of sub list with arrival times */ }; #define SES_STORE_TABLE_SIZE 1024 typedef struct Ses_Store_t_ Ses_Store_t; struct Ses_Store_t_ { int fMakeAIG; /* create AIG instead of general network */ int fVerbose; /* be verbose */ int fVeryVerbose; /* be very verbose */ int nBTLimit; /* conflict limit */ int nEntriesCount; /* number of entries */ int nValidEntriesCount; /* number of entries with network */ Ses_TruthEntry_t * pEntries[SES_STORE_TABLE_SIZE]; /* hash table for truth table entries */ sat_solver * pSat; /* own SAT solver instance to reuse when calling exact algorithm */ FILE * pDebugEntries; /* debug unsynth. (rl) entries */ char * szDBName; /* if given, database is written every time a new entry is added */ /* statistics */ unsigned long nCutCount; /* number of cuts investigated */ unsigned long pCutCount[9]; /* -> per cut size */ unsigned long nUnsynthesizedImp; /* number of cuts which couldn't be optimized at all, opt. stopped because of imp. constraints */ unsigned long pUnsynthesizedImp[9]; /* -> per cut size */ unsigned long nUnsynthesizedRL; /* number of cuts which couldn't be optimized at all, opt. stopped because of resource limits */ unsigned long pUnsynthesizedRL[9]; /* -> per cut size */ unsigned long nSynthesizedTrivial; /* number of cuts which could be synthesized trivially (n < 2) */ unsigned long pSynthesizedTrivial[9]; /* -> per cut size */ unsigned long nSynthesizedImp; /* number of cuts which could be synthesized, opt. stopped because of imp. constraints */ unsigned long pSynthesizedImp[9]; /* -> per cut size */ unsigned long nSynthesizedRL; /* number of cuts which could be synthesized, opt. stopped because of resource limits */ unsigned long pSynthesizedRL[9]; /* -> per cut size */ unsigned long nCacheHits; /* number of cache hits */ unsigned long pCacheHits[9]; /* -> per cut size */ unsigned long nSatCalls; /* number of total SAT calls */ unsigned long nUnsatCalls; /* number of total UNSAT calls */ unsigned long nUndefCalls; /* number of total UNDEF calls */ abctime timeExact; /* Exact synthesis runtime */ abctime timeSat; /* SAT runtime */ abctime timeSatSat; /* SAT runtime (sat instance) */ abctime timeSatUnsat; /* SAT runtime (unsat instance) */ abctime timeSatUndef; /* SAT runtime (undef instance) */ abctime timeInstance; /* creating instance runtime */ abctime timeTotal; /* all runtime */ }; static Ses_Store_t * s_pSesStore = NULL; //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// static int Abc_NormalizeArrivalTimes( int * pArrTimeProfile, int nVars, int * maxNormalized ) { int * p = pArrTimeProfile, * pEnd = pArrTimeProfile + nVars; int delta = *p; while ( ++p < pEnd ) if ( *p < delta ) delta = *p; *maxNormalized = 0; p = pArrTimeProfile; while ( p < pEnd ) { *p -= delta; if ( *p > *maxNormalized ) *maxNormalized = *p; ++p; } *maxNormalized += 1; return delta; } static inline Ses_Store_t * Ses_StoreAlloc( int nBTLimit, int fMakeAIG, int fVerbose ) { Ses_Store_t * pStore = ABC_CALLOC( Ses_Store_t, 1 ); pStore->fMakeAIG = fMakeAIG; pStore->fVerbose = fVerbose; pStore->nBTLimit = nBTLimit; memset( pStore->pEntries, 0, sizeof(pStore->pEntries) ); pStore->pSat = sat_solver_new(); return pStore; } static inline void Ses_StoreClean( Ses_Store_t * pStore ) { int i; Ses_TruthEntry_t * pTEntry, * pTEntry2; Ses_TimesEntry_t * pTiEntry, * pTiEntry2; for ( i = 0; i < SES_STORE_TABLE_SIZE; ++i ) if ( pStore->pEntries[i] ) { pTEntry = pStore->pEntries[i]; while ( pTEntry ) { pTiEntry = pTEntry->head; while ( pTiEntry ) { ABC_FREE( pTiEntry->pNetwork ); pTiEntry2 = pTiEntry; pTiEntry = pTiEntry->next; ABC_FREE( pTiEntry2 ); } pTEntry2 = pTEntry; pTEntry = pTEntry->next; ABC_FREE( pTEntry2 ); } } sat_solver_delete( pStore->pSat ); if ( pStore->szDBName ) ABC_FREE( pStore->szDBName ); ABC_FREE( pStore ); } static inline int Ses_StoreTableHash( word * pTruth, int nVars ) { static int s_Primes[4] = { 1291, 1699, 1999, 2357 }; int i; unsigned uHash = 0; for ( i = 0; i < Abc_TtWordNum( nVars ); ++i ) uHash ^= pTruth[i] * s_Primes[i & 0xf]; return (int)(uHash % SES_STORE_TABLE_SIZE ); } static inline int Ses_StoreTruthEqual( Ses_TruthEntry_t * pEntry, word * pTruth, int nVars ) { int i; if ( pEntry->nVars != nVars ) return 0; for ( i = 0; i < Abc_TtWordNum( nVars ); ++i ) if ( pEntry->pTruth[i] != pTruth[i] ) return 0; return 1; } static inline void Ses_StoreTruthCopy( Ses_TruthEntry_t * pEntry, word * pTruthSrc, int nVars ) { int i; pEntry->nVars = nVars; for ( i = 0; i < Abc_TtWordNum( nVars ); ++i ) pEntry->pTruth[i] = pTruthSrc[i]; } static inline int Ses_StoreTimesEqual( int * pTimes1, int * pTimes2, int nVars ) { int i; for ( i = 0; i < nVars; ++i ) if ( pTimes1[i] != pTimes2[i] ) return 0; return 1; } static inline void Ses_StoreTimesCopy( int * pTimesDest, int * pTimesSrc, int nVars ) { int i; for ( i = 0; i < nVars; ++i ) pTimesDest[i] = pTimesSrc[i]; } static inline void Ses_StorePrintEntry( Ses_TruthEntry_t * pEntry, Ses_TimesEntry_t * pTiEntry ) { int i; printf( "f = " ); Abc_TtPrintHexRev( stdout, pEntry->pTruth, pEntry->nVars ); printf( ", n = %d", pEntry->nVars ); printf( ", arrival =" ); for ( i = 0; i < pEntry->nVars; ++i ) printf( " %d", pTiEntry->pArrTimeProfile[i] ); printf( "\n" ); } static inline void Ses_StorePrintDebugEntry( Ses_Store_t * pStore, word * pTruth, int nVars, int * pNormalArrTime, int nMaxDepth, char * pSol, int nStartGates ) { int l; fprintf( pStore->pDebugEntries, "abc -c \"exact -v -C %d", pStore->nBTLimit ); if ( s_pSesStore->fMakeAIG ) fprintf( pStore->pDebugEntries, " -a" ); fprintf( pStore->pDebugEntries, " -S %d -D %d -A", nStartGates + 1, nMaxDepth ); for ( l = 0; l < nVars; ++l ) fprintf( pStore->pDebugEntries, "%c%d", ( l == 0 ? ' ' : ',' ), pNormalArrTime[l] ); fprintf( pStore->pDebugEntries, " " ); Abc_TtPrintHexRev( pStore->pDebugEntries, pTruth, nVars ); fprintf( pStore->pDebugEntries, "\" # " ); if ( !pSol ) fprintf( pStore->pDebugEntries, "no " ); fprintf( pStore->pDebugEntries, "solution found before\n" ); } static void Abc_ExactNormalizeArrivalTimesForNetwork( int nVars, int * pArrTimeProfile, char * pSol ) { int nGates, i, j, k, nMax; Vec_Int_t * vLevels; nGates = pSol[ABC_EXACT_SOL_NGATES]; /* printf( "NORMALIZE\n" ); */ /* printf( " #vars = %d\n", nVars ); */ /* printf( " #gates = %d\n", nGates ); */ vLevels = Vec_IntAllocArrayCopy( pArrTimeProfile, nVars ); /* compute level of each gate based on arrival time profile (to compute depth) */ for ( i = 0; i < nGates; ++i ) { j = pSol[3 + i * 4 + 2]; k = pSol[3 + i * 4 + 3]; Vec_IntPush( vLevels, Abc_MaxInt( Vec_IntEntry( vLevels, j ), Vec_IntEntry( vLevels, k ) ) + 1 ); /* printf( " gate %d = (%d,%d)\n", nVars + i, j, k ); */ } /* Vec_IntPrint( vLevels ); */ /* reset all levels except for the last one */ for ( i = 0; i < nVars + nGates - 1; ++i ) Vec_IntSetEntry( vLevels, i, Vec_IntEntry( vLevels, nVars + nGates - 1 ) ); /* Vec_IntPrint( vLevels ); */ /* compute levels from top to bottom */ for ( i = nGates - 1; i >= 0; --i ) { j = pSol[3 + i * 4 + 2]; k = pSol[3 + i * 4 + 3]; Vec_IntSetEntry( vLevels, j, Abc_MinInt( Vec_IntEntry( vLevels, j ), Vec_IntEntry( vLevels, nVars + i ) - 1 ) ); Vec_IntSetEntry( vLevels, k, Abc_MinInt( Vec_IntEntry( vLevels, k ), Vec_IntEntry( vLevels, nVars + i ) - 1 ) ); } /* Vec_IntPrint( vLevels ); */ /* normalize arrival times */ Abc_NormalizeArrivalTimes( Vec_IntArray( vLevels ), nVars, &nMax ); memcpy( pArrTimeProfile, Vec_IntArray( vLevels ), sizeof(int) * nVars ); /* printf( " nMax = %d\n", nMax ); */ /* Vec_IntPrint( vLevels ); */ Vec_IntFree( vLevels ); } static void Ses_StoreWrite( Ses_Store_t * pStore, const char * pFilename, int fSynthImp, int fSynthRL, int fUnsynthImp, int fUnsynthRL ) { int i; char zero = '\0'; unsigned long nEntries = 0; Ses_TruthEntry_t * pTEntry; Ses_TimesEntry_t * pTiEntry; FILE * pFile; pFile = fopen( pFilename, "wb" ); if (pFile == NULL) { printf( "cannot open file \"%s\" for writing\n", pFilename ); return; } if ( fSynthImp ) nEntries += pStore->nSynthesizedImp; if ( fSynthRL ) nEntries += pStore->nSynthesizedRL; if ( fUnsynthImp ) nEntries += pStore->nUnsynthesizedImp; if ( fUnsynthRL ) nEntries += pStore->nUnsynthesizedRL; fwrite( &nEntries, sizeof( unsigned long ), 1, pFile ); for ( i = 0; i < SES_STORE_TABLE_SIZE; ++i ) if ( pStore->pEntries[i] ) { pTEntry = pStore->pEntries[i]; while ( pTEntry ) { pTiEntry = pTEntry->head; while ( pTiEntry ) { if ( !fSynthImp && pTiEntry->pNetwork && !pTiEntry->fResLimit ) { pTiEntry = pTiEntry->next; continue; } if ( !fSynthRL && pTiEntry->pNetwork && pTiEntry->fResLimit ) { pTiEntry = pTiEntry->next; continue; } if ( !fUnsynthImp && !pTiEntry->pNetwork && !pTiEntry->fResLimit ) { pTiEntry = pTiEntry->next; continue; } if ( !fUnsynthRL && !pTiEntry->pNetwork && pTiEntry->fResLimit ) { pTiEntry = pTiEntry->next; continue; } fwrite( pTEntry->pTruth, sizeof( word ), 4, pFile ); fwrite( &pTEntry->nVars, sizeof( int ), 1, pFile ); fwrite( pTiEntry->pArrTimeProfile, sizeof( int ), 8, pFile ); fwrite( &pTiEntry->fResLimit, sizeof( int ), 1, pFile ); if ( pTiEntry->pNetwork ) { fwrite( pTiEntry->pNetwork, sizeof( char ), 3 + 4 * pTiEntry->pNetwork[ABC_EXACT_SOL_NGATES] + 2 + pTiEntry->pNetwork[ABC_EXACT_SOL_NVARS], pFile ); } else { fwrite( &zero, sizeof( char ), 1, pFile ); fwrite( &zero, sizeof( char ), 1, pFile ); fwrite( &zero, sizeof( char ), 1, pFile ); } pTiEntry = pTiEntry->next; } pTEntry = pTEntry->next; } } fclose( pFile ); } // pArrTimeProfile is normalized // returns 1 if and only if a new TimesEntry has been created int Ses_StoreAddEntry( Ses_Store_t * pStore, word * pTruth, int nVars, int * pArrTimeProfile, char * pSol, int fResLimit ) { int key, fAdded; Ses_TruthEntry_t * pTEntry; Ses_TimesEntry_t * pTiEntry; if ( pSol ) Abc_ExactNormalizeArrivalTimesForNetwork( nVars, pArrTimeProfile, pSol ); key = Ses_StoreTableHash( pTruth, nVars ); pTEntry = pStore->pEntries[key]; /* does truth table already exist? */ while ( pTEntry ) { if ( Ses_StoreTruthEqual( pTEntry, pTruth, nVars ) ) break; else pTEntry = pTEntry->next; } /* entry does not yet exist, so create new one and enqueue */ if ( !pTEntry ) { pTEntry = ABC_CALLOC( Ses_TruthEntry_t, 1 ); Ses_StoreTruthCopy( pTEntry, pTruth, nVars ); pTEntry->next = pStore->pEntries[key]; pStore->pEntries[key] = pTEntry; } /* does arrival time already exist? */ pTiEntry = pTEntry->head; while ( pTiEntry ) { if ( Ses_StoreTimesEqual( pArrTimeProfile, pTiEntry->pArrTimeProfile, nVars ) ) break; else pTiEntry = pTiEntry->next; } /* entry does not yet exist, so create new one and enqueue */ if ( !pTiEntry ) { pTiEntry = ABC_CALLOC( Ses_TimesEntry_t, 1 ); Ses_StoreTimesCopy( pTiEntry->pArrTimeProfile, pArrTimeProfile, nVars ); pTiEntry->pNetwork = pSol; pTiEntry->fResLimit = fResLimit; pTiEntry->next = pTEntry->head; pTEntry->head = pTiEntry; /* item has been added */ fAdded = 1; pStore->nEntriesCount++; if ( pSol ) pStore->nValidEntriesCount++; } else { //assert( 0 ); /* item was already present */ fAdded = 0; } /* statistics */ if ( pSol ) { if ( fResLimit ) { pStore->nSynthesizedRL++; pStore->pSynthesizedRL[nVars]++; } else { pStore->nSynthesizedImp++; pStore->pSynthesizedImp[nVars]++; } } else { if ( fResLimit ) { pStore->nUnsynthesizedRL++; pStore->pUnsynthesizedRL[nVars]++; } else { pStore->nUnsynthesizedImp++; pStore->pUnsynthesizedImp[nVars]++; } } if ( fAdded && pStore->szDBName ) Ses_StoreWrite( pStore, pStore->szDBName, 1, 0, 0, 0 ); return fAdded; } // pArrTimeProfile is normalized // returns 1 if entry was in store, pSol may still be 0 if it couldn't be computed int Ses_StoreGetEntrySimple( Ses_Store_t * pStore, word * pTruth, int nVars, int * pArrTimeProfile, char ** pSol ) { int key; Ses_TruthEntry_t * pTEntry; Ses_TimesEntry_t * pTiEntry; key = Ses_StoreTableHash( pTruth, nVars ); pTEntry = pStore->pEntries[key]; /* find truth table entry */ while ( pTEntry ) { if ( Ses_StoreTruthEqual( pTEntry, pTruth, nVars ) ) break; else pTEntry = pTEntry->next; } /* no entry found? */ if ( !pTEntry ) return 0; /* find times entry */ pTiEntry = pTEntry->head; while ( pTiEntry ) { if ( Ses_StoreTimesEqual( pArrTimeProfile, pTiEntry->pArrTimeProfile, nVars ) ) break; else pTiEntry = pTiEntry->next; } /* no entry found? */ if ( !pTiEntry ) return 0; *pSol = pTiEntry->pNetwork; return 1; } int Ses_StoreGetEntry( Ses_Store_t * pStore, word * pTruth, int nVars, int * pArrTimeProfile, char ** pSol ) { int key; Ses_TruthEntry_t * pTEntry; Ses_TimesEntry_t * pTiEntry; int pTimes[8]; key = Ses_StoreTableHash( pTruth, nVars ); pTEntry = pStore->pEntries[key]; /* find truth table entry */ while ( pTEntry ) { if ( Ses_StoreTruthEqual( pTEntry, pTruth, nVars ) ) break; else pTEntry = pTEntry->next; } /* no entry found? */ if ( !pTEntry ) return 0; /* find times entry */ pTiEntry = pTEntry->head; while ( pTiEntry ) { /* found after normalization wrt. to network */ if ( pTiEntry->pNetwork ) { memcpy( pTimes, pArrTimeProfile, sizeof(int) * nVars ); Abc_ExactNormalizeArrivalTimesForNetwork( nVars, pTimes, pTiEntry->pNetwork ); if ( Ses_StoreTimesEqual( pTimes, pTiEntry->pArrTimeProfile, nVars ) ) break; } /* found for non synthesized network */ else if ( Ses_StoreTimesEqual( pArrTimeProfile, pTiEntry->pArrTimeProfile, nVars ) ) break; else pTiEntry = pTiEntry->next; } /* no entry found? */ if ( !pTiEntry ) return 0; *pSol = pTiEntry->pNetwork; return 1; } static void Ses_StoreRead( Ses_Store_t * pStore, const char * pFilename, int fSynthImp, int fSynthRL, int fUnsynthImp, int fUnsynthRL ) { int i; unsigned long nEntries; word pTruth[4]; int nVars, fResLimit; int pArrTimeProfile[8]; char pHeader[3]; char * pNetwork; FILE * pFile; int value; if ( pStore->szDBName ) { printf( "cannot read from database when szDBName is set" ); return; } pFile = fopen( pFilename, "rb" ); if (pFile == NULL) { printf( "cannot open file \"%s\" for reading\n", pFilename ); return; } value = fread( &nEntries, sizeof( unsigned long ), 1, pFile ); for ( i = 0; i < (int)nEntries; ++i ) { value = fread( pTruth, sizeof( word ), 4, pFile ); value = fread( &nVars, sizeof( int ), 1, pFile ); value = fread( pArrTimeProfile, sizeof( int ), 8, pFile ); value = fread( &fResLimit, sizeof( int ), 1, pFile ); value = fread( pHeader, sizeof( char ), 3, pFile ); if ( pHeader[0] == '\0' ) pNetwork = NULL; else { pNetwork = ABC_CALLOC( char, 3 + 4 * pHeader[ABC_EXACT_SOL_NGATES] + 2 + pHeader[ABC_EXACT_SOL_NVARS] ); pNetwork[0] = pHeader[0]; pNetwork[1] = pHeader[1]; pNetwork[2] = pHeader[2]; value = fread( pNetwork + 3, sizeof( char ), 4 * pHeader[ABC_EXACT_SOL_NGATES] + 2 + pHeader[ABC_EXACT_SOL_NVARS], pFile ); } if ( !fSynthImp && pNetwork && !fResLimit ) continue; if ( !fSynthRL && pNetwork && fResLimit ) continue; if ( !fUnsynthImp && !pNetwork && !fResLimit ) continue; if ( !fUnsynthRL && !pNetwork && fResLimit ) continue; Ses_StoreAddEntry( pStore, pTruth, nVars, pArrTimeProfile, pNetwork, fResLimit ); } fclose( pFile ); printf( "read %lu entries from file\n", (long)nEntries ); } // computes top decomposition of variables wrt. to AND and OR static inline void Ses_ManComputeTopDec( Ses_Man_t * pSes ) { int l; word pMask[4]; Abc_TtMask( pMask, pSes->nSpecWords, pSes->nSpecWords * 64 ); for ( l = 0; l < pSes->nSpecVars; ++l ) if ( Abc_TtIsTopDecomposable( pSes->pSpec, pMask, pSes->nSpecWords, l ) ) pSes->pDecVars |= ( 1 << l ); } static inline Ses_Man_t * Ses_ManAlloc( word * pTruth, int nVars, int nFunc, int nMaxDepth, int * pArrTimeProfile, int fMakeAIG, int nBTLimit, int fVerbose ) { int h, i; Ses_Man_t * p = ABC_CALLOC( Ses_Man_t, 1 ); p->pSat = NULL; p->bSpecInv = 0; for ( h = 0; h < nFunc; ++h ) if ( pTruth[h << 2] & 1 ) { for ( i = 0; i < 4; ++i ) pTruth[(h << 2) + i] = ~pTruth[(h << 2) + i]; p->bSpecInv |= ( 1 << h ); } p->pSpec = pTruth; p->nSpecVars = nVars; p->nSpecFunc = nFunc; p->nSpecWords = Abc_TtWordNum( nVars ); p->nRows = ( 1 << nVars ) - 1; p->nMaxDepth = nMaxDepth; p->pArrTimeProfile = nMaxDepth >= 0 ? pArrTimeProfile : NULL; if ( p->pArrTimeProfile ) p->nArrTimeDelta = Abc_NormalizeArrivalTimes( p->pArrTimeProfile, nVars, &p->nArrTimeMax ); else p->nArrTimeDelta = p->nArrTimeMax = 0; p->fMakeAIG = fMakeAIG; p->nBTLimit = nBTLimit; p->fVerbose = fVerbose; p->fVeryVerbose = 0; p->fExtractVerbose = 0; p->fSatVerbose = 0; p->vPolar = Vec_IntAlloc( 100 ); p->vAssump = Vec_IntAlloc( 10 ); p->vStairDecVars = Vec_IntAlloc( nVars ); p->nRandRowAssigns = 2 * nVars; p->fKeepRowAssigns = 0; if ( p->nSpecFunc == 1 ) Ses_ManComputeTopDec( p ); srand( 0xCAFE ); return p; } static inline void Ses_ManCleanLight( Ses_Man_t * pSes ) { int h, i; for ( h = 0; h < pSes->nSpecFunc; ++h ) if ( ( pSes->bSpecInv >> h ) & 1 ) for ( i = 0; i < 4; ++i ) pSes->pSpec[(h << 2) + i] = ~( pSes->pSpec[(h << 2) + i] ); if ( pSes->pArrTimeProfile ) for ( i = 0; i < pSes->nSpecVars; ++i ) pSes->pArrTimeProfile[i] += pSes->nArrTimeDelta; Vec_IntFree( pSes->vPolar ); Vec_IntFree( pSes->vAssump ); Vec_IntFree( pSes->vStairDecVars ); ABC_FREE( pSes ); } static inline void Ses_ManClean( Ses_Man_t * pSes ) { if ( pSes->pSat ) sat_solver_delete( pSes->pSat ); Ses_ManCleanLight( pSes ); } /**Function************************************************************* Synopsis [Access variables based on indexes.] ***********************************************************************/ static inline int Ses_ManSimVar( Ses_Man_t * pSes, int i, int t ) { assert( i < pSes->nGates ); assert( t < pSes->nRows ); return pSes->nSimOffset + pSes->nRows * i + t; } static inline int Ses_ManOutputVar( Ses_Man_t * pSes, int h, int i ) { assert( h < pSes->nSpecFunc ); assert( i < pSes->nGates ); return pSes->nOutputOffset + pSes->nGates * h + i; } static inline int Ses_ManGateVar( Ses_Man_t * pSes, int i, int p, int q ) { assert( i < pSes->nGates ); assert( p < 2 ); assert( q < 2 ); assert( p > 0 || q > 0 ); return pSes->nGateOffset + i * 3 + ( p << 1 ) + q - 1; } static inline int Ses_ManSelectVar( Ses_Man_t * pSes, int i, int j, int k ) { int a; int offset; assert( i < pSes->nGates ); assert( k < pSes->nSpecVars + i ); assert( j < k ); offset = pSes->nSelectOffset; for ( a = pSes->nSpecVars; a < pSes->nSpecVars + i; ++a ) offset += a * ( a - 1 ) / 2; return offset + ( -j * ( 1 + j - 2 * ( pSes->nSpecVars + i ) ) ) / 2 + ( k - j - 1 ); } static inline int Ses_ManDepthVar( Ses_Man_t * pSes, int i, int j ) { assert( i < pSes->nGates ); assert( j <= pSes->nArrTimeMax + i ); return pSes->nDepthOffset + i * pSes->nArrTimeMax + ( ( i * ( i + 1 ) ) / 2 ) + j; } /**Function************************************************************* Synopsis [Compute truth table from a solution.] ***********************************************************************/ static word * Ses_ManDeriveTruth( Ses_Man_t * pSes, char * pSol, int fInvert ) { int i, f, j, k, w, nGates = pSol[ABC_EXACT_SOL_NGATES]; char * p; word * pTruth = NULL, * pTruth0, * pTruth1; assert( pSol[ABC_EXACT_SOL_NFUNC] == 1 ); p = pSol + 3; memset( pSes->pTtObjs, 0, sizeof( word ) * 4 * nGates ); for ( i = 0; i < nGates; ++i ) { f = *p++; assert( *p == 2 ), p++; j = *p++; k = *p++; pTruth0 = j < pSes->nSpecVars ? &s_Truths8[j << 2] : &pSes->pTtObjs[( j - pSes->nSpecVars ) << 2]; pTruth1 = k < pSes->nSpecVars ? &s_Truths8[k << 2] : &pSes->pTtObjs[( k - pSes->nSpecVars ) << 2]; pTruth = &pSes->pTtObjs[i << 2]; if ( f & 1 ) for ( w = 0; w < pSes->nSpecWords; ++w ) pTruth[w] |= ~pTruth0[w] & pTruth1[w]; if ( ( f >> 1 ) & 1 ) for ( w = 0; w < pSes->nSpecWords; ++w ) pTruth[w] |= pTruth0[w] & ~pTruth1[w]; if ( ( f >> 2 ) & 1 ) for ( w = 0; w < pSes->nSpecWords; ++w ) pTruth[w] |= pTruth0[w] & pTruth1[w]; } assert( Abc_Lit2Var( *p ) == nGates - 1 ); if ( fInvert && Abc_LitIsCompl( *p ) ) Abc_TtNot( pTruth, pSes->nSpecWords ); return pTruth; } /**Function************************************************************* Synopsis [Setup variables to find network with nGates gates.] ***********************************************************************/ static void Ses_ManCreateVars( Ses_Man_t * pSes, int nGates ) { int i; if ( pSes->fSatVerbose ) { printf( "create variables for network with %d functions over %d variables and %d/%d gates\n", pSes->nSpecFunc, pSes->nSpecVars, nGates, pSes->nMaxGates ); } pSes->nGates = nGates; pSes->nSimVars = nGates * pSes->nRows; pSes->nOutputVars = pSes->nSpecFunc * nGates; pSes->nGateVars = nGates * 3; pSes->nSelectVars = 0; for ( i = pSes->nSpecVars; i < pSes->nSpecVars + nGates; ++i ) pSes->nSelectVars += ( i * ( i - 1 ) ) / 2; pSes->nDepthVars = pSes->nMaxDepth > 0 ? nGates * pSes->nArrTimeMax + ( nGates * ( nGates + 1 ) ) / 2 : 0; /* pSes->nSimOffset = 0; */ /* pSes->nOutputOffset = pSes->nSimVars; */ /* pSes->nGateOffset = pSes->nSimVars + pSes->nOutputVars; */ /* pSes->nSelectOffset = pSes->nSimVars + pSes->nOutputVars + pSes->nGateVars; */ /* pSes->nDepthOffset = pSes->nSimVars + pSes->nOutputVars + pSes->nGateVars + pSes->nSelectVars; */ pSes->nDepthOffset = 0; pSes->nSelectOffset = pSes->nDepthVars; pSes->nGateOffset = pSes->nDepthVars + pSes->nSelectVars; pSes->nOutputOffset = pSes->nDepthVars + pSes->nSelectVars + pSes->nGateVars; pSes->nSimOffset = pSes->nDepthVars + pSes->nSelectVars + pSes->nGateVars + pSes->nOutputVars; /* pSes->nDepthOffset = 0; */ /* pSes->nSelectOffset = pSes->nDepthVars; */ /* pSes->nOutputOffset = pSes->nDepthVars + pSes->nSelectVars; */ /* pSes->nGateOffset = pSes->nDepthVars + pSes->nSelectVars + pSes->nOutputVars; */ /* pSes->nSimOffset = pSes->nDepthVars + pSes->nSelectVars + pSes->nOutputVars + pSes->nGateVars; */ /* if we already have a SAT solver, then restart it (this saves a lot of time) */ if ( pSes->pSat ) sat_solver_restart( pSes->pSat ); else pSes->pSat = sat_solver_new(); sat_solver_setnvars( pSes->pSat, pSes->nSimVars + pSes->nOutputVars + pSes->nGateVars + pSes->nSelectVars + pSes->nDepthVars ); } /**Function************************************************************* Synopsis [Create clauses.] ***********************************************************************/ static inline void Ses_ManGateCannotHaveChild( Ses_Man_t * pSes, int i, int j ) { int k; for ( k = 0; k < j; ++k ) Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, k, j ), 1 ) ); for ( k = j + 1; k < pSes->nSpecVars + i; ++k ) Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ) ); } static inline void Ses_ManCreateMainClause( Ses_Man_t * pSes, int t, int i, int j, int k, int a, int b, int c ) { int pLits[5], ctr = 0; pLits[ctr++] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[ctr++] = Abc_Var2Lit( Ses_ManSimVar( pSes, i, t ), a ); if ( j < pSes->nSpecVars ) { if ( ( ( ( t + 1 ) & ( 1 << j ) ) ? 1 : 0 ) != b ) return; } else pLits[ctr++] = Abc_Var2Lit( Ses_ManSimVar( pSes, j - pSes->nSpecVars, t ), b ); if ( k < pSes->nSpecVars ) { if ( ( ( ( t + 1 ) & ( 1 << k ) ) ? 1 : 0 ) != c ) return; } else pLits[ctr++] = Abc_Var2Lit( Ses_ManSimVar( pSes, k - pSes->nSpecVars, t ), c ); if ( b > 0 || c > 0 ) pLits[ctr++] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, b, c ), 1 - a ); sat_solver_addclause( pSes->pSat, pLits, pLits + ctr ); } static int inline Ses_ManCreateTruthTableClause( Ses_Man_t * pSes, int t ) { int i, j, k, h; int pLits[3]; for ( i = 0; i < pSes->nGates; ++i ) { /* main clauses */ for ( j = 0; j < pSes->nSpecVars + i; ++j ) for ( k = j + 1; k < pSes->nSpecVars + i; ++k ) { Ses_ManCreateMainClause( pSes, t, i, j, k, 0, 0, 1 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 0, 1, 0 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 0, 1, 1 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 1, 0, 0 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 1, 0, 1 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 1, 1, 0 ); Ses_ManCreateMainClause( pSes, t, i, j, k, 1, 1, 1 ); } /* output clauses */ if ( pSes->nSpecFunc != 1 ) for ( h = 0; h < pSes->nSpecFunc; ++h ) { pLits[0] = Abc_Var2Lit( Ses_ManOutputVar( pSes, h, i ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManSimVar( pSes, i, t ), 1 - Abc_TtGetBit( &pSes->pSpec[h << 2], t + 1 ) ); if ( !sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ) ) return 0; } } if ( pSes->nSpecFunc == 1 ) Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManSimVar( pSes, pSes->nGates - 1, t ), 1 - Abc_TtGetBit( pSes->pSpec, t + 1 ) ) ); return 1; } static int Ses_ManCreateClauses( Ses_Man_t * pSes ) { extern int Extra_TruthVarsSymm( unsigned * pTruth, int nVars, int iVar0, int iVar1 ); int h, i, j, k, t, ii, jj, kk, iii, p, q; int pLits[3]; Vec_Int_t * vLits = NULL; for ( t = 0; t < pSes->nRows; ++t ) { if ( Abc_TtGetBit( pSes->pTtValues, t ) ) if ( !Ses_ManCreateTruthTableClause( pSes, t ) ) return 0; } /* if there is only one output, we know it must point to the last gate */ if ( pSes->nSpecFunc == 1 ) { for ( i = 0; i < pSes->nGates - 1; ++i ) Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManOutputVar( pSes, 0, i ), 1 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManOutputVar( pSes, 0, pSes->nGates - 1 ), 0 ) ); vLits = Vec_IntAlloc( 0u ); } else { vLits = Vec_IntAlloc( 0u ); /* some output is selected */ for ( h = 0; h < pSes->nSpecFunc; ++h ) { Vec_IntGrowResize( vLits, pSes->nGates ); for ( i = 0; i < pSes->nGates; ++i ) Vec_IntSetEntry( vLits, i, Abc_Var2Lit( Ses_ManOutputVar( pSes, h, i ), 0 ) ); sat_solver_addclause( pSes->pSat, Vec_IntArray( vLits ), Vec_IntArray( vLits ) + pSes->nGates ); } } /* each gate has two operands */ for ( i = 0; i < pSes->nGates; ++i ) { Vec_IntGrowResize( vLits, ( ( pSes->nSpecVars + i ) * ( pSes->nSpecVars + i - 1 ) ) / 2 ); jj = 0; for ( j = 0; j < pSes->nSpecVars + i; ++j ) for ( k = j + 1; k < pSes->nSpecVars + i; ++k ) Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 0 ) ); sat_solver_addclause( pSes->pSat, Vec_IntArray( vLits ), Vec_IntArray( vLits ) + jj ); } /* gate decomposition (makes it worse) */ /* if ( fDecVariable >= 0 && pSes->nGates >= 2 ) */ /* { */ /* pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, pSes->nGates - 1, fDecVariable, pSes->nSpecVars + pSes->nGates - 2 ), 0 ); */ /* if ( !sat_solver_addclause( pSes->pSat, pLits, pLits + 1 ) ) */ /* { */ /* Vec_IntFree( vLits ); */ /* return 0; */ /* } */ /* for ( k = 1; k < pSes->nSpecVars + pSes->nGates - 1; ++k ) */ /* for ( j = 0; j < k; ++j ) */ /* if ( j != fDecVariable || k != pSes->nSpecVars + pSes->nGates - 2 ) */ /* { */ /* pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, pSes->nGates - 1, j, k ), 1 ); */ /* if ( !sat_solver_addclause( pSes->pSat, pLits, pLits + 1 ) ) */ /* { */ /* Vec_IntFree( vLits ); */ /* return 0; */ /* } */ /* } */ /* } */ /* only AIG */ if ( pSes->fMakeAIG ) { for ( i = 0; i < pSes->nGates; ++i ) { /* not 2 ones */ pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 0 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 0 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); } } /* only binary clauses */ if ( 1 ) /* TODO: add some meaningful parameter */ { for ( i = 0; i < pSes->nGates; ++i ) { pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 0 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 0 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 0 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); pLits[0] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 0, 1 ), 0 ); pLits[1] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 0 ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManGateVar( pSes, i, 1, 1 ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); } for ( i = 0; i < pSes->nGates; ++i ) for ( k = 1; k < pSes->nSpecVars + i; ++k ) for ( j = 0; j < k; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); for ( kk = 1; kk < pSes->nSpecVars + i; ++kk ) for ( jj = 0; jj < kk; ++jj ) { if ( k == kk && j == jj ) continue; pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, jj, kk ), 1 ); if ( pLits[0] < pLits[1] ) sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } } /* Vec_IntGrowResize( vLits, pSes->nGates * ( pSes->nSpecVars + pSes->nGates - 2 ) ); */ /* for ( j = 0; j < pSes->nSpecVars; ++j ) */ /* { */ /* jj = 0; */ /* for ( i = 0; i < pSes->nGates; ++i ) */ /* { */ /* for ( k = 0; k < j; ++k ) */ /* Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, k, j ), 0 ) ); */ /* for ( k = j + 1; k < pSes->nSpecVars + i; ++k ) */ /* Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 0 ) ); */ /* } */ /* sat_solver_addclause( pSes->pSat, Vec_IntArray( vLits ), Vec_IntArray( vLits ) + jj ); */ /* } */ } /* EXTRA stair decomposition */ if (Vec_IntSize( pSes->vStairDecVars ) ) { Vec_IntForEachEntry( pSes->vStairDecVars, j, i ) { if ( pSes->nGates - 2 - i < j ) { continue; } Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManSelectVar( pSes, pSes->nGates - 1 - i, j, pSes->nSpecVars + pSes->nGates - 2 - i ), 0 ) ); //printf( "dec %d for var %d\n", pSes->pStairDecFunc[i], j ); switch ( pSes->pStairDecFunc[i] ) { case 1: /* AND(x,g) */ Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 0, 1 ), 1 ) ); //Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 0 ), 1 ) ); //Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 1 ), 0 ) ); break; case 2: /* AND(!x,g) */ //Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 0, 1 ), 0 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 0 ), 1 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 1 ), 1 ) ); break; case 3: /* OR(x,g) */ //Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 0, 1 ), 0 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 0 ), 0 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 1 ), 0 ) ); break; case 4: /* OR(!x,g) */ ////Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 0, 1 ), 0 ) ); ////Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 0 ), 1 ) ); ////Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 1 ), 0 ) ); break; case 5: /* XOR(x,g) */ Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 0, 1 ), 0 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 0 ), 0 ) ); Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManGateVar( pSes, pSes->nGates - 1 - i, 1, 1 ), 1 ) ); break; default: printf( "func: %d\n", pSes->pStairDecFunc[i] ); assert( 0 ); } } } /* EXTRA clauses: use gate i at least once */ Vec_IntGrowResize( vLits, pSes->nSpecFunc + pSes->nGates * ( pSes->nSpecVars + pSes->nGates - 2 ) ); for ( i = 0; i < pSes->nGates; ++i ) { jj = 0; for ( h = 0; h < pSes->nSpecFunc; ++h ) Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManOutputVar( pSes, h, i ), 0 ) ); for ( ii = i + 1; ii < pSes->nGates; ++ii ) { for ( j = 0; j < pSes->nSpecVars + i; ++j ) Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, j, pSes->nSpecVars + i ), 0 ) ); for ( j = pSes->nSpecVars + i + 1; j < pSes->nSpecVars + ii; ++j ) Vec_IntSetEntry( vLits, jj++, Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, pSes->nSpecVars + i, j ), 0 ) ); } sat_solver_addclause( pSes->pSat, Vec_IntArray( vLits ), Vec_IntArray( vLits ) + jj ); } Vec_IntFree( vLits ); /* EXTRA clauses: no reapplying operand */ if ( pSes->nGates > 1 ) for ( i = 0; i < pSes->nGates - 1; ++i ) for ( ii = i + 1; ii < pSes->nGates; ++ii ) for ( k = 1; k < pSes->nSpecVars + i; ++k ) for ( j = 0; j < k; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, j, pSes->nSpecVars + i ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, k, pSes->nSpecVars + i ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } if ( pSes->nGates > 2 ) for ( i = 0; i < pSes->nGates - 2; ++i ) for ( ii = i + 1; ii < pSes->nGates - 1; ++ii ) for ( iii = ii + 1; iii < pSes->nGates; ++iii ) for ( k = 1; k < pSes->nSpecVars + i; ++k ) for ( j = 0; j < k; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, j, k ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManSelectVar( pSes, iii, i, ii ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); } /* EXTRA clauses: co-lexicographic order */ for ( i = 0; i < pSes->nGates - 1; ++i ) { for ( k = 2; k < pSes->nSpecVars + i; ++k ) { for ( j = 1; j < k; ++j ) for ( jj = 0; jj < j; ++jj ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i + 1, jj, k ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } for ( j = 0; j < k; ++j ) for ( kk = 1; kk < k; ++kk ) for ( jj = 0; jj < kk; ++jj ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i + 1, jj, kk ), 1 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } } } /* EXTRA clauses: symmetric variables */ if ( /*pSes->nMaxDepth == -1 &&*/ pSes->nSpecFunc == 1 ) /* only check if there is one output function */ for ( q = 1; q < pSes->nSpecVars; ++q ) for ( p = 0; p < q; ++p ) if ( Extra_TruthVarsSymm( (unsigned*)( pSes->pSpec ), pSes->nSpecVars, p, q ) && ( !pSes->pArrTimeProfile || ( pSes->pArrTimeProfile[p] <= pSes->pArrTimeProfile[q] ) ) ) { if ( pSes->fSatVerbose ) printf( "variables %d and %d are symmetric\n", p, q ); for ( i = 0; i < pSes->nGates; ++i ) for ( j = 0; j < q; ++j ) { if ( j == p ) continue; vLits = Vec_IntAlloc( 0 ); Vec_IntPush( vLits, Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, q ), 1 ) ); for ( ii = 0; ii < i; ++ii ) for ( kk = 1; kk < pSes->nSpecVars + ii; ++kk ) for ( jj = 0; jj < kk; ++jj ) if ( jj == p || kk == p ) Vec_IntPush( vLits, Abc_Var2Lit( Ses_ManSelectVar( pSes, ii, jj, kk ), 0 ) ); sat_solver_addclause( pSes->pSat, Vec_IntArray( vLits ), Vec_IntLimit( vLits ) ); Vec_IntFree( vLits ); } } return 1; } static int Ses_ManCreateDepthClauses( Ses_Man_t * pSes ) { int i, j, k, jj, kk, d, h; int pLits[3]; for ( i = 0; i < pSes->nGates; ++i ) { /* propagate depths from children */ for ( k = 1; k < i; ++k ) for ( j = 0; j < k; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, pSes->nSpecVars + j, pSes->nSpecVars + k ), 1 ); for ( jj = 0; jj <= pSes->nArrTimeMax + j; ++jj ) { pLits[1] = Abc_Var2Lit( Ses_ManDepthVar( pSes, j, jj ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, jj + 1 ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); } } for ( k = 0; k < i; ++k ) for ( j = 0; j < pSes->nSpecVars + k; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, pSes->nSpecVars + k ), 1 ); for ( kk = 0; kk <= pSes->nArrTimeMax + k; ++kk ) { pLits[1] = Abc_Var2Lit( Ses_ManDepthVar( pSes, k, kk ), 1 ); pLits[2] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, kk + 1 ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 3 ); } } /* propagate depths from arrival times at PIs */ if ( pSes->pArrTimeProfile ) { for ( k = 1; k < pSes->nSpecVars + i; ++k ) for ( j = 0; j < ( ( k < pSes->nSpecVars ) ? k : pSes->nSpecVars ); ++j ) { d = pSes->pArrTimeProfile[j]; if ( k < pSes->nSpecVars && pSes->pArrTimeProfile[k] > d ) d = pSes->pArrTimeProfile[k]; pLits[0] = Abc_Var2Lit( Ses_ManSelectVar( pSes, i, j, k ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, d ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } } else /* arrival times are 0 */ Vec_IntPush( pSes->vAssump, Abc_Var2Lit( Ses_ManDepthVar( pSes, i, 0 ), 0 ) ); /* reverse order encoding of depth variables */ for ( j = 1; j <= pSes->nArrTimeMax + i; ++j ) { pLits[0] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, j ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, j - 1 ), 0 ); sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ); } /* constrain maximum depth */ if ( pSes->nMaxDepth < pSes->nArrTimeMax + i ) for ( h = 0; h < pSes->nSpecFunc; ++h ) { pLits[0] = Abc_Var2Lit( Ses_ManOutputVar( pSes, h, i ), 1 ); pLits[1] = Abc_Var2Lit( Ses_ManDepthVar( pSes, i, pSes->nMaxDepth ), 1 ); if ( !sat_solver_addclause( pSes->pSat, pLits, pLits + 2 ) ) return 0; } } return 1; } /**Function************************************************************* Synopsis [Solve.] ***********************************************************************/ static inline double Sat_Wrd2Dbl( word w ) { return (double)(unsigned)(w&0x3FFFFFFF) + (double)(1<<30)*(unsigned)(w>>30); } static inline int Ses_ManSolve( Ses_Man_t * pSes ) { int status; abctime timeStart, timeDelta; if ( pSes->fSatVerbose ) { printf( "SAT CL: %7d VA: %5d", sat_solver_nclauses( pSes->pSat ), sat_solver_nvars( pSes->pSat ) ); fflush( stdout ); } timeStart = Abc_Clock(); status = sat_solver_solve( pSes->pSat, Vec_IntArray( pSes->vAssump ), Vec_IntLimit( pSes->vAssump ), pSes->nBTLimit, 0, 0, 0 ); timeDelta = Abc_Clock() - timeStart; if ( pSes->fSatVerbose ) printf( " RE: %2d ST: %4.f CO: %7.0f DE: %6.0f PR: %6.0f\n", status, Sat_Wrd2Dbl( pSes->pSat->stats.starts ), Sat_Wrd2Dbl( pSes->pSat->stats.conflicts ), Sat_Wrd2Dbl( pSes->pSat->stats.decisions ), Sat_Wrd2Dbl( pSes->pSat->stats.propagations ) ); //Sat_SolverPrintStats( stdout, pSes->pSat ); pSes->timeSat += timeDelta; if ( status == l_True ) { pSes->nSatCalls++; pSes->timeSatSat += timeDelta; return 1; } else if ( status == l_False ) { pSes->nUnsatCalls++; pSes->timeSatUnsat += timeDelta; return 0; } else { pSes->nUndefCalls++; pSes->timeSatUndef += timeDelta; if ( pSes->fSatVerbose ) { //Sat_SolverWriteDimacs( pSes->pSat, "/tmp/test.cnf", Vec_IntArray( pSes->vAssump ), Vec_IntLimit( pSes->vAssump ), 1 ); //exit( 42 ); printf( "resource limit reached\n" ); } return 2; } } /**Function************************************************************* Synopsis [Extract solution.] ***********************************************************************/ // char is an array of short integers that stores the synthesized network // using the following format // | nvars | nfunc | ngates | gate[1] | ... | gate[ngates] | func[1] | .. | func[nfunc] | // nvars: integer with number of variables // nfunc: integer with number of functions // ngates: integer with number of gates // gate[i]: | op | nfanin | fanin[1] | ... | fanin[nfanin] | // op: integer of gate's truth table (divided by 2, because gate is normal) // nfanin: integer with number of fanins // fanin[i]: integer to primary input or other gate // func[i]: | fanin | delay | pin[1] | ... | pin[nvars] | // fanin: integer as literal to some gate (not primary input), can be complemented // delay: maximum delay to output (taking arrival times into account, not normalized) or 0 if not specified // pin[i]: pin to pin delay to input i or 0 if not specified or if there is no connection to input i // NOTE: since outputs can only point to gates, delay and pin-to-pin times cannot be 0 static char * Ses_ManExtractSolution( Ses_Man_t * pSes ) { int nSol, h, i, j, k, l, aj, ak, d, nOp; char * pSol, * p; int * pPerm = NULL; /* will be a 2d array [i][l] where is is gate id and l is PI id */ /* compute length of solution, for now all gates have 2 inputs */ nSol = 3 + pSes->nGates * 4 + pSes->nSpecFunc * ( 2 + pSes->nSpecVars ); p = pSol = ABC_CALLOC( char, nSol ); /* header */ *p++ = pSes->nSpecVars; *p++ = pSes->nSpecFunc; *p++ = pSes->nGates; /* gates */ for ( i = 0; i < pSes->nGates; ++i ) { nOp = sat_solver_var_value( pSes->pSat, Ses_ManGateVar( pSes, i, 0, 1 ) ); nOp |= sat_solver_var_value( pSes->pSat, Ses_ManGateVar( pSes, i, 1, 0 ) ) << 1; nOp |= sat_solver_var_value( pSes->pSat, Ses_ManGateVar( pSes, i, 1, 1 ) ) << 2; *p++ = nOp; *p++ = 2; if ( pSes->fExtractVerbose ) printf( "add gate %d with operation %d", pSes->nSpecVars + i, nOp ); for ( k = 0; k < pSes->nSpecVars + i; ++k ) for ( j = 0; j < k; ++j ) if ( sat_solver_var_value( pSes->pSat, Ses_ManSelectVar( pSes, i, j, k ) ) ) { if ( pSes->fExtractVerbose ) printf( " and operands %d and %d", j, k ); *p++ = j; *p++ = k; k = pSes->nSpecVars + i; break; } if ( pSes->fExtractVerbose ) { if ( pSes->nMaxDepth > 0 ) { printf( " and depth vector " ); for ( j = 0; j <= pSes->nArrTimeMax + i; ++j ) printf( "%d", sat_solver_var_value( pSes->pSat, Ses_ManDepthVar( pSes, i, j ) ) ); } printf( "\n" ); } } /* pin-to-pin delay */ if ( pSes->nMaxDepth != -1 ) { pPerm = ABC_CALLOC( int, pSes->nGates * pSes->nSpecVars ); for ( i = 0; i < pSes->nGates; ++i ) { /* since all gates are binary for now */ j = pSol[3 + i * 4 + 2]; k = pSol[3 + i * 4 + 3]; for ( l = 0; l < pSes->nSpecVars; ++l ) { /* pin-to-pin delay to input l of child nodes */ aj = j < pSes->nSpecVars ? 0 : pPerm[(j - pSes->nSpecVars) * pSes->nSpecVars + l]; ak = k < pSes->nSpecVars ? 0 : pPerm[(k - pSes->nSpecVars) * pSes->nSpecVars + l]; if ( aj == 0 && ak == 0 ) pPerm[i * pSes->nSpecVars + l] = ( l == j || l == k ) ? 1 : 0; else pPerm[i * pSes->nSpecVars + l] = Abc_MaxInt( aj, ak ) + 1; } } } /* outputs */ for ( h = 0; h < pSes->nSpecFunc; ++h ) for ( i = 0; i < pSes->nGates; ++i ) if ( sat_solver_var_value( pSes->pSat, Ses_ManOutputVar( pSes, h, i ) ) ) { *p++ = Abc_Var2Lit( i, ( pSes->bSpecInv >> h ) & 1 ); d = 0; if ( pSes->nMaxDepth != -1 ) for ( l = 0; l < pSes->nSpecVars; ++l ) { if ( pSes->pArrTimeProfile ) d = Abc_MaxInt( d, pSes->pArrTimeProfile[l] + pPerm[i * pSes->nSpecVars + l] ); else d = Abc_MaxInt( d, pPerm[i * pSes->nSpecVars + l] ); } *p++ = d; if ( pSes->pArrTimeProfile && pSes->fExtractVerbose ) printf( "output %d points to gate %d and has normalized delay %d (nArrTimeDelta = %d)\n", h, pSes->nSpecVars + i, d, pSes->nArrTimeDelta ); for ( l = 0; l < pSes->nSpecVars; ++l ) { d = ( pSes->nMaxDepth != -1 ) ? pPerm[i * pSes->nSpecVars + l] : 0; if ( pSes->pArrTimeProfile && pSes->fExtractVerbose ) printf( " pin-to-pin arrival time from input %d is %d (pArrTimeProfile = %d)\n", l, d, pSes->pArrTimeProfile[l] ); *p++ = d; } } /* pin-to-pin delays */ if ( pSes->nMaxDepth != -1 ) ABC_FREE( pPerm ); /* have we used all the fields? */ assert( ( p - pSol ) == nSol ); /* printf( "found network: " ); */ /* Abc_TtPrintHexRev( stdout, Ses_ManDeriveTruth( pSes, pSol, 1 ), pSes->nSpecVars ); */ /* printf( "\n" ); */ return pSol; } static Abc_Ntk_t * Ses_ManExtractNtk( char const * pSol ) { int h, i; char const * p; Abc_Ntk_t * pNtk; Abc_Obj_t * pObj; Vec_Ptr_t * pGates, * vNames; char pGateTruth[5]; char * pSopCover; pNtk = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 ); pNtk->pName = Extra_UtilStrsav( "exact" ); pGates = Vec_PtrAlloc( pSol[ABC_EXACT_SOL_NVARS] + pSol[ABC_EXACT_SOL_NGATES] ); pGateTruth[3] = '0'; pGateTruth[4] = '\0'; vNames = Abc_NodeGetFakeNames( pSol[ABC_EXACT_SOL_NVARS] + pSol[ABC_EXACT_SOL_NFUNC] ); /* primary inputs */ Vec_PtrPush( pNtk->vObjs, NULL ); for ( i = 0; i < pSol[ABC_EXACT_SOL_NVARS]; ++i ) { pObj = Abc_NtkCreatePi( pNtk ); Abc_ObjAssignName( pObj, (char*)Vec_PtrEntry( vNames, i ), NULL ); Vec_PtrPush( pGates, pObj ); } /* gates */ p = pSol + 3; for ( i = 0; i < pSol[ABC_EXACT_SOL_NGATES]; ++i ) { pGateTruth[2] = '0' + ( *p & 1 ); pGateTruth[1] = '0' + ( ( *p >> 1 ) & 1 ); pGateTruth[0] = '0' + ( ( *p >> 2 ) & 1 ); ++p; assert( *p == 2 ); /* binary gate */ ++p; pSopCover = Abc_SopFromTruthBin( pGateTruth ); pObj = Abc_NtkCreateNode( pNtk ); pObj->pData = Abc_SopRegister( (Mem_Flex_t*)pNtk->pManFunc, pSopCover ); Vec_PtrPush( pGates, pObj ); ABC_FREE( pSopCover ); Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) ); Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) ); } /* outputs */ for ( h = 0; h < pSol[ABC_EXACT_SOL_NFUNC]; ++h ) { pObj = Abc_NtkCreatePo( pNtk ); Abc_ObjAssignName( pObj, (char*)Vec_PtrEntry( vNames, pSol[ABC_EXACT_SOL_NVARS] + h ), NULL ); if ( Abc_LitIsCompl( *p ) ) Abc_ObjAddFanin( pObj, Abc_NtkCreateNodeInv( pNtk, (Abc_Obj_t *)Vec_PtrEntry( pGates, pSol[ABC_EXACT_SOL_NVARS] + Abc_Lit2Var( *p ) ) ) ); else Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, pSol[ABC_EXACT_SOL_NVARS] + Abc_Lit2Var( *p ) ) ); p += ( 2 + pSol[ABC_EXACT_SOL_NVARS] ); } Abc_NodeFreeNames( vNames ); Vec_PtrFree( pGates ); if ( !Abc_NtkCheck( pNtk ) ) printf( "Ses_ManExtractSolution(): Network check has failed.\n" ); return pNtk; } static Gia_Man_t * Ses_ManExtractGia( char const * pSol ) { int h, i; char const * p; Gia_Man_t * pGia; Vec_Int_t * pGates; Vec_Ptr_t * vNames; int nObj, nChild1, nChild2, fChild1Comp, fChild2Comp; pGia = Gia_ManStart( pSol[ABC_EXACT_SOL_NVARS] + pSol[ABC_EXACT_SOL_NGATES] + pSol[ABC_EXACT_SOL_NFUNC] + 1 ); pGia->nConstrs = 0; pGia->pName = Extra_UtilStrsav( "exact" ); pGates = Vec_IntAlloc( pSol[ABC_EXACT_SOL_NVARS] + pSol[ABC_EXACT_SOL_NGATES] ); vNames = Abc_NodeGetFakeNames( pSol[ABC_EXACT_SOL_NVARS] + pSol[ABC_EXACT_SOL_NFUNC] ); /* primary inputs */ pGia->vNamesIn = Vec_PtrStart( pSol[ABC_EXACT_SOL_NVARS] ); for ( i = 0; i < pSol[ABC_EXACT_SOL_NVARS]; ++i ) { nObj = Gia_ManAppendCi( pGia ); Vec_IntPush( pGates, nObj ); Vec_PtrSetEntry( pGia->vNamesIn, i, Extra_UtilStrsav( (const char*)Vec_PtrEntry( vNames, i ) ) ); } /* gates */ p = pSol + 3; for ( i = 0; i < pSol[ABC_EXACT_SOL_NGATES]; ++i ) { assert( p[1] == 2 ); nChild1 = Vec_IntEntry( pGates, p[2] ); nChild2 = Vec_IntEntry( pGates, p[3] ); fChild1Comp = fChild2Comp = 0; if ( *p & 1 ) { nChild1 = Abc_LitNot( nChild1 ); fChild1Comp = 1; } if ( ( *p >> 1 ) & 1 ) { nChild2 = Abc_LitNot( nChild2 ); fChild2Comp = 1; } nObj = Gia_ManAppendAnd( pGia, nChild1, nChild2 ); if ( fChild1Comp && fChild2Comp ) { assert( ( *p >> 2 ) & 1 ); nObj = Abc_LitNot( nObj ); } Vec_IntPush( pGates, nObj ); p += 4; } /* outputs */ pGia->vNamesOut = Vec_PtrStart( pSol[ABC_EXACT_SOL_NFUNC] ); for ( h = 0; h < pSol[ABC_EXACT_SOL_NFUNC]; ++h ) { nObj = Vec_IntEntry( pGates, pSol[ABC_EXACT_SOL_NVARS] + Abc_Lit2Var( *p ) ); if ( Abc_LitIsCompl( *p ) ) nObj = Abc_LitNot( nObj ); Gia_ManAppendCo( pGia, nObj ); Vec_PtrSetEntry( pGia->vNamesOut, h, Extra_UtilStrsav( (const char*)Vec_PtrEntry( vNames, pSol[ABC_EXACT_SOL_NVARS] + h ) ) ); p += ( 2 + pSol[ABC_EXACT_SOL_NVARS] ); } Abc_NodeFreeNames( vNames ); Vec_IntFree( pGates ); return pGia; } /**Function************************************************************* Synopsis [Debug.] ***********************************************************************/ static void Ses_ManPrintRuntime( Ses_Man_t * pSes ) { printf( "Runtime breakdown:\n" ); ABC_PRTP( "Sat ", pSes->timeSat, pSes->timeTotal ); ABC_PRTP( " Sat ", pSes->timeSatSat, pSes->timeTotal ); ABC_PRTP( " Unsat ", pSes->timeSatUnsat, pSes->timeTotal ); ABC_PRTP( " Undef ", pSes->timeSatUndef, pSes->timeTotal ); ABC_PRTP( "Instance", pSes->timeInstance, pSes->timeTotal ); ABC_PRTP( "ALL ", pSes->timeTotal, pSes->timeTotal ); } static inline void Ses_ManPrintFuncs( Ses_Man_t * pSes ) { int h; printf( "find optimum circuit for %d %d-variable functions:\n", pSes->nSpecFunc, pSes->nSpecVars ); for ( h = 0; h < pSes->nSpecFunc; ++h ) { printf( " func %d: ", h + 1 ); Abc_TtPrintHexRev( stdout, &pSes->pSpec[h << 2], pSes->nSpecVars ); printf( "\n" ); } if ( pSes->nMaxDepth != -1 ) { printf( " max depth = %d\n", pSes->nMaxDepth ); if ( pSes->pArrTimeProfile ) { printf( " arrival times =" ); for ( h = 0; h < pSes->nSpecVars; ++h ) printf( " %d", pSes->pArrTimeProfile[h] ); printf( "\n" ); } } } static inline void Ses_ManPrintVars( Ses_Man_t * pSes ) { int h, i, j, k, p, q, t; for ( i = 0; i < pSes->nGates; ++i ) for ( t = 0; t < pSes->nRows; ++t ) printf( "x(%d, %d) : %d\n", i, t, Ses_ManSimVar( pSes, i, t ) ); for ( h = 0; h < pSes->nSpecFunc; ++h ) for ( i = 0; i < pSes->nGates; ++i ) printf( "h(%d, %d) : %d\n", h, i, Ses_ManOutputVar( pSes, h, i ) ); for ( i = 0; i < pSes->nGates; ++i ) for ( p = 0; p <= 1; ++p ) for ( q = 0; q <= 1; ++ q) { if ( p == 0 && q == 0 ) { continue; } printf( "f(%d, %d, %d) : %d\n", i, p, q, Ses_ManGateVar( pSes, i, p, q ) ); } for ( i = 0; i < pSes->nGates; ++i ) for ( j = 0; j < pSes->nSpecVars + i; ++j ) for ( k = j + 1; k < pSes->nSpecVars + i; ++k ) printf( "s(%d, %d, %d) : %d\n", i, j, k, Ses_ManSelectVar( pSes, i, j, k ) ); if ( pSes->nMaxDepth > 0 ) for ( i = 0; i < pSes->nGates; ++i ) for ( j = 0; j <= i; ++j ) printf( "d(%d, %d) : %d\n", i, j, Ses_ManDepthVar( pSes, i, j ) ); } /**Function************************************************************* Synopsis [Synthesis algorithm.] ***********************************************************************/ static void Ses_ManComputeMaxGates( Ses_Man_t * pSes ) { int s = 1, lvl = pSes->nMaxDepth, avail = pSes->nSpecVars, l; pSes->nMaxGates = 0; /* s is the number of gates we have in the current level */ while ( s && /* while there are nodes to branch from */ lvl && /* while we are at some level */ avail * 2 > s /* while there are still enough available nodes (heuristic) */ ) { /* erase from s if we have arriving nodes */ for ( l = 0; l < pSes->nSpecVars; ++l ) if ( pSes->pArrTimeProfile[l] == lvl ) { --s; --avail; } --lvl; pSes->nMaxGates += s; s *= 2; } } // returns 0, if current max depth and arrival times are not consistent static int Ses_CheckDepthConsistency( Ses_Man_t * pSes ) { int l, i, fAdded, nLevel; int fMaxGatesLevel2 = 1; Vec_IntClear( pSes->vStairDecVars ); pSes->fDecStructure = 0; for ( l = 0; l < pSes->nSpecVars; ++l ) { if ( pSes->pArrTimeProfile[l] >= pSes->nMaxDepth ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible arrival time (depth = %d, input = %d, arrival time = %d)", pSes->nMaxDepth, l, pSes->pArrTimeProfile[l] ); return 0; } else if ( pSes->nSpecFunc == 1 && pSes->pArrTimeProfile[l] + 1 == pSes->nMaxDepth ) { if ( ( pSes->fDecStructure == 1 && pSes->nSpecVars > 2 ) || pSes->fDecStructure == 2 ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible decomposition (depth = %d, input = %d, arrival time = %d)", pSes->nMaxDepth, l, pSes->pArrTimeProfile[l] ); return 0; } pSes->fDecStructure++; /* A subset B <=> A and B = A */ if ( !( ( pSes->pDecVars >> l ) & 1 ) ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible decomposition (depth = %d, input = %d, arrival time = %d)", pSes->nMaxDepth, l, pSes->pArrTimeProfile[l] ); return 0; } } } /* more complicated decomposition */ if ( pSes->fDecStructure ) { nLevel = 1; while ( 1 ) { fAdded = 0; for ( l = 0; l < pSes->nSpecVars; ++l ) if ( pSes->pArrTimeProfile[l] + nLevel == pSes->nMaxDepth ) { if ( fAdded ) { assert( nLevel == Vec_IntSize( pSes->vStairDecVars ) ); if ( fAdded > 1 || ( nLevel + 1 < pSes->nSpecVars ) ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible decomposition at level %d", nLevel ); return 0; } } else { Vec_IntPush( pSes->vStairDecVars, l ); } fAdded++; } if ( !fAdded ) break; ++nLevel; } if ( Vec_IntSize( pSes->vStairDecVars ) && !Abc_TtIsStairDecomposable( pSes->pSpec, pSes->nSpecWords, Vec_IntArray( pSes->vStairDecVars ), Vec_IntSize( pSes->vStairDecVars ), pSes->pStairDecFunc ) ) { if ( pSes->fReasonVerbose ) { printf( "give up due to impossible stair decomposition at level %d: ", nLevel ); Vec_IntPrint( pSes->vStairDecVars ); } return 0; } } /* check if depth's match with structure at second level from top */ if ( pSes->fDecStructure ) fMaxGatesLevel2 = ( pSes->nSpecVars == 3 ) ? 2 : 1; else fMaxGatesLevel2 = ( pSes->nSpecVars == 4 ) ? 4 : 3; i = 0; for ( l = 0; l < pSes->nSpecVars; ++l ) if ( pSes->pArrTimeProfile[l] + 2 == pSes->nMaxDepth ) if ( ++i > fMaxGatesLevel2 ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible decomposition at second level (depth = %d, input = %d, arrival time = %d)", pSes->nMaxDepth, l, pSes->pArrTimeProfile[l] ); return 0; } /* check if depth's match with structure at third level from top */ if ( pSes->nSpecVars > 4 && pSes->fDecStructure && i == 1 ) /* we have f = AND(x_i, AND(x_j, g)) (x_i and x_j may be complemented) */ { i = 0; for ( l = 0; l < pSes->nSpecVars; ++l ) if ( pSes->pArrTimeProfile[l] + 3 == pSes->nMaxDepth ) if ( ++i > 1 ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible decomposition at third level (depth = %d, input = %d, arrival time = %d)", pSes->nMaxDepth, l, pSes->pArrTimeProfile[l] ); return 0; } } return 1; } // returns 0, if current max depth and #gates are not consistent static int Ses_CheckGatesConsistency( Ses_Man_t * pSes, int nGates ) { /* give up if number of gates is impossible for given depth */ if ( pSes->nMaxDepth != -1 && nGates >= ( 1 << pSes->nMaxDepth ) ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible depth (depth = %d, gates = %d)", pSes->nMaxDepth, nGates ); return 0; } /* give up if number of gates is impossible for given depth and arrival times */ if ( pSes->nMaxDepth != -1 && pSes->pArrTimeProfile && nGates > pSes->nMaxGates ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible depth and arrival times (depth = %d, gates = %d)", pSes->nMaxDepth, nGates ); return 0; } if ( pSes->fDecStructure && nGates >= ( 1 << ( pSes->nMaxDepth - 1 ) ) + 1 ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible depth in AND-dec structure (depth = %d, gates = %d)", pSes->nMaxDepth, nGates ); return 0; } /* give up if number of gates gets practically too large */ if ( nGates >= ( 1 << pSes->nSpecVars ) ) { if ( pSes->fReasonVerbose ) printf( "give up due to impossible number of gates" ); return 0; } return 1; } static void Abc_ExactCopyDepthAndArrivalTimes( int nVars, int nDepthFrom, int * nDepthTo, int * pTimesFrom, int * pTimesTo ) { int l; *nDepthTo = nDepthFrom; for ( l = 0; l < nVars; ++l ) pTimesTo[l] = pTimesFrom[l]; } static void Ses_ManStoreDepthAndArrivalTimes( Ses_Man_t * pSes ) { if ( pSes->nMaxDepth == -1 ) return; Abc_ExactCopyDepthAndArrivalTimes( pSes->nSpecVars, pSes->nMaxDepth, &pSes->nMaxDepthTmp, pSes->pArrTimeProfile, pSes->pArrTimeProfileTmp ); } static void Ses_ManRestoreDepthAndArrivalTimes( Ses_Man_t * pSes ) { if ( pSes->nMaxDepth == -1 ) return; Abc_ExactCopyDepthAndArrivalTimes( pSes->nSpecVars, pSes->nMaxDepthTmp, &pSes->nMaxDepth, pSes->pArrTimeProfileTmp, pSes->pArrTimeProfile ); } static void Abc_ExactAdjustDepthAndArrivalTimes( int nVars, int nGates, int nDepthFrom, int * nDepthTo, int * pTimesFrom, int * pTimesTo, int nTimesMax ) { int l; *nDepthTo = Abc_MinInt( nDepthFrom, nGates ); for ( l = 0; l < nVars; ++l ) pTimesTo[l] = Abc_MinInt( pTimesFrom[l], Abc_MaxInt( 0, nGates - 1 - nTimesMax + pTimesFrom[l] ) ); } static void Ses_AdjustDepthAndArrivalTimes( Ses_Man_t * pSes, int nGates ) { Abc_ExactAdjustDepthAndArrivalTimes( pSes->nSpecVars, nGates, pSes->nMaxDepthTmp, &pSes->nMaxDepth, pSes->pArrTimeProfileTmp, pSes->pArrTimeProfile, pSes->nArrTimeMax - 1 ); } /* return: (2: continue, 1: found, 0: gave up) */ static int Ses_ManFindNetworkExact( Ses_Man_t * pSes, int nGates ) { int f, fSat; abctime timeStart; /* solve */ timeStart = Abc_Clock(); Vec_IntClear( pSes->vPolar ); Vec_IntClear( pSes->vAssump ); Ses_ManCreateVars( pSes, nGates ); if ( pSes->nMaxDepth != -1 ) { f = Ses_ManCreateDepthClauses( pSes ); pSes->timeInstance += ( Abc_Clock() - timeStart ); if ( !f ) return 2; /* proven UNSAT while creating clauses */ } sat_solver_set_polarity( pSes->pSat, Vec_IntArray( pSes->vPolar ), Vec_IntSize( pSes->vPolar ) ); /* first solve */ fSat = Ses_ManSolve( pSes ); if ( fSat == 0 ) return 2; /* UNSAT, continue with next # of gates */ else if ( fSat == 2 ) { pSes->fHitResLimit = 1; return 0; } timeStart = Abc_Clock(); f = Ses_ManCreateClauses( pSes ); pSes->timeInstance += ( Abc_Clock() - timeStart ); if ( !f ) return 2; /* proven UNSAT while creating clauses */ fSat = Ses_ManSolve( pSes ); if ( fSat == 1 ) return 1; else if ( fSat == 2 ) { pSes->fHitResLimit = 1; return 0; } return 2; /* UNSAT continue */ } // is there a network for a given number of gates /* return: (3: impossible, 2: continue, 1: found, 0: gave up) */ static int Ses_ManFindNetworkExactCEGAR( Ses_Man_t * pSes, int nGates, char ** pSol ) { int fRes, iMint, fSat, i; word pTruth[4]; /* debug */ Abc_DebugErase( pSes->nDebugOffset + ( nGates > 10 ? 5 : 4 ), pSes->fVeryVerbose ); Abc_DebugPrintIntInt( " (%d/%d)", nGates, pSes->nMaxGates, pSes->fVeryVerbose ); /* do #gates and max depth allow for a network? */ if ( !Ses_CheckGatesConsistency( pSes, nGates ) ) return 3; for ( i = 0; i < pSes->nRandRowAssigns; ++i ) Abc_TtSetBit( pSes->pTtValues, rand() % pSes->nRows ); fRes = Ses_ManFindNetworkExact( pSes, nGates ); if ( fRes != 1 ) return fRes; while ( true ) { *pSol = Ses_ManExtractSolution( pSes ); Abc_TtXor( pTruth, Ses_ManDeriveTruth( pSes, *pSol, 0 ), pSes->pSpec, pSes->nSpecWords, 0 ); iMint = Abc_TtFindFirstBit( pTruth, pSes->nSpecVars ); if ( iMint == -1 || (pSes->nSpecVars < 6 && iMint > pSes->nRows) ) { assert( fRes == 1 ); return 1; } ABC_FREE( *pSol ); if ( pSes->fKeepRowAssigns ) Abc_TtSetBit( pSes->pTtValues, iMint - 1 ); if ( !Ses_ManCreateTruthTableClause( pSes, iMint - 1 ) ) /* UNSAT, continue */ return 2; if ( ( fSat = Ses_ManSolve( pSes ) ) == 1 ) continue; return ( fSat == 2 ) ? 0 : 2; } } // find minimum size by increasing the number of gates static char * Ses_ManFindMinimumSizeBottomUp( Ses_Man_t * pSes ) { int nGates = pSes->nStartGates, fRes; char * pSol = NULL; /* store whether call was unsuccessful due to resource limit and not due to impossible constraint */ pSes->fHitResLimit = 0; pSes->nDebugOffset = pSes->nMaxGates >= 10 ? 3 : 2; /* adjust number of gates if there is a stair decomposition */ if ( Vec_IntSize( pSes->vStairDecVars ) ) nGates = Abc_MaxInt( nGates, Vec_IntSize( pSes->vStairDecVars ) - 1 ); //Ses_ManStoreDepthAndArrivalTimes( pSes ); memset( pSes->pTtValues, 0, 4 * sizeof( word ) ); Abc_DebugPrintIntInt( " (%d/%d)", nGates, pSes->nMaxGates, pSes->fVeryVerbose ); while ( true ) { ++nGates; fRes = Ses_ManFindNetworkExactCEGAR( pSes, nGates, &pSol ); if ( fRes == 0 ) { pSes->fHitResLimit = 1; break; } else if ( fRes == 1 || fRes == 3 ) break; } Abc_DebugErase( pSes->nDebugOffset + ( nGates >= 10 ? 5 : 4 ), pSes->fVeryVerbose ); return pSol; } static char * Ses_ManFindMinimumSizeTopDown( Ses_Man_t * pSes, int nMinGates ) { int nGates = pSes->nMaxGates, fRes; char * pSol = NULL, * pSol2 = NULL; pSes->fHitResLimit = 0; Abc_DebugPrintIntInt( " (%d/%d)", nGates, pSes->nMaxGates, pSes->fVeryVerbose ); while ( true ) { fRes = Ses_ManFindNetworkExactCEGAR( pSes, nGates, &pSol2 ); if ( fRes == 0 ) { pSes->fHitResLimit = 1; break; } else if ( fRes == 2 || fRes == 3 ) break; pSol = pSol2; if ( nGates == nMinGates ) break; --nGates; } Abc_DebugErase( pSes->nDebugOffset + ( nGates >= 10 ? 5 : 4 ), pSes->fVeryVerbose ); return pSol; } static char * Ses_ManFindMinimumSize( Ses_Man_t * pSes ) { char * pSol = NULL; int i = pSes->nStartGates + 1, fRes; /* if more than one function, no CEGAR */ if ( pSes->nSpecFunc > 1 ) { while ( true ) { if ( pSes->fVerbose ) { printf( "try with %d gates\n", i ); } memset( pSes->pTtValues, ~0, 4 * sizeof( word ) ); fRes = Ses_ManFindNetworkExact( pSes, i++ ); if ( fRes == 2 ) continue; if ( fRes == 0 ) break; pSol = Ses_ManExtractSolution( pSes ); break; } return pSol; } /* do the arrival times allow for a network? */ if ( pSes->nMaxDepth != -1 && pSes->pArrTimeProfile ) { if ( !Ses_CheckDepthConsistency( pSes ) ) return 0; Ses_ManComputeMaxGates( pSes ); } pSol = Ses_ManFindMinimumSizeBottomUp( pSes ); if ( !pSol && pSes->nMaxDepth != -1 && pSes->fHitResLimit && pSes->nGates != pSes->nMaxGates ) return Ses_ManFindMinimumSizeTopDown( pSes, pSes->nGates + 1 ); else return pSol; } /**Function************************************************************* Synopsis [Find minimum size networks with a SAT solver.] Description [If nMaxDepth is -1, then depth constraints are ignored. If nMaxDepth is not -1, one can set pArrTimeProfile which should have the length of nVars. One can ignore pArrTimeProfile by setting it to NULL.] SideEffects [] SeeAlso [] ***********************************************************************/ Abc_Ntk_t * Abc_NtkFindExact( word * pTruth, int nVars, int nFunc, int nMaxDepth, int * pArrTimeProfile, int nBTLimit, int nStartGates, int fVerbose ) { Ses_Man_t * pSes; char * pSol; Abc_Ntk_t * pNtk = NULL; abctime timeStart; /* some checks */ assert( nVars >= 2 && nVars <= 8 ); timeStart = Abc_Clock(); pSes = Ses_ManAlloc( pTruth, nVars, nFunc, nMaxDepth, pArrTimeProfile, 0, nBTLimit, fVerbose ); pSes->nStartGates = nStartGates; pSes->fReasonVerbose = 0; pSes->fSatVerbose = 0; if ( fVerbose ) Ses_ManPrintFuncs( pSes ); if ( ( pSol = Ses_ManFindMinimumSize( pSes ) ) != NULL ) { pNtk = Ses_ManExtractNtk( pSol ); ABC_FREE( pSol ); } pSes->timeTotal = Abc_Clock() - timeStart; if ( fVerbose ) Ses_ManPrintRuntime( pSes ); /* cleanup */ Ses_ManClean( pSes ); return pNtk; } Gia_Man_t * Gia_ManFindExact( word * pTruth, int nVars, int nFunc, int nMaxDepth, int * pArrTimeProfile, int nBTLimit, int nStartGates, int fVerbose ) { Ses_Man_t * pSes; char * pSol; Gia_Man_t * pGia = NULL; abctime timeStart; /* some checks */ assert( nVars >= 2 && nVars <= 8 ); timeStart = Abc_Clock(); pSes = Ses_ManAlloc( pTruth, nVars, nFunc, nMaxDepth, pArrTimeProfile, 1, nBTLimit, fVerbose ); pSes->nStartGates = nStartGates; pSes->fVeryVerbose = 1; pSes->fExtractVerbose = 0; pSes->fSatVerbose = 0; pSes->fReasonVerbose = 1; if ( fVerbose ) Ses_ManPrintFuncs( pSes ); if ( ( pSol = Ses_ManFindMinimumSize( pSes ) ) != NULL ) { pGia = Ses_ManExtractGia( pSol ); ABC_FREE( pSol ); } pSes->timeTotal = Abc_Clock() - timeStart; if ( fVerbose ) Ses_ManPrintRuntime( pSes ); /* cleanup */ Ses_ManClean( pSes ); return pGia; } /**Function************************************************************* Synopsis [Some test cases.] ***********************************************************************/ Abc_Ntk_t * Abc_NtkFromTruthTable( word * pTruth, int nVars ) { Abc_Ntk_t * pNtk; Mem_Flex_t * pMan; char * pSopCover; pMan = Mem_FlexStart(); pSopCover = Abc_SopCreateFromTruth( pMan, nVars, (unsigned*)pTruth ); pNtk = Abc_NtkCreateWithNode( pSopCover ); Abc_NtkShortNames( pNtk ); Mem_FlexStop( pMan, 0 ); return pNtk; } void Abc_ExactTestSingleOutput( int fVerbose ) { extern void Abc_NtkCecSat( Abc_Ntk_t * pNtk1, Abc_Ntk_t * pNtk2, int nConfLimit, int nInsLimit ); word pTruth[4] = {0xcafe, 0, 0, 0}; Abc_Ntk_t * pNtk, * pNtk2, * pNtk3, * pNtk4; int pArrTimeProfile[4] = {6, 2, 8, 5}; pNtk = Abc_NtkFromTruthTable( pTruth, 4 ); pNtk2 = Abc_NtkFindExact( pTruth, 4, 1, -1, NULL, 0, 0, fVerbose ); Abc_NtkShortNames( pNtk2 ); Abc_NtkCecSat( pNtk, pNtk2, 10000, 0 ); assert( pNtk2 ); assert( Abc_NtkNodeNum( pNtk2 ) == 6 ); Abc_NtkDelete( pNtk2 ); pNtk3 = Abc_NtkFindExact( pTruth, 4, 1, 3, NULL, 0, 0, fVerbose ); Abc_NtkShortNames( pNtk3 ); Abc_NtkCecSat( pNtk, pNtk3, 10000, 0 ); assert( pNtk3 ); assert( Abc_NtkLevel( pNtk3 ) <= 3 ); Abc_NtkDelete( pNtk3 ); pNtk4 = Abc_NtkFindExact( pTruth, 4, 1, 9, pArrTimeProfile, 50000, 0, fVerbose ); Abc_NtkShortNames( pNtk4 ); Abc_NtkCecSat( pNtk, pNtk4, 10000, 0 ); assert( pNtk4 ); assert( Abc_NtkLevel( pNtk4 ) <= 9 ); Abc_NtkDelete( pNtk4 ); assert( !Abc_NtkFindExact( pTruth, 4, 1, 2, NULL, 50000, 0, fVerbose ) ); assert( !Abc_NtkFindExact( pTruth, 4, 1, 8, pArrTimeProfile, 50000, 0, fVerbose ) ); Abc_NtkDelete( pNtk ); } void Abc_ExactTestSingleOutputAIG( int fVerbose ) { word pTruth[4] = {0xcafe, 0, 0, 0}; Abc_Ntk_t * pNtk; Gia_Man_t * pGia, * pGia2, * pGia3, * pGia4, * pMiter; Cec_ParCec_t ParsCec, * pPars = &ParsCec; int pArrTimeProfile[4] = {6, 2, 8, 5}; Cec_ManCecSetDefaultParams( pPars ); pNtk = Abc_NtkFromTruthTable( pTruth, 4 ); Abc_NtkToAig( pNtk ); pGia = Abc_NtkAigToGia( pNtk, 1 ); pGia2 = Gia_ManFindExact( pTruth, 4, 1, -1, NULL, 0, 0, fVerbose ); pMiter = Gia_ManMiter( pGia, pGia2, 0, 1, 0, 0, 1 ); assert( pMiter ); Cec_ManVerify( pMiter, pPars ); Gia_ManStop( pMiter ); pGia3 = Gia_ManFindExact( pTruth, 4, 1, 3, NULL, 0, 0, fVerbose ); pMiter = Gia_ManMiter( pGia, pGia3, 0, 1, 0, 0, 1 ); assert( pMiter ); Cec_ManVerify( pMiter, pPars ); Gia_ManStop( pMiter ); pGia4 = Gia_ManFindExact( pTruth, 4, 1, 9, pArrTimeProfile, 50000, 0, fVerbose ); pMiter = Gia_ManMiter( pGia, pGia4, 0, 1, 0, 0, 1 ); assert( pMiter ); Cec_ManVerify( pMiter, pPars ); Gia_ManStop( pMiter ); assert( !Gia_ManFindExact( pTruth, 4, 1, 2, NULL, 50000, 0, fVerbose ) ); assert( !Gia_ManFindExact( pTruth, 4, 1, 8, pArrTimeProfile, 50000, 0, fVerbose ) ); Gia_ManStop( pGia ); Gia_ManStop( pGia2 ); Gia_ManStop( pGia3 ); Gia_ManStop( pGia4 ); } void Abc_ExactTest( int fVerbose ) { Abc_ExactTestSingleOutput( fVerbose ); Abc_ExactTestSingleOutputAIG( fVerbose ); printf( "\n" ); } /**Function************************************************************* Synopsis [APIs for integraging with the mapper.] ***********************************************************************/ // may need to have a static pointer to the SAT-based synthesis engine and/or loaded library // this procedure should return 1, if the engine/library are available, and 0 otherwise int Abc_ExactIsRunning() { return s_pSesStore != NULL; } // this procedure returns the number of inputs of the library // for example, somebody may try to map into 10-cuts while the library only contains 8-functions int Abc_ExactInputNum() { return 8; } // start exact store manager void Abc_ExactStart( int nBTLimit, int fMakeAIG, int fVerbose, int fVeryVerbose, const char * pFilename ) { if ( !s_pSesStore ) { s_pSesStore = Ses_StoreAlloc( nBTLimit, fMakeAIG, fVerbose ); s_pSesStore->fVeryVerbose = fVeryVerbose; if ( pFilename ) { Ses_StoreRead( s_pSesStore, pFilename, 1, 0, 0, 0 ); s_pSesStore->szDBName = ABC_CALLOC( char, strlen( pFilename ) + 1 ); strcpy( s_pSesStore->szDBName, pFilename ); } if ( s_pSesStore->fVeryVerbose ) { s_pSesStore->pDebugEntries = fopen( "bms.debug", "w" ); } } else printf( "BMS manager already started\n" ); } // stop exact store manager void Abc_ExactStop( const char * pFilename ) { if ( s_pSesStore ) { if ( pFilename ) Ses_StoreWrite( s_pSesStore, pFilename, 1, 0, 0, 0 ); if ( s_pSesStore->pDebugEntries ) fclose( s_pSesStore->pDebugEntries ); Ses_StoreClean( s_pSesStore ); } else printf( "BMS manager has not been started\n" ); } // show statistics about store manager void Abc_ExactStats() { int i; if ( !s_pSesStore ) { printf( "BMS manager has not been started\n" ); return; } printf( "-------------------------------------------------------------------------------------------------------------------------------\n" ); printf( " 0 1 2 3 4 5 6 7 8 total\n" ); printf( "-------------------------------------------------------------------------------------------------------------------------------\n" ); printf( "number of considered cuts :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pCutCount[i] ); printf( "%10lu\n", s_pSesStore->nCutCount ); printf( " - trivial :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pSynthesizedTrivial[i] ); printf( "%10lu\n", s_pSesStore->nSynthesizedTrivial ); printf( " - synth (imp) :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pSynthesizedImp[i] ); printf( "%10lu\n", s_pSesStore->nSynthesizedImp ); printf( " - synth (res) :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pSynthesizedRL[i] ); printf( "%10lu\n", s_pSesStore->nSynthesizedRL ); printf( " - not synth (imp) :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pUnsynthesizedImp[i] ); printf( "%10lu\n", s_pSesStore->nUnsynthesizedImp ); printf( " - not synth (res) :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pUnsynthesizedRL[i] ); printf( "%10lu\n", s_pSesStore->nUnsynthesizedRL ); printf( " - cache hits :" ); for ( i = 0; i < 9; ++i ) printf( "%10lu", s_pSesStore->pCacheHits[i] ); printf( "%10lu\n", s_pSesStore->nCacheHits ); printf( "-------------------------------------------------------------------------------------------------------------------------------\n" ); printf( "number of entries : %d\n", s_pSesStore->nEntriesCount ); printf( "number of valid entries : %d\n", s_pSesStore->nValidEntriesCount ); printf( "number of invalid entries : %d\n", s_pSesStore->nEntriesCount - s_pSesStore->nValidEntriesCount ); printf( "-------------------------------------------------------------------------------------------------------------------------------\n" ); printf( "number of SAT calls : %lu\n", s_pSesStore->nSatCalls ); printf( "number of UNSAT calls : %lu\n", s_pSesStore->nUnsatCalls ); printf( "number of UNDEF calls : %lu\n", s_pSesStore->nUndefCalls ); printf( "-------------------------------------------------------------------------------------------------------------------------------\n" ); printf( "Runtime breakdown:\n" ); ABC_PRTP( "Exact ", s_pSesStore->timeExact, s_pSesStore->timeTotal ); ABC_PRTP( " Sat ", s_pSesStore->timeSat, s_pSesStore->timeTotal ); ABC_PRTP( " Sat ", s_pSesStore->timeSatSat, s_pSesStore->timeTotal ); ABC_PRTP( " Unsat ", s_pSesStore->timeSatUnsat, s_pSesStore->timeTotal ); ABC_PRTP( " Undef ", s_pSesStore->timeSatUndef, s_pSesStore->timeTotal ); ABC_PRTP( " Instance", s_pSesStore->timeInstance, s_pSesStore->timeTotal ); ABC_PRTP( "Other ", s_pSesStore->timeTotal - s_pSesStore->timeExact, s_pSesStore->timeTotal ); ABC_PRTP( "ALL ", s_pSesStore->timeTotal, s_pSesStore->timeTotal ); } // this procedure takes TT and input arrival times (pArrTimeProfile) and return the smallest output arrival time; // it also returns the pin-to-pin delays (pPerm) between each cut leaf and the cut output and the cut area cost (Cost) // the area cost should not exceed 2048, if the cut is implementable; otherwise, it should be ABC_INFINITY int Abc_ExactDelayCost( word * pTruth, int nVars, int * pArrTimeProfile, char * pPerm, int * Cost, int AigLevel ) { int i, nMaxArrival, nDelta, l; Ses_Man_t * pSes = NULL; char * pSol = NULL, * pSol2 = NULL, * p; int pNormalArrTime[8]; int Delay = ABC_INFINITY, nMaxDepth, fResLimit; abctime timeStart = Abc_Clock(), timeStartExact; /* some checks */ if ( nVars < 0 || nVars > 8 ) { printf( "invalid truth table size %d\n", nVars ); assert( 0 ); } /* statistics */ s_pSesStore->nCutCount++; s_pSesStore->pCutCount[nVars]++; if ( nVars == 0 ) { s_pSesStore->nSynthesizedTrivial++; s_pSesStore->pSynthesizedTrivial[0]++; *Cost = 0; s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return 0; } if ( nVars == 1 ) { s_pSesStore->nSynthesizedTrivial++; s_pSesStore->pSynthesizedTrivial[1]++; *Cost = 0; pPerm[0] = (char)0; s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return pArrTimeProfile[0]; } for ( l = 0; l < nVars; ++l ) pNormalArrTime[l] = pArrTimeProfile[l]; nDelta = Abc_NormalizeArrivalTimes( pNormalArrTime, nVars, &nMaxArrival ); *Cost = ABC_INFINITY; if ( Ses_StoreGetEntry( s_pSesStore, pTruth, nVars, pNormalArrTime, &pSol ) ) { s_pSesStore->nCacheHits++; s_pSesStore->pCacheHits[nVars]++; } else { if ( s_pSesStore->fVeryVerbose ) { printf( ANSI_COLOR_CYAN ); Abc_TtPrintHexRev( stdout, pTruth, nVars ); printf( ANSI_COLOR_RESET ); printf( " [%d", pNormalArrTime[0] ); for ( l = 1; l < nVars; ++l ) printf( " %d", pNormalArrTime[l] ); printf( "]@%d:", AigLevel ); fflush( stdout ); } nMaxDepth = pNormalArrTime[0]; for ( i = 1; i < nVars; ++i ) nMaxDepth = Abc_MaxInt( nMaxDepth, pNormalArrTime[i] ); nMaxDepth += nVars + 1; if ( AigLevel != -1 ) nMaxDepth = Abc_MinInt( AigLevel - nDelta, nMaxDepth + nVars + 1 ); timeStartExact = Abc_Clock(); pSes = Ses_ManAlloc( pTruth, nVars, 1 /* nSpecFunc */, nMaxDepth, pNormalArrTime, s_pSesStore->fMakeAIG, s_pSesStore->nBTLimit, s_pSesStore->fVerbose ); pSes->fVeryVerbose = s_pSesStore->fVeryVerbose; pSes->pSat = s_pSesStore->pSat; pSes->nStartGates = nVars - 2; while ( pSes->nMaxDepth ) /* there is improvement */ { if ( s_pSesStore->fVeryVerbose ) { printf( " %d", pSes->nMaxDepth ); fflush( stdout ); } if ( ( pSol2 = Ses_ManFindMinimumSize( pSes ) ) != NULL ) { if ( s_pSesStore->fVeryVerbose ) { if ( pSes->nMaxDepth >= 10 ) printf( "\b" ); printf( "\b" ANSI_COLOR_GREEN "%d" ANSI_COLOR_RESET, pSes->nMaxDepth ); } if ( pSol ) ABC_FREE( pSol ); pSol = pSol2; pSes->nMaxDepth--; } else { if ( s_pSesStore->fVeryVerbose ) { if ( pSes->nMaxDepth >= 10 ) printf( "\b" ); printf( "\b%s%d" ANSI_COLOR_RESET, pSes->fHitResLimit ? ANSI_COLOR_RED : ANSI_COLOR_YELLOW, pSes->nMaxDepth ); } break; } } if ( s_pSesStore->fVeryVerbose ) printf( " \n" ); /* log unsuccessful case for debugging */ if ( s_pSesStore->pDebugEntries && pSes->fHitResLimit ) Ses_StorePrintDebugEntry( s_pSesStore, pTruth, nVars, pNormalArrTime, pSes->nMaxDepth, pSol, nVars - 2 ); pSes->timeTotal = Abc_Clock() - timeStartExact; /* statistics */ s_pSesStore->nSatCalls += pSes->nSatCalls; s_pSesStore->nUnsatCalls += pSes->nUnsatCalls; s_pSesStore->nUndefCalls += pSes->nUndefCalls; s_pSesStore->timeSat += pSes->timeSat; s_pSesStore->timeSatSat += pSes->timeSatSat; s_pSesStore->timeSatUnsat += pSes->timeSatUnsat; s_pSesStore->timeSatUndef += pSes->timeSatUndef; s_pSesStore->timeInstance += pSes->timeInstance; s_pSesStore->timeExact += pSes->timeTotal; /* cleanup (we need to clean before adding since pTruth may have been modified by pSes) */ fResLimit = pSes->fHitResLimit; Ses_ManCleanLight( pSes ); /* store solution */ Ses_StoreAddEntry( s_pSesStore, pTruth, nVars, pNormalArrTime, pSol, fResLimit ); } if ( pSol ) { *Cost = pSol[ABC_EXACT_SOL_NGATES]; p = pSol + 3 + 4 * pSol[ABC_EXACT_SOL_NGATES] + 1; Delay = *p++; for ( l = 0; l < nVars; ++l ) pPerm[l] = *p++; } if ( pSol ) { int Delay2 = 0; for ( l = 0; l < nVars; ++l ) { //printf( "%d ", pPerm[l] ); Delay2 = Abc_MaxInt( Delay2, pArrTimeProfile[l] + pPerm[l] ); } //printf( " output arrival = %d recomputed = %d\n", Delay, Delay2 ); //if ( Delay != Delay2 ) //{ // printf( "^--- BUG!\n" ); // assert( 0 ); //} s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return Delay2; } else { assert( *Cost == ABC_INFINITY ); s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return ABC_INFINITY; } } // this procedure returns a new node whose output in terms of the given fanins // has the smallest possible arrival time (in agreement with the above Abc_ExactDelayCost) Abc_Obj_t * Abc_ExactBuildNode( word * pTruth, int nVars, int * pArrTimeProfile, Abc_Obj_t ** pFanins, Abc_Ntk_t * pNtk ) { char * pSol = NULL; int i, j, nMaxArrival; int pNormalArrTime[8]; char const * p; Abc_Obj_t * pObj; Vec_Ptr_t * pGates; char pGateTruth[5]; char * pSopCover; abctime timeStart = Abc_Clock(); if ( nVars == 0 ) { s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return (pTruth[0] & 1) ? Abc_NtkCreateNodeConst1(pNtk) : Abc_NtkCreateNodeConst0(pNtk); } if ( nVars == 1 ) { s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return (pTruth[0] & 1) ? Abc_NtkCreateNodeInv(pNtk, pFanins[0]) : Abc_NtkCreateNodeBuf(pNtk, pFanins[0]); } for ( i = 0; i < nVars; ++i ) pNormalArrTime[i] = pArrTimeProfile[i]; Abc_NormalizeArrivalTimes( pNormalArrTime, nVars, &nMaxArrival ); assert( Ses_StoreGetEntry( s_pSesStore, pTruth, nVars, pNormalArrTime, &pSol ) ); if ( !pSol ) { s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return NULL; } assert( pSol[ABC_EXACT_SOL_NVARS] == nVars ); assert( pSol[ABC_EXACT_SOL_NFUNC] == 1 ); pGates = Vec_PtrAlloc( nVars + pSol[ABC_EXACT_SOL_NGATES] ); pGateTruth[3] = '0'; pGateTruth[4] = '\0'; /* primary inputs */ for ( i = 0; i < nVars; ++i ) { assert( pFanins[i] ); Vec_PtrPush( pGates, pFanins[i] ); } /* gates */ p = pSol + 3; for ( i = 0; i < pSol[ABC_EXACT_SOL_NGATES]; ++i ) { pGateTruth[2] = '0' + ( *p & 1 ); pGateTruth[1] = '0' + ( ( *p >> 1 ) & 1 ); pGateTruth[0] = '0' + ( ( *p >> 2 ) & 1 ); ++p; assert( *p == 2 ); /* binary gate */ ++p; /* invert truth table if we are last gate and inverted */ if ( i + 1 == pSol[ABC_EXACT_SOL_NGATES] && Abc_LitIsCompl( *( p + 2 ) ) ) for ( j = 0; j < 4; ++j ) pGateTruth[j] = ( pGateTruth[j] == '0' ) ? '1' : '0'; pSopCover = Abc_SopFromTruthBin( pGateTruth ); pObj = Abc_NtkCreateNode( pNtk ); assert( pObj ); pObj->pData = Abc_SopRegister( (Mem_Flex_t*)pNtk->pManFunc, pSopCover ); Vec_PtrPush( pGates, pObj ); ABC_FREE( pSopCover ); Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) ); Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) ); } /* output */ pObj = (Abc_Obj_t *)Vec_PtrEntry( pGates, nVars + Abc_Lit2Var( *p ) ); Vec_PtrFree( pGates ); s_pSesStore->timeTotal += ( Abc_Clock() - timeStart ); return pObj; } void Abc_ExactStoreTest( int fVerbose ) { int i; word pTruth[4] = {0xcafe, 0, 0, 0}; int pArrTimeProfile[4] = {6, 2, 8, 5}; Abc_Ntk_t * pNtk; Abc_Obj_t * pFanins[4]; Vec_Ptr_t * vNames; char pPerm[4] = {0}; int Cost = 0; pNtk = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 ); pNtk->pName = Extra_UtilStrsav( "exact" ); vNames = Abc_NodeGetFakeNames( 4u ); /* primary inputs */ Vec_PtrPush( pNtk->vObjs, NULL ); for ( i = 0; i < 4; ++i ) { pFanins[i] = Abc_NtkCreatePi( pNtk ); Abc_ObjAssignName( pFanins[i], (char*)Vec_PtrEntry( vNames, i ), NULL ); } Abc_NodeFreeNames( vNames ); Abc_ExactStart( 10000, 1, fVerbose, 0, NULL ); assert( !Abc_ExactBuildNode( pTruth, 4, pArrTimeProfile, pFanins, pNtk ) ); assert( Abc_ExactDelayCost( pTruth, 4, pArrTimeProfile, pPerm, &Cost, 12 ) == 1 ); assert( Abc_ExactBuildNode( pTruth, 4, pArrTimeProfile, pFanins, pNtk ) ); (*pArrTimeProfile)++; assert( !Abc_ExactBuildNode( pTruth, 4, pArrTimeProfile, pFanins, pNtk ) ); (*pArrTimeProfile)--; Abc_ExactStop( NULL ); Abc_NtkDelete( pNtk ); } //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// ABC_NAMESPACE_IMPL_END