path: root/src/aig/gia/giaGig.c

/**CFile****************************************************************

  FileName    [giaGig.c]

  SystemName  [ABC: Logic synthesis and verification system.]

  PackageName [Scalable AIG package.]

  Synopsis    [Parser for Gate-Inverter Graph by Niklas Een.]

  Author      [Alan Mishchenko]
  
  Affiliation [UC Berkeley]

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

  Revision    [$Id: giaGig.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]

***********************************************************************/

#include "gia.h"
#include "misc/extra/extra.h"
#include "misc/util/utilTruth.h"

ABC_NAMESPACE_IMPL_START


////////////////////////////////////////////////////////////////////////
///                        DECLARATIONS                              ///
////////////////////////////////////////////////////////////////////////

#define MAX_LINE 1000000

// network types
enum { 
    GLS_NONE = -1,  // not used
    GLS_ZERO =  0,  // zero
    GLS_ONE  =  1,  // one
    GLS_PI   =  2,  // primary input
    GLS_PO   =  3,  // primary output
    GLS_BAR  =  4,  // barrier
    GLS_SEQ  =  5,  // sequential
    GLS_SEL  =  6,  // fan
    GLS_LUT4 =  7,  // LUT4
    GLS_LUT6 =  8,  // LUT6
    GLS_BOX  =  9,  // sequential box
    GLS_DEL  = 10,  // delay box
    GLS_FINAL
};

static char * s_Strs[GLS_FINAL] =
{
    "0",     // GLS_ZERO =  0,  // zero
    "1",     // GLS_ONE  =  1,  // one
    "PI",    // GLS_PI   =  2,  // primary input
    "PO",    // GLS_PO   =  3,  // primary output
    "Bar",   // GLS_BAR  =  4,  // barrier
    "Seq",   // GLS_SEQ  =  5,  // sequential
    "Sel",   // GLS_SEL  =  6,  // fan
    "Lut4",  // GLS_LUT4 =  7,  // LUT4
    "Lut6",  // GLS_LUT6 =  8,  // LUT6
    "Box",   // GLS_BOX  =  9,  // sequential box
    "Del"    // GLS_DEL  = 10,  // delay box
};

typedef struct Gls_Man_t_ Gls_Man_t;
struct Gls_Man_t_
{
    // general
    Vec_Str_t *    vLines;       // line types
    Vec_Str_t *    vTypes;       // gate types
    Vec_Int_t *    vIndexes;     // gate indexes
    // specific types
    Vec_Int_t *    vLut4s;       // 4-LUTs (4-tuples)
    Vec_Int_t *    vLut4TTs;     // truth tables
    Vec_Int_t *    vLut6s;       // 6-LUTs (6-tuples)
    Vec_Wrd_t *    vLut6TTs;     // truth tables
    Vec_Int_t *    vBoxes;       // boxes (5-tuples)
    Vec_Wec_t *    vDelayIns;    // delay fanins
    Vec_Wec_t *    vDelayOuts;   // delay fanouts
    Vec_Int_t *    vDelays;      // delay values
    // ordering
    Vec_Int_t *    vOrderPis;  
    Vec_Int_t *    vOrderPos;  
    Vec_Int_t *    vOrderBoxes;  
    Vec_Int_t *    vOrderDelays;  
    Vec_Int_t *    vOrderLuts;  
    Vec_Int_t *    vOrderSeqs;  
};

