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