| /**CFile**************************************************************** |
| |
| FileName [plaSimple.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [SOP manager.] |
| |
| Synopsis [Scalable SOP transformations.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - March 18, 2015.] |
| |
| Revision [$Id: plaSimple.c,v 1.00 2014/09/12 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "pla.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Dump PLA manager into a BLIF file.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Pla_ManDumpPla( Pla_Man_t * p, char * pFileName ) |
| { |
| // find the number of original variables |
| //int nVarsInit = Pla_ManDivNum(p) ? Vec_IntCountZero(&p->vDivs) : Pla_ManInNum(p); |
| FILE * pFile = fopen( pFileName, "wb" ); |
| if ( pFile == NULL ) |
| printf( "Cannot open file \"%s\" for writing.\n", pFileName ); |
| else |
| { |
| //char * pLits = "-01?"; |
| Vec_Str_t * vStr; |
| Vec_Int_t * vCube; |
| int i, k, Lit; |
| // comment |
| fprintf( pFile, "# PLA file written via PLA package in ABC on " ); |
| fprintf( pFile, "%s", Extra_TimeStamp() ); |
| fprintf( pFile, "\n\n" ); |
| // header |
| fprintf( pFile, ".i %d\n", Pla_ManInNum(p) ); |
| fprintf( pFile, ".o %d\n", 1 ); |
| fprintf( pFile, ".p %d\n", Vec_WecSize(&p->vCubeLits) ); |
| // SOP |
| vStr = Vec_StrStart( Pla_ManInNum(p) + 1 ); |
| Vec_WecForEachLevel( &p->vCubeLits, vCube, i ) |
| { |
| if ( !Vec_IntSize(vCube) ) |
| continue; |
| for ( k = 0; k < Pla_ManInNum(p); k++ ) |
| Vec_StrWriteEntry( vStr, k, '-' ); |
| Vec_IntForEachEntry( vCube, Lit, k ) |
| Vec_StrWriteEntry( vStr, Abc_Lit2Var(Lit), (char)(Abc_LitIsCompl(Lit) ? '0' : '1') ); |
| fprintf( pFile, "%s 1\n", Vec_StrArray(vStr) ); |
| } |
| Vec_StrFree( vStr ); |
| fprintf( pFile, ".e\n\n" ); |
| fclose( pFile ); |
| printf( "Written file \"%s\".\n", pFileName ); |
| } |
| } |
| void Pla_ManDumpBlif( Pla_Man_t * p, char * pFileName ) |
| { |
| // find the number of original variables |
| int nVarsInit = Pla_ManDivNum(p) ? Vec_IntCountZero(&p->vDivs) : Pla_ManInNum(p); |
| FILE * pFile = fopen( pFileName, "wb" ); |
| if ( pFile == NULL ) |
| printf( "Cannot open file \"%s\" for writing.\n", pFileName ); |
| else |
| { |
| //char * pLits = "-01?"; |
| Vec_Str_t * vStr; |
| Vec_Int_t * vCube; |
| int i, k, Lit, Div; |
| // comment |
| fprintf( pFile, "# BLIF file written via PLA package in ABC on " ); |
| fprintf( pFile, "%s", Extra_TimeStamp() ); |
| fprintf( pFile, "\n\n" ); |
| // header |
| fprintf( pFile, ".model %s\n", Pla_ManName(p) ); |
| fprintf( pFile, ".inputs" ); |
| for ( i = 0; i < nVarsInit; i++ ) |
| fprintf( pFile, " i%d", i ); |
| fprintf( pFile, "\n" ); |
| fprintf( pFile, ".outputs o" ); |
| fprintf( pFile, "\n" ); |
| // SOP |
| fprintf( pFile, ".names" ); |
| for ( i = 0; i < Pla_ManInNum(p); i++ ) |
| fprintf( pFile, " i%d", i ); |
| fprintf( pFile, " o\n" ); |
| vStr = Vec_StrStart( Pla_ManInNum(p) + 1 ); |
| Vec_WecForEachLevel( &p->vCubeLits, vCube, i ) |
| { |
| for ( k = 0; k < Pla_ManInNum(p); k++ ) |
| Vec_StrWriteEntry( vStr, k, '-' ); |
| Vec_IntForEachEntry( vCube, Lit, k ) |
| Vec_StrWriteEntry( vStr, Abc_Lit2Var(Lit), (char)(Abc_LitIsCompl(Lit) ? '0' : '1') ); |
| fprintf( pFile, "%s 1\n", Vec_StrArray(vStr) ); |
| } |
| Vec_StrFree( vStr ); |
| // divisors |
| Vec_IntForEachEntryStart( &p->vDivs, Div, i, nVarsInit ) |
| { |
| int pLits[3] = { (Div >> 2) & 0x3FF, (Div >> 12) & 0x3FF, (Div >> 22) & 0x3FF }; |
| fprintf( pFile, ".names" ); |
| fprintf( pFile, " i%d", Abc_Lit2Var(pLits[0]) ); |
| fprintf( pFile, " i%d", Abc_Lit2Var(pLits[1]) ); |
| if ( (Div & 3) == 3 ) // MUX |
| fprintf( pFile, " i%d", Abc_Lit2Var(pLits[2]) ); |
| fprintf( pFile, " i%d\n", i ); |
| if ( (Div & 3) == 1 ) // AND |
| fprintf( pFile, "%d%d 1\n", !Abc_LitIsCompl(pLits[0]), !Abc_LitIsCompl(pLits[1]) ); |
| else if ( (Div & 3) == 2 ) // XOR |
| { |
| assert( !Abc_LitIsCompl(pLits[0]) ); |
| assert( !Abc_LitIsCompl(pLits[1]) ); |
| fprintf( pFile, "10 1\n01 1\n" ); |
| } |
| else if ( (Div & 3) == 3 ) // MUX |
| { |
| assert( !Abc_LitIsCompl(pLits[1]) ); |
| assert( !Abc_LitIsCompl(pLits[2]) ); |
| fprintf( pFile, "%d-0 1\n-11 1\n", !Abc_LitIsCompl(pLits[0]) ); |
| } |
| else assert( 0 ); |
| } |
| fprintf( pFile, ".end\n\n" ); |
| fclose( pFile ); |
| printf( "Written file \"%s\".\n", pFileName ); |
| } |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Transforms truth table into an SOP manager.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Pla_ManExpendDirNum( word * pOn, int nBits, int iMint, int * pVars ) |
| { |
| int v, nVars = 0; |
| for ( v = 0; v < nBits; v++ ) |
| if ( Pla_TtGetBit(pOn, iMint ^ (1 << v)) ) |
| pVars[nVars++] = v; |
| return nVars; |
| } |
| void Pla_PrintBinary( word * pT, int nBits ) |
| { |
| int v; |
| for ( v = 0; v < nBits; v++ ) |
| printf( "%d", Pla_TtGetBit(pT, v) ); |
| printf( "\n" ); |
| } |
| Vec_Wrd_t * Pla_ManFxMinimize( word * pOn, int nVars ) |
| { |
| int i, v, iMint, iVar, nMints = (1 << nVars); |
| int nWords = Abc_Bit6WordNum( nMints ); |
| Vec_Wrd_t * vCubes = Vec_WrdAlloc( 1000 ); |
| word * pDc = ABC_CALLOC( word, nWords ); |
| int Count[32] = {0}; |
| int Cubes[32] = {0}; |
| Vec_Int_t * vStore = Vec_IntAlloc( 1000 ); |
| |
| // count the number of expansion directions |
| for ( i = 0; i < nMints; i++ ) |
| if ( Pla_TtGetBit(pOn, i) && !Pla_TtGetBit(pDc, i) ) |
| { |
| int pDirs[32], nDirs = Pla_ManExpendDirNum(pOn, nVars, i, pDirs); |
| Count[nDirs]++; |
| if ( nDirs == 0 ) |
| { |
| Pla_TtSetBit(pDc, i); |
| Cubes[0]++; |
| // save |
| Vec_IntPushTwo( vStore, i, -1 ); |
| continue; |
| } |
| if ( nDirs == 1 ) |
| { |
| //Pla_PrintBinary( (word *)&i, nVars ); |
| //printf( " %d \n", pDirs[0] ); |
| |
| Pla_TtSetBit(pDc, i); |
| Pla_TtSetBit(pDc, i ^ (1 << pDirs[0])); |
| Cubes[1]++; |
| // save |
| Vec_IntPushTwo( vStore, i, pDirs[0] ); |
| continue; |
| } |
| if ( nDirs == 2 && Pla_TtGetBit(pOn, i ^ (1 << pDirs[0]) ^ (1 << pDirs[1])) ) |
| { |
| assert( 0 ); |
| Pla_TtSetBit(pDc, i); |
| Pla_TtSetBit(pDc, i ^ (1 << pDirs[0])); |
| Pla_TtSetBit(pDc, i ^ (1 << pDirs[1])); |
| Pla_TtSetBit(pDc, i ^ (1 << pDirs[0]) ^ (1 << pDirs[1])); |
| Cubes[2]++; |
| continue; |
| } |
| } |
| |
| // go through the remaining cubes |
| for ( i = 0; i < nMints; i++ ) |
| if ( Pla_TtGetBit(pOn, i) && !Pla_TtGetBit(pDc, i) ) |
| { |
| int pDirs[32], nDirs = Pla_ManExpendDirNum(pOn, nVars, i, pDirs); |
| // find direction, which is not taken |
| for ( v = 0; v < nDirs; v++ ) |
| if ( Pla_TtGetBit(pOn, i ^ (1 << pDirs[v])) && !Pla_TtGetBit(pDc, i ^ (1 << pDirs[v])) ) |
| break; |
| // if there is no open directions, use any one |
| if ( v == nDirs ) |
| v = 0; |
| // mark this one |
| Pla_TtSetBit(pDc, i); |
| Pla_TtSetBit(pDc, i ^ (1 << pDirs[v])); |
| Cubes[10]++; |
| // save |
| Vec_IntPushTwo( vStore, i, pDirs[v] ); |
| continue; |
| } |
| |
| printf( "\n" ); |
| printf( "Truth = %d. ", Pla_TtCountOnes(pOn, nWords) ); |
| printf( "Cover = %d. ", Pla_TtCountOnes(pDc, nWords) ); |
| printf( "\n" ); |
| |
| printf( "Count: " ); |
| for ( i = 0; i < 16; i++ ) |
| if ( Count[i] ) |
| printf( "%d=%d ", i, Count[i] ); |
| printf( "\n" ); |
| |
| printf( "Cubes: " ); |
| for ( i = 0; i < 16; i++ ) |
| if ( Cubes[i] ) |
| printf( "%d=%d ", i, Cubes[i] ); |
| printf( "\n" ); |
| |
| /* |
| // extract cubes one at a time |
| for ( i = 0; i < nMints; i++ ) |
| if ( Pla_TtGetBit(pOn, i) ) |
| { |
| word Cube = 0; |
| for ( v = 0; v < nVars; v++ ) |
| if ( (i >> v) & 1 ) |
| Pla_CubeSetLit( &Cube, v, PLA_LIT_ONE ); |
| else |
| Pla_CubeSetLit( &Cube, v, PLA_LIT_ZERO ); |
| Vec_WrdPush( vCubes, Cube ); |
| } |
| */ |
| Vec_IntForEachEntryDouble( vStore, iMint, iVar, i ) |
| { |
| word Cube = 0; |
| for ( v = 0; v < nVars; v++ ) |
| { |
| if ( v == iVar ) |
| continue; |
| if ( (iMint >> v) & 1 ) |
| Pla_CubeSetLit( &Cube, v, PLA_LIT_ONE ); |
| else |
| Pla_CubeSetLit( &Cube, v, PLA_LIT_ZERO ); |
| } |
| Vec_WrdPush( vCubes, Cube ); |
| } |
| Vec_IntFree( vStore ); |
| |
| // collect the minterms |
| ABC_FREE( pDc ); |
| return vCubes; |
| } |
| Pla_Man_t * Pla_ManFxPrepare( int nVars ) |
| { |
| Pla_Man_t * p; char Buffer[1000]; |
| Vec_Bit_t * vFunc = Pla_ManPrimesTable( nVars ); |
| Vec_Wrd_t * vSop = Pla_ManFxMinimize( (word *)Vec_BitArray(vFunc), nVars ); |
| word Cube, * pCube = &Cube; int i, k, Lit; |
| sprintf( Buffer, "primes%02d", nVars ); |
| p = Pla_ManAlloc( Buffer, nVars, 1, Vec_WrdSize(vSop) ); |
| Vec_WecInit( &p->vCubeLits, Pla_ManCubeNum(p) ); |
| Vec_WecInit( &p->vOccurs, 2*Pla_ManInNum(p) ); |
| Vec_WrdForEachEntry( vSop, Cube, i ) |
| Pla_CubeForEachLit( nVars, pCube, Lit, k ) |
| if ( Lit != PLA_LIT_DASH ) |
| { |
| Lit = Abc_Var2Lit( k, Lit == PLA_LIT_ZERO ); |
| Vec_WecPush( &p->vCubeLits, i, Lit ); |
| Vec_WecPush( &p->vOccurs, Lit, i ); |
| } |
| Vec_BitFree( vFunc ); |
| Vec_WrdFree( vSop ); |
| return p; |
| } |
| int Pla_ManFxPerformSimple( int nVars ) |
| { |
| char Buffer[100]; |
| Pla_Man_t * p = Pla_ManFxPrepare( nVars ); |
| sprintf( Buffer, "primesmin%02d.pla", nVars ); |
| Pla_ManDumpPla( p, Buffer ); |
| Pla_ManFree( p ); |
| return 1; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