////////////////////////////////////////////////////////////////////////
///                     FUNCTION DEFINITIONS                         ///
////////////////////////////////////////////////////////////////////////

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Gls_Man_t * Gls_ManAlloc( Vec_Str_t * vLines, int * pCounts )
{
    Gls_Man_t * p = ABC_CALLOC( Gls_Man_t, 1 );
    p->vLines     = vLines;
    p->vTypes     = Vec_StrStart( Vec_StrSize(vLines)+100 ); 
    p->vIndexes   = Vec_IntStart( Vec_StrSize(vLines)+100 ); 
    p->vLut4s     = Vec_IntAlloc( 4 * pCounts[GLS_LUT4] );
    p->vLut4TTs   = Vec_IntAlloc( pCounts[GLS_LUT4] );
    p->vLut6s     = Vec_IntAlloc( 6 * pCounts[GLS_LUT6] );
    p->vLut6TTs   = Vec_WrdAlloc( pCounts[GLS_LUT6] );
    p->vBoxes     = Vec_IntAlloc( 5 * pCounts[GLS_BOX] );
    p->vDelays    = Vec_IntAlloc( pCounts[GLS_DEL] );
    p->vDelayIns  = Vec_WecAlloc( pCounts[GLS_DEL] );
    p->vDelayOuts = Vec_WecAlloc( pCounts[GLS_DEL] );
    // ordering
    p->vOrderPis    = Vec_IntAlloc( pCounts[GLS_PI] );
    p->vOrderPos    = Vec_IntAlloc( pCounts[GLS_PO] );
    p->vOrderBoxes  = Vec_IntAlloc( pCounts[GLS_BOX] );
    p->vOrderDelays = Vec_IntAlloc( pCounts[GLS_DEL] );
    p->vOrderLuts   = Vec_IntAlloc( pCounts[GLS_LUT4] + pCounts[GLS_LUT6] + 2*pCounts[GLS_BAR] );
    p->vOrderSeqs   = Vec_IntAlloc( pCounts[GLS_SEQ] );
    return p;
}
void Gls_ManStop( Gls_Man_t * p )
{
    Vec_StrFree( p->vLines );
    Vec_StrFree( p->vTypes );
    Vec_IntFree( p->vIndexes );
    Vec_IntFree( p->vLut4s );
    Vec_IntFree( p->vLut4TTs );
    Vec_IntFree( p->vLut6s );
    Vec_WrdFree( p->vLut6TTs );
    Vec_IntFree( p->vBoxes );
    Vec_IntFree( p->vDelays );
    Vec_WecFree( p->vDelayIns );
    Vec_WecFree( p->vDelayOuts );
    // ordering
    Vec_IntFree( p->vOrderPis );
    Vec_IntFree( p->vOrderPos );
    Vec_IntFree( p->vOrderBoxes );
    Vec_IntFree( p->vOrderDelays );
    Vec_IntFree( p->vOrderLuts );
    Vec_IntFree( p->vOrderSeqs );
    ABC_FREE( p );
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Vec_Str_t * Gls_ManCount( FILE * pFile, int pCounts[GLS_FINAL] )
{
    char * pLine, * pBuffer = ABC_ALLOC(char, MAX_LINE); int Type;
    Vec_Str_t * vLines = Vec_StrAlloc( 10000 );
    memset( pCounts, 0, sizeof(int)*GLS_FINAL );
    while ( fgets( pBuffer, MAX_LINE, pFile ) != NULL )
    {
        pLine = pBuffer;
        while ( *pLine )
            if ( *pLine++ == '=' )
                break;
        while ( *pLine == ' ' )
            pLine++;
        if ( *pLine == 'L' )
        {
            if ( pLine[3] == '4' )
                Type = GLS_LUT4;
            else if ( pLine[3] == '6' )
                Type = GLS_LUT6;
            else assert( 0 );
        }
        else if ( *pLine == 'P' )
        {
            if ( pLine[1] == 'I' )
                Type = GLS_PI;
            else if ( pLine[1] == 'O' )
                Type = GLS_PO;
            else assert( 0 );
        }
        else if ( *pLine == 'B' )
        {
            if ( pLine[1] == 'o' )
                Type = GLS_BOX;
            else if ( pLine[1] == 'a' )
                Type = GLS_BAR;
            else assert( 0 );
        }
        else if ( *pLine == 'S' )
        {
            if ( pLine[2] == 'l' )
                Type = GLS_SEL;
            else if ( pLine[2] == 'q' )
                Type = GLS_SEQ;
            else assert( 0 );
        }
        else if ( *pLine == 'D' )
            Type = GLS_DEL;
        else assert( 0 );
        Vec_StrPush( vLines, (char)Type );
        pCounts[Type]++;
    }
    ABC_FREE( pBuffer );
    return vLines;
}
int Gls_ManParseOne( char ** ppLine )
{
    int Entry;
    char * pLine = *ppLine;
    while ( *pLine == ' ' )   pLine++;
    if ( *pLine == '-' )
        Entry = GLS_NONE;
    else if ( *pLine == '0' )
        Entry = 0;
    else if ( *pLine == '1' )
        Entry = 1;
    else if ( *pLine == 'w' )
        Entry = atoi(++pLine);
    else assert( 0 );
    while ( *pLine == '-' || (*pLine >= '0' && *pLine <= '9') )   pLine++;
    while ( *pLine == ' ' )   pLine++;
    *ppLine = pLine;
    return Entry;
}
int Gls_ManParse( FILE * pFile, Gls_Man_t * p )
{
    char * pLine, * pBuffer = ABC_ALLOC(char, MAX_LINE); 
    int i, k, Type, iObj, Entry, iItem;  word Truth;
    for ( i = 0; fgets( pBuffer, MAX_LINE, pFile ) != NULL; i++ )
    {
        pLine = pBuffer;
        Type = Vec_StrEntry( p->vLines, i );
        iObj = Gls_ManParseOne( &pLine );
        Vec_StrWriteEntry( p->vTypes, iObj, (char)Type );
        if ( Type == GLS_PI )
        {
            Vec_IntPush( p->vOrderPis, iObj );
            Vec_IntWriteEntry( p->vIndexes, iObj, -1 );
            continue;
        }
        while ( *pLine )
            if ( *pLine++ == '(' )
                break;
        Entry = Gls_ManParseOne( &pLine );
        if ( Type == GLS_PO || Type == GLS_BAR || Type == GLS_SEQ || Type == GLS_SEL )
        {
            if ( Type == GLS_PO )
                Vec_IntPush( p->vOrderPos, iObj );
            else if ( Type == GLS_BAR )
                Vec_IntPush( p->vOrderLuts, iObj );
            else if ( Type == GLS_SEQ )
                Vec_IntPush( p->vOrderSeqs, iObj );
            else if ( Type == GLS_SEL )
            {
                if ( (int)Vec_StrEntry(p->vTypes, Entry) == GLS_DEL )
                {
                    Vec_Int_t * vOuts = Vec_WecEntry( p->vDelayOuts, Vec_IntEntry(p->vIndexes, Entry) );
                    Vec_IntPush( vOuts, iObj );
                }
                else if ( (int)Vec_StrEntry(p->vTypes, Entry) == GLS_BAR )
                    Vec_IntPush( p->vOrderLuts, iObj );
                else assert( 0 );
            }
            Vec_IntWriteEntry( p->vIndexes, iObj, Entry );
            continue;
        }
        if ( Type == GLS_LUT4 )
        {
            Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vLut4TTs) );
            Vec_IntPush( p->vLut4s, Entry );
            for ( k = 1; ; k++ )
            {
                if ( *pLine != ',' )     break;
                pLine++;
                Entry = Gls_ManParseOne( &pLine );
                Vec_IntPush( p->vLut4s, Entry );
            }
            assert( *pLine == ')' );
            assert( k == 4 );
            pLine++;
            while ( *pLine )
                if ( *pLine++ == '[' )
                    break;
            Abc_TtReadHex( &Truth, pLine );
            Vec_IntPush( p->vLut4TTs, (unsigned)Truth );
            Vec_IntPush( p->vOrderLuts, iObj );
        }
        else if ( Type == GLS_LUT6 )
        {
            Vec_IntWriteEntry( p->vIndexes, iObj, Vec_WrdSize(p->vLut6TTs) );
            Vec_IntPush( p->vLut6s, Entry );
            for ( k = 1; ; k++ )
            {
                if ( *pLine != ',' )     break;
                pLine++;
                Entry = Gls_ManParseOne( &pLine );
                Vec_IntPush( p->vLut6s, Entry );
            }
            assert( *pLine == ')' );
            assert( k == 4 );
            pLine++;
            while ( *pLine )
                if ( *pLine++ == '[' )
                    break;
            Abc_TtReadHex( &Truth, pLine );
            Vec_WrdPush( p->vLut6TTs, Truth );
            Vec_IntPush( p->vOrderLuts, iObj );
        }
        else if ( Type == GLS_BOX )
        {
            Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vBoxes)/5 );
            Vec_IntPush( p->vBoxes, Entry );
            for ( k = 1; ; k++ )
            {
                if ( *pLine != ',' )     break;
                pLine++;
                Entry = Gls_ManParseOne( &pLine );
                Vec_IntPush( p->vBoxes, Entry );
            }
            assert( *pLine == ')' );
            assert( k == 4 || k == 5 );
            if ( k == 4 )
                Vec_IntPush( p->vBoxes, GLS_NONE );
            Vec_IntPush( p->vOrderBoxes, iObj );
        }
        else if ( Type == GLS_DEL )
        {
            Vec_Int_t * vIns  = Vec_WecPushLevel( p->vDelayIns );
            Vec_Int_t * vOuts = Vec_WecPushLevel( p->vDelayOuts );
            Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vDelays) );
            Vec_IntPush( vIns, Entry );
            if ( *pLine != ')' )
            {
                for ( k = 1; ; k++ )
                {
                    if ( *pLine != ',' )     break;
                    pLine++;
                    Entry = Gls_ManParseOne( &pLine );
                    Vec_IntPush( vIns, Entry );
                }
            }
            assert( *pLine == ')' );
            pLine++;
            while ( *pLine )
                if ( *pLine++ == '[' )
                    break;
            iItem = atoi(pLine);
            Vec_IntPush( p->vDelays, iItem );
            Vec_IntPush( p->vOrderDelays, iObj );
            vOuts = vIns; // harmless use to prevent a compiler warning
        }
        else assert( 0 );
    }
    ABC_FREE( pBuffer );
    return 1;
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Gia_Man_t * Gls_ManConstruct( Gls_Man_t * p, char * pFileName )
{
    extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash );
    Gia_Man_t * pGia = NULL;  
    Vec_Int_t * vMap, * vArray;
    Vec_Int_t * vCover = Vec_IntAlloc(0);
    Vec_Int_t * vLeaves = Vec_IntAlloc(6);
    int  k, iObj, iLit, Index;  char Type;
    // create new manager
    pGia = Gia_ManStart( Vec_StrSize(p->vTypes) );
    pGia->pName = Abc_UtilStrsav( pFileName );
    pGia->pSpec = Abc_UtilStrsav( pFileName );
    // create constants
    vMap = Vec_IntStartFull( Vec_StrSize(p->vTypes) );
    Vec_IntWriteEntry( vMap, 0, 0 );
    Vec_IntWriteEntry( vMap, 1, 1 );
    // create primary inputs
    Vec_IntForEachEntry( p->vOrderPis, iObj, k )
        Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) );
    // create box outputs
    Vec_IntForEachEntry( p->vOrderBoxes, iObj, k )
        Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) );
    // create delay outputs
    Vec_IntForEachEntry( p->vOrderDelays, iObj, Index )
    {
        assert( Index == Vec_IntEntry(p->vIndexes, iObj) );
        vArray = Vec_WecEntry(p->vDelayOuts, Index);
        if ( Vec_IntSize(vArray) == 0 )
            Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) );
        else
            Vec_IntForEachEntry( vArray, iObj, k )
                Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) );
    }
    // construct LUTs
    Vec_IntForEachEntry( p->vOrderLuts, iObj, Index )
    {
        Type = Vec_StrEntry( p->vTypes, iObj );
        if ( Type == GLS_LUT4 || Type == GLS_LUT6 )
        {
            int Limit = Type == GLS_LUT4 ? 4 : 6;
            int Index = Vec_IntEntry(p->vIndexes, iObj);
            int * pFanins = Type == GLS_LUT4 ? Vec_IntEntryP(p->vLut4s, 4*Index) : Vec_IntEntryP(p->vLut6s, 6*Index);
            word Truth = Type == GLS_LUT4 ? (word)Vec_IntEntry(p->vLut4TTs, Index) : Vec_WrdEntry(p->vLut6TTs, Index);
            Vec_IntClear( vLeaves );
            for ( k = 0; k < Limit; k++ )
                Vec_IntPush( vLeaves, pFanins[k] == GLS_NONE ? 0 : Vec_IntEntry(vMap, pFanins[k]) );
            iLit = Kit_TruthToGia( pGia, (unsigned *)&Truth, Vec_IntSize(vLeaves), vCover, vLeaves, 0 );
            Vec_IntWriteEntry( vMap, iObj, iLit );
        }
        else if ( Type == GLS_BAR || Type == GLS_SEL )
        {
            iLit = Vec_IntEntry( vMap, Vec_IntEntry(p->vIndexes, iObj) );
            Vec_IntWriteEntry( vMap, iObj, iLit );
        }
    }
    // delay inputs
    Vec_IntForEachEntry( p->vOrderDelays, iObj, Index )
    {
        vArray = Vec_WecEntry(p->vDelayIns, Index);
        assert( Vec_IntSize(vArray) > 0 );
        Vec_IntForEachEntry( vArray, iObj, k )
            Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, iObj) );
    }
    // create primary outputs
    Vec_IntForEachEntry( p->vOrderPos, iObj, k )
        Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, Vec_IntEntry(p->vIndexes, iObj)) );
    // create sequential nodes
    Vec_IntForEachEntry( p->vOrderSeqs, iObj, k )
        Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, Vec_IntEntry(p->vIndexes, iObj)) );
    Vec_IntFree( vMap );
    Vec_IntFree( vCover );
    Vec_IntFree( vLeaves );
    // print delay boxes
