plaSimple.c

/**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