//    for ( k = 0; k < Vec_IntSize(p->vDelays); k++ )
//        printf( "%d:%d  ", Vec_IntSize(Vec_WecEntry(p->vDelayIns, k)), Vec_IntSize(Vec_WecEntry(p->vDelayOuts, k)) );
//    printf( "\n" );
    return pGia;
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Gia_Man_t * Gia_ManReadGig( char * pFileName )
{
    abctime clk = Abc_Clock();
    Gls_Man_t * p = NULL;
    Gia_Man_t * pGia = NULL;
    Vec_Str_t * vLines;
    int i, pCounts[GLS_FINAL];
    FILE * pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot read file \"%s\".\n", pFileName );
        return NULL;
    }
    vLines = Gls_ManCount( pFile, pCounts );
    rewind( pFile );
    // statistics
    for ( i = 0; i < GLS_FINAL; i++ )
        if ( pCounts[i] )
            printf( "%s=%d  ", s_Strs[i], pCounts[i] );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    // collect data and derive AIG
    p = Gls_ManAlloc( vLines, pCounts );
    if ( Gls_ManParse( pFile, p ) )
        pGia = Gls_ManConstruct( p, pFileName );
    Gls_ManStop( p );
    fclose( pFile );
    //printf( "\n" );
    return pGia;
}

////////////////////////////////////////////////////////////////////////
///                       END OF FILE                                ///
////////////////////////////////////////////////////////////////////////


ABC_NAMESPACE_IMPL_END